From 7cb8676bf78c7bd59b588b11d472a34385d773c8 Mon Sep 17 00:00:00 2001 From: Hashim Date: Sat, 22 Nov 2025 17:32:21 +0300 Subject: [PATCH 1/3] fix: enum particles and inline world exec --- docs/worlds_and_entities.md | 47 + plugin/adapters/plugin/actions.go | 314 +++- plugin/adapters/plugin/event_helpers.go | 37 +- proto/generated/actions.pb.go | 1812 ++++++++++++++++++++--- proto/generated/command.pb.go | 6 +- proto/generated/common.pb.go | 270 +++- proto/generated/mutations.pb.go | 6 +- proto/generated/player_events.pb.go | 6 +- proto/generated/plugin.pb.go | 266 ++-- proto/generated/world_events.pb.go | 6 +- proto/types/actions.proto | 125 ++ proto/types/common.proto | 12 + proto/types/plugin.proto | 1 + 13 files changed, 2480 insertions(+), 428 deletions(-) create mode 100644 docs/worlds_and_entities.md diff --git a/docs/worlds_and_entities.md b/docs/worlds_and_entities.md new file mode 100644 index 0000000..da361c2 --- /dev/null +++ b/docs/worlds_and_entities.md @@ -0,0 +1,47 @@ +# Worlds and Entities Implementation Notes + +This document captures the world- and entity-related behaviours the plugin host mirrors from Dragonfly and that external plugins need to support. + +## World identity and lookup +- World references sent to plugins include both the configured world name and its dimension string (lower-cased) to disambiguate lookups across dimensions. The helper populates `WorldRef` with `Name` and `Dimension` derived from the `world.World` instance. 【F:plugin/adapters/plugin/event_helpers.go†L164-L173】 +- Incoming `WorldRef` values from plugins are resolved by name first, then by dimension string if the name is empty or unknown. Registered worlds are stored in a lower-cased map keyed by name; dimension matching also lower-cases. 【F:plugin/adapters/plugin/manager.go†L378-L427】 +- Worlds are registered when the manager attaches to them and unregistered after a `WORLD_CLOSE` event is emitted so stale references are not reused. 【F:plugin/adapters/plugin/world_events.go†L192-L203】 + +## World configuration and range management +- Dragonfly exposes runtime setters such as `SetDefaultGameMode`, `SetDifficulty`, and `SetTickRange` to adjust core world behaviour. The plugin bridge needs to surface these so plugins can match the server’s world state and react when these settings change. +- World `Range` queries control which chunks are loaded or targeted for tick updates. Any plugin-facing API that performs block mutations or entity searches should obey the configured range. +- World-level effects such as `PlaySound`, `AddParticle`, and `SetBlock` require positional parameters relative to the world’s chunk range and dimension to avoid inconsistencies when multiple worlds are present. + +## World event surface area +- The plugin world handler hooks into Dragonfly’s `world.Handler` and forwards each server callback into the event stream (`WORLD_*` event types). Implementations must wire the handler for close, liquid flow/decay/hardening, sound playback, fire spread, block burn, crop trample, leaves decay, entity spawn/despawn, and explosions. 【F:plugin/adapters/handlers/world.go†L12-L67】 +- Each event payload contains a `WorldRef` plus context-specific data: + - Liquid flow, decay, and harden events include source/target block positions and liquid or block states. 【F:plugin/adapters/plugin/world_events.go†L13-L55】 + - World sounds include the emitted sound type (stringified Go type) and 3D position. 【F:plugin/adapters/plugin/world_events.go†L57-L68】 + - Fire spread, block burn, crop trample, and leaves decay send the relevant block positions. 【F:plugin/adapters/plugin/world_events.go†L70-L117】 + - Entity spawn/despawn events bundle the entity reference alongside the world reference. 【F:plugin/adapters/plugin/world_events.go†L119-L141】 + - Explosions surface the epicenter, affected entities/blocks, and the calculated item-drop chance and spawn-fire flags, which plugins may mutate. 【F:plugin/adapters/plugin/world_events.go†L143-L190】【F:proto/types/mutations.proto†L9-L100】 + - World close broadcasts the world reference and immediately unregisters the world so further lookups fail until it is reattached. 【F:plugin/adapters/plugin/world_events.go†L192-L203】 + +## Entity representation +- Entities are serialized to `EntityRef` with their Go type name, UUID (when available from the entity handle), position, and rotation. This data allows plugins to recognize entities and correlate later mutations (such as explosion filtering). 【F:plugin/adapters/plugin/event_helpers.go†L199-L226】【F:proto/types/common.proto†L109-L120】 +- Entity refs appear in spawn/despawn events and as the optional `affected_entities` list in explosions for selective mutation by plugins. Filtering uses plugin-supplied UUID lists to drop entities from the explosion impact set. 【F:plugin/adapters/plugin/world_events.go†L119-L190】【F:proto/types/world_events.proto†L59-L76】 + +## Entity lifecycle and querying +- World transactions expose `AddEntity`/`RemoveEntity` to add or detach entities; removal invalidates the handle returned by spawn to mirror Dragonfly’s semantics. Plugins should receive enough context to track these lifecycle changes and avoid reusing stale references. +- Entity iteration helpers (`Entities`, `Players`, `EntitiesWithin`) must be mirrored so plugins can enumerate everything in a world or filter by bounding box. Bounding boxes follow Dragonfly’s `cube.BBox` conventions and should consider the world’s tick range when evaluating membership. +- Viewer lookups (`Viewers`) are used to target updates (sounds, particles, block updates) to interested clients. Even if the viewer interface itself is not directly exposed, the plugin layer should provide enough information to deliver per-viewer or per-position updates consistently. + +## World and block state serialization +- Block positions are converted into `BlockPos` tuples; block and liquid states encode the block name and property map or liquid depth/falling flags and type. These representations show up across world events (liquid changes, explosion block lists). 【F:plugin/adapters/plugin/event_helpers.go†L53-L92】【F:proto/types/common.proto†L85-L120】 +- Liquid/block conversions accept both liquids and non-liquid blocks when populating liquid hardening events, ensuring plugins see the before/after composition. 【F:plugin/adapters/plugin/world_events.go†L42-L55】【F:plugin/adapters/plugin/event_helpers.go†L72-L92】 + +## World explosion mutation semantics +- Explosion events are cancellable and support mutations to the affected entity list, block positions, item drop chance, and whether fire is spawned. Mutation handlers apply plugin-specified UUID filters and block lists back into Dragonfly structures, or clear them when plugins supply empty/invalid data. 【F:plugin/adapters/plugin/world_events.go†L143-L190】 +- The protocol exposes the mutable fields through `WorldExplosionMutation` so plugins can remove specific entities/blocks or adjust drop probability and fire. Ensure plugin responses are processed in order so multiple plugins can compose mutations. 【F:proto/types/mutations.proto†L9-L100】 + +## Required proto coverage +- The `world_events.proto` schema lists every world-facing event type that must be mirrored over gRPC. Implementations should verify outgoing events populate the fields defined there and that incoming mutations respect optionality. 【F:proto/types/world_events.proto†L9-L80】 +- `common.proto` defines the reusable structures (world refs, entity refs, block/liquid state, vectors) that need consistent encoding/decoding across host and plugin runtimes. 【F:proto/types/common.proto†L85-L120】 + +## Structures and world composition +- Dragonfly supports loading and placing structures at runtime via `world/structure.go`. Plugins that author or paste structures need hooks to schedule placement, manage rotation/mirroring, and resolve collisions with existing blocks or entities within the world’s configured range and dimension. diff --git a/plugin/adapters/plugin/actions.go b/plugin/adapters/plugin/actions.go index 30efe8f..274f3f7 100644 --- a/plugin/adapters/plugin/actions.go +++ b/plugin/adapters/plugin/actions.go @@ -1,9 +1,9 @@ package plugin import ( - "strings" "time" + "github.com/df-mc/dragonfly/server/block/cube" "github.com/df-mc/dragonfly/server/entity" "github.com/df-mc/dragonfly/server/entity/effect" "github.com/df-mc/dragonfly/server/item" @@ -11,6 +11,7 @@ import ( "github.com/df-mc/dragonfly/server/player/chat" "github.com/df-mc/dragonfly/server/player/title" "github.com/df-mc/dragonfly/server/world" + "github.com/df-mc/dragonfly/server/world/particle" "github.com/df-mc/dragonfly/server/world/sound" "github.com/go-gl/mathgl/mgl64" "github.com/google/uuid" @@ -25,6 +26,7 @@ func (m *Manager) applyActions(p *pluginProcess, batch *pb.ActionBatch) { if action == nil { continue } + correlationID := action.GetCorrelationId() switch kind := action.Kind.(type) { case *pb.Action_SendChat: m.handleSendChat(kind.SendChat) @@ -62,6 +64,26 @@ func (m *Manager) applyActions(p *pluginProcess, batch *pb.ActionBatch) { m.handlePlaySound(kind.PlaySound) case *pb.Action_ExecuteCommand: m.handleExecuteCommand(kind.ExecuteCommand) + case *pb.Action_WorldSetDefaultGameMode: + m.handleWorldSetDefaultGameMode(p, correlationID, kind.WorldSetDefaultGameMode) + case *pb.Action_WorldSetDifficulty: + m.handleWorldSetDifficulty(p, correlationID, kind.WorldSetDifficulty) + case *pb.Action_WorldSetTickRange: + m.handleWorldSetTickRange(p, correlationID, kind.WorldSetTickRange) + case *pb.Action_WorldSetBlock: + m.handleWorldSetBlock(p, correlationID, kind.WorldSetBlock) + case *pb.Action_WorldPlaySound: + m.handleWorldPlaySound(p, correlationID, kind.WorldPlaySound) + case *pb.Action_WorldAddParticle: + m.handleWorldAddParticle(p, correlationID, kind.WorldAddParticle) + case *pb.Action_WorldQueryEntities: + m.handleWorldQueryEntities(p, correlationID, kind.WorldQueryEntities) + case *pb.Action_WorldQueryPlayers: + m.handleWorldQueryPlayers(p, correlationID, kind.WorldQueryPlayers) + case *pb.Action_WorldQueryEntitiesWithin: + m.handleWorldQueryEntitiesWithin(p, correlationID, kind.WorldQueryEntitiesWithin) + case *pb.Action_WorldQueryViewers: + m.handleWorldQueryViewers(p, correlationID, kind.WorldQueryViewers) } } } @@ -338,6 +360,218 @@ func (m *Manager) handleExecuteCommand(act *pb.ExecuteCommandAction) { }) } +func (m *Manager) handleWorldSetDefaultGameMode(p *pluginProcess, correlationID string, act *pb.WorldSetDefaultGameModeAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + mode, ok := world.GameModeByID(int(act.GameMode)) + if !ok { + m.sendActionError(p, correlationID, "unknown game mode") + return + } + w.SetDefaultGameMode(mode) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldSetDifficulty(p *pluginProcess, correlationID string, act *pb.WorldSetDifficultyAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + diff, ok := world.DifficultyByID(int(act.Difficulty)) + if !ok { + m.sendActionError(p, correlationID, "unknown difficulty") + return + } + w.SetDifficulty(diff) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldSetTickRange(p *pluginProcess, correlationID string, act *pb.WorldSetTickRangeAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + if act.TickRange < 0 { + m.sendActionError(p, correlationID, "tick range must be non-negative") + return + } + w.SetTickRange(int(act.TickRange)) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldSetBlock(p *pluginProcess, correlationID string, act *pb.WorldSetBlockAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + if act.Position == nil { + m.sendActionError(p, correlationID, "missing position") + return + } + pos := cube.Pos{int(act.Position.X), int(act.Position.Y), int(act.Position.Z)} + var blk world.Block + var ok bool + if act.Block != nil { + blk, ok = blockFromProto(act.Block) + if !ok { + m.sendActionError(p, correlationID, "unknown block") + return + } + } + <-w.Exec(func(tx *world.Tx) { + tx.SetBlock(pos, blk, nil) + }) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldPlaySound(p *pluginProcess, correlationID string, act *pb.WorldPlaySoundAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + pos, ok := vec3FromProto(act.Position) + if !ok { + m.sendActionError(p, correlationID, "invalid position") + return + } + s := soundFromProto(act.Sound) + <-w.Exec(func(tx *world.Tx) { + tx.PlaySound(pos, s) + }) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldAddParticle(p *pluginProcess, correlationID string, act *pb.WorldAddParticleAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + pos, ok := vec3FromProto(act.Position) + if !ok { + m.sendActionError(p, correlationID, "invalid position") + return + } + part, ok := particleFromProto(act) + if !ok { + m.sendActionError(p, correlationID, "unknown particle") + return + } + <-w.Exec(func(tx *world.Tx) { + tx.AddParticle(pos, part) + }) + m.sendActionOK(p, correlationID) +} + +func (m *Manager) handleWorldQueryEntities(p *pluginProcess, correlationID string, act *pb.WorldQueryEntitiesAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + entities := make([]world.Entity, 0) + <-w.Exec(func(tx *world.Tx) { + for e := range tx.Entities() { + entities = append(entities, e) + } + }) + m.sendActionResult(p, &pb.ActionResult{ + CorrelationId: correlationID, + Status: &pb.ActionStatus{Ok: true}, + Result: &pb.ActionResult_WorldEntities{WorldEntities: &pb.WorldEntitiesResult{ + World: protoWorldRef(w), + Entities: protoEntityRefs(entities), + }}, + }) +} + +func (m *Manager) handleWorldQueryPlayers(p *pluginProcess, correlationID string, act *pb.WorldQueryPlayersAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + players := make([]world.Entity, 0) + <-w.Exec(func(tx *world.Tx) { + for pl := range tx.Players() { + players = append(players, pl) + } + }) + m.sendActionResult(p, &pb.ActionResult{ + CorrelationId: correlationID, + Status: &pb.ActionStatus{Ok: true}, + Result: &pb.ActionResult_WorldPlayers{WorldPlayers: &pb.WorldPlayersResult{ + World: protoWorldRef(w), + Players: protoEntityRefs(players), + }}, + }) +} + +func (m *Manager) handleWorldQueryEntitiesWithin(p *pluginProcess, correlationID string, act *pb.WorldQueryEntitiesWithinAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + box, ok := bboxFromProto(act.Box) + if !ok { + m.sendActionError(p, correlationID, "invalid bounding box") + return + } + entities := make([]world.Entity, 0) + <-w.Exec(func(tx *world.Tx) { + for e := range tx.EntitiesWithin(box) { + entities = append(entities, e) + } + }) + m.sendActionResult(p, &pb.ActionResult{ + CorrelationId: correlationID, + Status: &pb.ActionStatus{Ok: true}, + Result: &pb.ActionResult_WorldEntitiesWithin{WorldEntitiesWithin: &pb.WorldEntitiesWithinResult{ + World: protoWorldRef(w), + Box: protoBBox(box), + Entities: protoEntityRefs(entities), + }}, + }) +} + +func (m *Manager) handleWorldQueryViewers(p *pluginProcess, correlationID string, act *pb.WorldQueryViewersAction) { + w := m.worldFromRef(act.GetWorld()) + if w == nil { + m.sendActionError(p, correlationID, "world not found") + return + } + pos, ok := vec3FromProto(act.Position) + if !ok { + m.sendActionError(p, correlationID, "invalid position") + return + } + viewers := make([]string, 0) + <-w.Exec(func(tx *world.Tx) { + for _, v := range tx.Viewers(pos) { + if pl, ok := v.(*player.Player); ok { + viewers = append(viewers, pl.UUID().String()) + } + } + }) + m.sendActionResult(p, &pb.ActionResult{ + CorrelationId: correlationID, + Status: &pb.ActionStatus{Ok: true}, + Result: &pb.ActionResult_WorldViewers{WorldViewers: &pb.WorldViewersResult{ + World: protoWorldRef(w), + Position: protoVec3(pos), + ViewerUuids: viewers, + }}, + }) +} + func (m *Manager) execMethod(id uuid.UUID, method func(pl *player.Player)) { if m.srv == nil { return @@ -351,6 +585,30 @@ func (m *Manager) execMethod(id uuid.UUID, method func(pl *player.Player)) { } } +func (m *Manager) sendActionResult(p *pluginProcess, result *pb.ActionResult) { + if p == nil || result == nil || result.CorrelationId == "" { + return + } + p.queue(&pb.HostToPlugin{ + PluginId: p.id, + Payload: &pb.HostToPlugin_ActionResult{ActionResult: result}, + }) +} + +func (m *Manager) sendActionOK(p *pluginProcess, correlationID string) { + if correlationID == "" { + return + } + m.sendActionResult(p, &pb.ActionResult{CorrelationId: correlationID, Status: &pb.ActionStatus{Ok: true}}) +} + +func (m *Manager) sendActionError(p *pluginProcess, correlationID, msg string) { + if correlationID == "" { + return + } + m.sendActionResult(p, &pb.ActionResult{CorrelationId: correlationID, Status: &pb.ActionStatus{Ok: false, Error: &msg}}) +} + func soundFromProto(s pb.Sound) world.Sound { switch s { case pb.Sound_ATTACK: @@ -398,6 +656,60 @@ func soundFromProto(s pb.Sound) world.Sound { } } +func particleFromProto(act *pb.WorldAddParticleAction) (world.Particle, bool) { + switch act.GetParticle() { + case pb.ParticleType_PARTICLE_HUGE_EXPLOSION: + return particle.HugeExplosion{}, true + case pb.ParticleType_PARTICLE_ENDERMAN_TELEPORT: + return particle.EndermanTeleport{}, true + case pb.ParticleType_PARTICLE_SNOWBALL_POOF: + return particle.SnowballPoof{}, true + case pb.ParticleType_PARTICLE_EGG_SMASH: + return particle.EggSmash{}, true + case pb.ParticleType_PARTICLE_SPLASH: + return particle.Splash{}, true + case pb.ParticleType_PARTICLE_EFFECT: + return particle.Effect{}, true + case pb.ParticleType_PARTICLE_ENTITY_FLAME: + return particle.EntityFlame{}, true + case pb.ParticleType_PARTICLE_FLAME: + return particle.Flame{}, true + case pb.ParticleType_PARTICLE_DUST: + return particle.Dust{}, true + case pb.ParticleType_PARTICLE_BLOCK_FORCE_FIELD: + return particle.BlockForceField{}, true + case pb.ParticleType_PARTICLE_BONE_MEAL: + return particle.BoneMeal{}, true + case pb.ParticleType_PARTICLE_EVAPORATE: + return particle.Evaporate{}, true + case pb.ParticleType_PARTICLE_WATER_DRIP: + return particle.WaterDrip{}, true + case pb.ParticleType_PARTICLE_LAVA_DRIP: + return particle.LavaDrip{}, true + case pb.ParticleType_PARTICLE_LAVA: + return particle.Lava{}, true + case pb.ParticleType_PARTICLE_DUST_PLUME: + return particle.DustPlume{}, true + case pb.ParticleType_PARTICLE_BLOCK_BREAK: + if act.Block != nil { + if blk, ok := blockFromProto(act.Block); ok { + return particle.BlockBreak{Block: blk}, true + } + } + case pb.ParticleType_PARTICLE_PUNCH_BLOCK: + if act.Block != nil { + if blk, ok := blockFromProto(act.Block); ok { + face := cube.Face(0) + if act.Face != nil { + face = cube.Face(*act.Face) + } + return particle.PunchBlock{Block: blk, Face: face}, true + } + } + } + return nil, false +} + func playerTitleFromAction(act *pb.SendTitleAction) title.Title { t := title.New(act.Title) if act.Subtitle != nil && *act.Subtitle != "" { diff --git a/plugin/adapters/plugin/event_helpers.go b/plugin/adapters/plugin/event_helpers.go index 2022920..45517f2 100644 --- a/plugin/adapters/plugin/event_helpers.go +++ b/plugin/adapters/plugin/event_helpers.go @@ -3,6 +3,7 @@ package plugin import ( "fmt" "net" + "strconv" "strings" "github.com/df-mc/dragonfly/server/block/cube" @@ -50,6 +51,17 @@ func protoRotation(r cube.Rotation) *pb.Rotation { return &pb.Rotation{Yaw: float32(yaw), Pitch: float32(pitch)} } +func protoBBox(box cube.BBox) *pb.BBox { + return &pb.BBox{Min: protoVec3(box.Min()), Max: protoVec3(box.Max())} +} + +func bboxFromProto(box *pb.BBox) (cube.BBox, bool) { + if box == nil || box.Min == nil || box.Max == nil { + return cube.BBox{}, false + } + return cube.Box(box.Min.X, box.Min.Y, box.Min.Z, box.Max.X, box.Max.Y, box.Max.Z), true +} + func protoBlockPos(pos cube.Pos) *pb.BlockPos { return &pb.BlockPos{X: int32(pos.X()), Y: int32(pos.Y()), Z: int32(pos.Z())} } @@ -129,6 +141,30 @@ func convertProtoItemStackValue(stack *pb.ItemStack) (item.Stack, bool) { return item.NewStack(material, count), true } +func blockFromProto(state *pb.BlockState) (world.Block, bool) { + if state == nil || state.Name == "" { + return nil, false + } + properties := make(map[string]any, len(state.Properties)) + for k, v := range state.Properties { + properties[k] = parsePropertyValue(v) + } + return world.BlockByName(state.Name, properties) +} + +func parsePropertyValue(v string) any { + if b, err := strconv.ParseBool(v); err == nil { + return b + } + if i, err := strconv.ParseInt(v, 10, 64); err == nil { + return int(i) + } + if f, err := strconv.ParseFloat(v, 64); err == nil { + return f + } + return v +} + func convertProtoBlockPositionsToCube(blocks []*pb.BlockPos) []cube.Pos { if len(blocks) == 0 { return nil @@ -272,4 +308,3 @@ func worldFromContext(ctx *world.Context) *world.World { } return tx.World() } - diff --git a/proto/generated/actions.pb.go b/proto/generated/actions.pb.go index cab8eb8..3c3da9f 100644 --- a/proto/generated/actions.pb.go +++ b/proto/generated/actions.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: actions.proto package generated @@ -21,6 +21,103 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) +type ParticleType int32 + +const ( + ParticleType_PARTICLE_TYPE_UNSPECIFIED ParticleType = 0 + ParticleType_PARTICLE_HUGE_EXPLOSION ParticleType = 1 + ParticleType_PARTICLE_ENDERMAN_TELEPORT ParticleType = 2 + ParticleType_PARTICLE_SNOWBALL_POOF ParticleType = 3 + ParticleType_PARTICLE_EGG_SMASH ParticleType = 4 + ParticleType_PARTICLE_SPLASH ParticleType = 5 + ParticleType_PARTICLE_EFFECT ParticleType = 6 + ParticleType_PARTICLE_ENTITY_FLAME ParticleType = 7 + ParticleType_PARTICLE_FLAME ParticleType = 8 + ParticleType_PARTICLE_DUST ParticleType = 9 + ParticleType_PARTICLE_BLOCK_FORCE_FIELD ParticleType = 10 + ParticleType_PARTICLE_BONE_MEAL ParticleType = 11 + ParticleType_PARTICLE_EVAPORATE ParticleType = 12 + ParticleType_PARTICLE_WATER_DRIP ParticleType = 13 + ParticleType_PARTICLE_LAVA_DRIP ParticleType = 14 + ParticleType_PARTICLE_LAVA ParticleType = 15 + ParticleType_PARTICLE_DUST_PLUME ParticleType = 16 + ParticleType_PARTICLE_BLOCK_BREAK ParticleType = 17 + ParticleType_PARTICLE_PUNCH_BLOCK ParticleType = 18 +) + +// Enum value maps for ParticleType. +var ( + ParticleType_name = map[int32]string{ + 0: "PARTICLE_TYPE_UNSPECIFIED", + 1: "PARTICLE_HUGE_EXPLOSION", + 2: "PARTICLE_ENDERMAN_TELEPORT", + 3: "PARTICLE_SNOWBALL_POOF", + 4: "PARTICLE_EGG_SMASH", + 5: "PARTICLE_SPLASH", + 6: "PARTICLE_EFFECT", + 7: "PARTICLE_ENTITY_FLAME", + 8: "PARTICLE_FLAME", + 9: "PARTICLE_DUST", + 10: "PARTICLE_BLOCK_FORCE_FIELD", + 11: "PARTICLE_BONE_MEAL", + 12: "PARTICLE_EVAPORATE", + 13: "PARTICLE_WATER_DRIP", + 14: "PARTICLE_LAVA_DRIP", + 15: "PARTICLE_LAVA", + 16: "PARTICLE_DUST_PLUME", + 17: "PARTICLE_BLOCK_BREAK", + 18: "PARTICLE_PUNCH_BLOCK", + } + ParticleType_value = map[string]int32{ + "PARTICLE_TYPE_UNSPECIFIED": 0, + "PARTICLE_HUGE_EXPLOSION": 1, + "PARTICLE_ENDERMAN_TELEPORT": 2, + "PARTICLE_SNOWBALL_POOF": 3, + "PARTICLE_EGG_SMASH": 4, + "PARTICLE_SPLASH": 5, + "PARTICLE_EFFECT": 6, + "PARTICLE_ENTITY_FLAME": 7, + "PARTICLE_FLAME": 8, + "PARTICLE_DUST": 9, + "PARTICLE_BLOCK_FORCE_FIELD": 10, + "PARTICLE_BONE_MEAL": 11, + "PARTICLE_EVAPORATE": 12, + "PARTICLE_WATER_DRIP": 13, + "PARTICLE_LAVA_DRIP": 14, + "PARTICLE_LAVA": 15, + "PARTICLE_DUST_PLUME": 16, + "PARTICLE_BLOCK_BREAK": 17, + "PARTICLE_PUNCH_BLOCK": 18, + } +) + +func (x ParticleType) Enum() *ParticleType { + p := new(ParticleType) + *p = x + return p +} + +func (x ParticleType) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (ParticleType) Descriptor() protoreflect.EnumDescriptor { + return file_actions_proto_enumTypes[0].Descriptor() +} + +func (ParticleType) Type() protoreflect.EnumType { + return &file_actions_proto_enumTypes[0] +} + +func (x ParticleType) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use ParticleType.Descriptor instead. +func (ParticleType) EnumDescriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{0} +} + type ActionBatch struct { state protoimpl.MessageState `protogen:"open.v1"` Actions []*Action `protobuf:"bytes,1,rep,name=actions,proto3" json:"actions,omitempty"` @@ -88,6 +185,16 @@ type Action struct { // *Action_SendTip // *Action_PlaySound // *Action_ExecuteCommand + // *Action_WorldSetDefaultGameMode + // *Action_WorldSetDifficulty + // *Action_WorldSetTickRange + // *Action_WorldSetBlock + // *Action_WorldPlaySound + // *Action_WorldAddParticle + // *Action_WorldQueryEntities + // *Action_WorldQueryPlayers + // *Action_WorldQueryEntitiesWithin + // *Action_WorldQueryViewers Kind isAction_Kind `protobuf_oneof:"kind"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -299,6 +406,96 @@ func (x *Action) GetExecuteCommand() *ExecuteCommandAction { return nil } +func (x *Action) GetWorldSetDefaultGameMode() *WorldSetDefaultGameModeAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldSetDefaultGameMode); ok { + return x.WorldSetDefaultGameMode + } + } + return nil +} + +func (x *Action) GetWorldSetDifficulty() *WorldSetDifficultyAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldSetDifficulty); ok { + return x.WorldSetDifficulty + } + } + return nil +} + +func (x *Action) GetWorldSetTickRange() *WorldSetTickRangeAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldSetTickRange); ok { + return x.WorldSetTickRange + } + } + return nil +} + +func (x *Action) GetWorldSetBlock() *WorldSetBlockAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldSetBlock); ok { + return x.WorldSetBlock + } + } + return nil +} + +func (x *Action) GetWorldPlaySound() *WorldPlaySoundAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldPlaySound); ok { + return x.WorldPlaySound + } + } + return nil +} + +func (x *Action) GetWorldAddParticle() *WorldAddParticleAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldAddParticle); ok { + return x.WorldAddParticle + } + } + return nil +} + +func (x *Action) GetWorldQueryEntities() *WorldQueryEntitiesAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldQueryEntities); ok { + return x.WorldQueryEntities + } + } + return nil +} + +func (x *Action) GetWorldQueryPlayers() *WorldQueryPlayersAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldQueryPlayers); ok { + return x.WorldQueryPlayers + } + } + return nil +} + +func (x *Action) GetWorldQueryEntitiesWithin() *WorldQueryEntitiesWithinAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldQueryEntitiesWithin); ok { + return x.WorldQueryEntitiesWithin + } + } + return nil +} + +func (x *Action) GetWorldQueryViewers() *WorldQueryViewersAction { + if x != nil { + if x, ok := x.Kind.(*Action_WorldQueryViewers); ok { + return x.WorldQueryViewers + } + } + return nil +} + type isAction_Kind interface { isAction_Kind() } @@ -380,6 +577,48 @@ type Action_ExecuteCommand struct { ExecuteCommand *ExecuteCommandAction `protobuf:"bytes,50,opt,name=execute_command,json=executeCommand,proto3,oneof"` } +type Action_WorldSetDefaultGameMode struct { + // World configuration and effects + WorldSetDefaultGameMode *WorldSetDefaultGameModeAction `protobuf:"bytes,60,opt,name=world_set_default_game_mode,json=worldSetDefaultGameMode,proto3,oneof"` +} + +type Action_WorldSetDifficulty struct { + WorldSetDifficulty *WorldSetDifficultyAction `protobuf:"bytes,61,opt,name=world_set_difficulty,json=worldSetDifficulty,proto3,oneof"` +} + +type Action_WorldSetTickRange struct { + WorldSetTickRange *WorldSetTickRangeAction `protobuf:"bytes,62,opt,name=world_set_tick_range,json=worldSetTickRange,proto3,oneof"` +} + +type Action_WorldSetBlock struct { + WorldSetBlock *WorldSetBlockAction `protobuf:"bytes,63,opt,name=world_set_block,json=worldSetBlock,proto3,oneof"` +} + +type Action_WorldPlaySound struct { + WorldPlaySound *WorldPlaySoundAction `protobuf:"bytes,64,opt,name=world_play_sound,json=worldPlaySound,proto3,oneof"` +} + +type Action_WorldAddParticle struct { + WorldAddParticle *WorldAddParticleAction `protobuf:"bytes,65,opt,name=world_add_particle,json=worldAddParticle,proto3,oneof"` +} + +type Action_WorldQueryEntities struct { + // World queries + WorldQueryEntities *WorldQueryEntitiesAction `protobuf:"bytes,70,opt,name=world_query_entities,json=worldQueryEntities,proto3,oneof"` +} + +type Action_WorldQueryPlayers struct { + WorldQueryPlayers *WorldQueryPlayersAction `protobuf:"bytes,71,opt,name=world_query_players,json=worldQueryPlayers,proto3,oneof"` +} + +type Action_WorldQueryEntitiesWithin struct { + WorldQueryEntitiesWithin *WorldQueryEntitiesWithinAction `protobuf:"bytes,72,opt,name=world_query_entities_within,json=worldQueryEntitiesWithin,proto3,oneof"` +} + +type Action_WorldQueryViewers struct { + WorldQueryViewers *WorldQueryViewersAction `protobuf:"bytes,73,opt,name=world_query_viewers,json=worldQueryViewers,proto3,oneof"` +} + func (*Action_SendChat) isAction_Kind() {} func (*Action_Teleport) isAction_Kind() {} @@ -416,6 +655,26 @@ func (*Action_PlaySound) isAction_Kind() {} func (*Action_ExecuteCommand) isAction_Kind() {} +func (*Action_WorldSetDefaultGameMode) isAction_Kind() {} + +func (*Action_WorldSetDifficulty) isAction_Kind() {} + +func (*Action_WorldSetTickRange) isAction_Kind() {} + +func (*Action_WorldSetBlock) isAction_Kind() {} + +func (*Action_WorldPlaySound) isAction_Kind() {} + +func (*Action_WorldAddParticle) isAction_Kind() {} + +func (*Action_WorldQueryEntities) isAction_Kind() {} + +func (*Action_WorldQueryPlayers) isAction_Kind() {} + +func (*Action_WorldQueryEntitiesWithin) isAction_Kind() {} + +func (*Action_WorldQueryViewers) isAction_Kind() {} + type SendChatAction struct { state protoimpl.MessageState `protogen:"open.v1"` TargetUuid string `protobuf:"bytes,1,opt,name=target_uuid,json=targetUuid,proto3" json:"target_uuid,omitempty"` @@ -1475,152 +1734,1198 @@ func (x *ExecuteCommandAction) GetCommand() string { return "" } -var File_actions_proto protoreflect.FileDescriptor - -const file_actions_proto_rawDesc = "" + - "\n" + - "\ractions.proto\x12\tdf.plugin\x1a\fcommon.proto\":\n" + - "\vActionBatch\x12+\n" + - "\aactions\x18\x01 \x03(\v2\x11.df.plugin.ActionR\aactions\"\xba\t\n" + - "\x06Action\x12*\n" + - "\x0ecorrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x128\n" + - "\tsend_chat\x18\n" + - " \x01(\v2\x19.df.plugin.SendChatActionH\x00R\bsendChat\x127\n" + - "\bteleport\x18\v \x01(\v2\x19.df.plugin.TeleportActionH\x00R\bteleport\x12+\n" + - "\x04kick\x18\f \x01(\v2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\n" + - "\rset_game_mode\x18\r \x01(\v2\x1c.df.plugin.SetGameModeActionH\x00R\vsetGameMode\x128\n" + - "\tgive_item\x18\x0e \x01(\v2\x19.df.plugin.GiveItemActionH\x00R\bgiveItem\x12J\n" + - "\x0fclear_inventory\x18\x0f \x01(\v2\x1f.df.plugin.ClearInventoryActionH\x00R\x0eclearInventory\x12B\n" + - "\rset_held_item\x18\x10 \x01(\v2\x1c.df.plugin.SetHeldItemActionH\x00R\vsetHeldItem\x12;\n" + - "\n" + - "set_health\x18\x14 \x01(\v2\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x125\n" + - "\bset_food\x18\x15 \x01(\v2\x18.df.plugin.SetFoodActionH\x00R\asetFood\x12G\n" + - "\x0eset_experience\x18\x16 \x01(\v2\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12A\n" + - "\fset_velocity\x18\x17 \x01(\v2\x1c.df.plugin.SetVelocityActionH\x00R\vsetVelocity\x12;\n" + - "\n" + - "add_effect\x18\x1e \x01(\v2\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12D\n" + - "\rremove_effect\x18\x1f \x01(\v2\x1d.df.plugin.RemoveEffectActionH\x00R\fremoveEffect\x12;\n" + - "\n" + - "send_title\x18( \x01(\v2\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n" + - "\n" + - "send_popup\x18) \x01(\v2\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x125\n" + - "\bsend_tip\x18* \x01(\v2\x18.df.plugin.SendTipActionH\x00R\asendTip\x12;\n" + - "\n" + - "play_sound\x18+ \x01(\v2\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n" + - "\x0fexecute_command\x182 \x01(\v2\x1f.df.plugin.ExecuteCommandActionH\x00R\x0eexecuteCommandB\x06\n" + - "\x04kindB\x11\n" + - "\x0f_correlation_id\"K\n" + - "\x0eSendChatAction\x12\x1f\n" + - "\vtarget_uuid\x18\x01 \x01(\tR\n" + - "targetUuid\x12\x18\n" + - "\amessage\x18\x02 \x01(\tR\amessage\"\x8b\x01\n" + - "\x0eTeleportAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12+\n" + - "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\x12+\n" + - "\brotation\x18\x03 \x01(\v2\x0f.df.plugin.Vec3R\brotation\"E\n" + - "\n" + - "KickAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x16\n" + - "\x06reason\x18\x02 \x01(\tR\x06reason\"f\n" + - "\x11SetGameModeAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x120\n" + - "\tgame_mode\x18\x02 \x01(\x0e2\x13.df.plugin.GameModeR\bgameMode\"[\n" + - "\x0eGiveItemAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12(\n" + - "\x04item\x18\x02 \x01(\v2\x14.df.plugin.ItemStackR\x04item\"7\n" + - "\x14ClearInventoryAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\"\xad\x01\n" + - "\x11SetHeldItemAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12-\n" + - "\x04main\x18\x02 \x01(\v2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\n" + - "\aoffhand\x18\x03 \x01(\v2\x14.df.plugin.ItemStackH\x01R\aoffhand\x88\x01\x01B\a\n" + - "\x05_mainB\n" + - "\n" + - "\b_offhand\"}\n" + - "\x0fSetHealthAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x16\n" + - "\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n" + - "\n" + - "max_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01B\r\n" + - "\v_max_health\"D\n" + - "\rSetFoodAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x12\n" + - "\x04food\x18\x02 \x01(\x05R\x04food\"\xb1\x01\n" + - "\x13SetExperienceAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x19\n" + - "\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n" + - "\bprogress\x18\x03 \x01(\x02H\x01R\bprogress\x88\x01\x01\x12\x1b\n" + - "\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\b\n" + - "\x06_levelB\v\n" + - "\t_progressB\t\n" + - "\a_amount\"a\n" + - "\x11SetVelocityAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12+\n" + - "\bvelocity\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bvelocity\"\xc8\x01\n" + - "\x0fAddEffectAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x126\n" + - "\veffect_type\x18\x02 \x01(\x0e2\x15.df.plugin.EffectTypeR\n" + - "effectType\x12\x14\n" + - "\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n" + - "\vduration_ms\x18\x04 \x01(\x03R\n" + - "durationMs\x12%\n" + - "\x0eshow_particles\x18\x05 \x01(\bR\rshowParticles\"m\n" + - "\x12RemoveEffectAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x126\n" + - "\veffect_type\x18\x02 \x01(\x0e2\x15.df.plugin.EffectTypeR\n" + - "effectType\"\x93\x02\n" + - "\x0fSendTitleAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x14\n" + - "\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n" + - "\bsubtitle\x18\x03 \x01(\tH\x00R\bsubtitle\x88\x01\x01\x12!\n" + - "\n" + - "fade_in_ms\x18\x04 \x01(\x03H\x01R\bfadeInMs\x88\x01\x01\x12$\n" + - "\vduration_ms\x18\x05 \x01(\x03H\x02R\n" + - "durationMs\x88\x01\x01\x12#\n" + - "\vfade_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01B\v\n" + - "\t_subtitleB\r\n" + - "\v_fade_in_msB\x0e\n" + - "\f_duration_msB\x0e\n" + - "\f_fade_out_ms\"L\n" + - "\x0fSendPopupAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x18\n" + - "\amessage\x18\x02 \x01(\tR\amessage\"J\n" + - "\rSendTipAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x18\n" + - "\amessage\x18\x02 \x01(\tR\amessage\"\xe6\x01\n" + - "\x0fPlaySoundAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12&\n" + - "\x05sound\x18\x02 \x01(\x0e2\x10.df.plugin.SoundR\x05sound\x120\n" + - "\bposition\x18\x03 \x01(\v2\x0f.df.plugin.Vec3H\x00R\bposition\x88\x01\x01\x12\x1b\n" + - "\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n" + - "\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\v\n" + - "\t_positionB\t\n" + - "\a_volumeB\b\n" + - "\x06_pitch\"Q\n" + - "\x14ExecuteCommandAction\x12\x1f\n" + - "\vplayer_uuid\x18\x01 \x01(\tR\n" + - "playerUuid\x12\x18\n" + - "\acommand\x18\x02 \x01(\tR\acommandB\x8b\x01\n" + - "\rcom.df.pluginB\fActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" +type WorldSetDefaultGameModeAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + GameMode GameMode `protobuf:"varint,2,opt,name=game_mode,json=gameMode,proto3,enum=df.plugin.GameMode" json:"game_mode,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} -var ( +func (x *WorldSetDefaultGameModeAction) Reset() { + *x = WorldSetDefaultGameModeAction{} + mi := &file_actions_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldSetDefaultGameModeAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldSetDefaultGameModeAction) ProtoMessage() {} + +func (x *WorldSetDefaultGameModeAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[20] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldSetDefaultGameModeAction.ProtoReflect.Descriptor instead. +func (*WorldSetDefaultGameModeAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{20} +} + +func (x *WorldSetDefaultGameModeAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldSetDefaultGameModeAction) GetGameMode() GameMode { + if x != nil { + return x.GameMode + } + return GameMode_SURVIVAL +} + +type WorldSetDifficultyAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Difficulty Difficulty `protobuf:"varint,2,opt,name=difficulty,proto3,enum=df.plugin.Difficulty" json:"difficulty,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldSetDifficultyAction) Reset() { + *x = WorldSetDifficultyAction{} + mi := &file_actions_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldSetDifficultyAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldSetDifficultyAction) ProtoMessage() {} + +func (x *WorldSetDifficultyAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[21] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldSetDifficultyAction.ProtoReflect.Descriptor instead. +func (*WorldSetDifficultyAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{21} +} + +func (x *WorldSetDifficultyAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldSetDifficultyAction) GetDifficulty() Difficulty { + if x != nil { + return x.Difficulty + } + return Difficulty_PEACEFUL +} + +type WorldSetTickRangeAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + TickRange int32 `protobuf:"varint,2,opt,name=tick_range,json=tickRange,proto3" json:"tick_range,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldSetTickRangeAction) Reset() { + *x = WorldSetTickRangeAction{} + mi := &file_actions_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldSetTickRangeAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldSetTickRangeAction) ProtoMessage() {} + +func (x *WorldSetTickRangeAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[22] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldSetTickRangeAction.ProtoReflect.Descriptor instead. +func (*WorldSetTickRangeAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{22} +} + +func (x *WorldSetTickRangeAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldSetTickRangeAction) GetTickRange() int32 { + if x != nil { + return x.TickRange + } + return 0 +} + +type WorldSetBlockAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Position *BlockPos `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` + Block *BlockState `protobuf:"bytes,3,opt,name=block,proto3,oneof" json:"block,omitempty"` // nil clears to air + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldSetBlockAction) Reset() { + *x = WorldSetBlockAction{} + mi := &file_actions_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldSetBlockAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldSetBlockAction) ProtoMessage() {} + +func (x *WorldSetBlockAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[23] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldSetBlockAction.ProtoReflect.Descriptor instead. +func (*WorldSetBlockAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{23} +} + +func (x *WorldSetBlockAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldSetBlockAction) GetPosition() *BlockPos { + if x != nil { + return x.Position + } + return nil +} + +func (x *WorldSetBlockAction) GetBlock() *BlockState { + if x != nil { + return x.Block + } + return nil +} + +type WorldPlaySoundAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Sound Sound `protobuf:"varint,2,opt,name=sound,proto3,enum=df.plugin.Sound" json:"sound,omitempty"` + Position *Vec3 `protobuf:"bytes,3,opt,name=position,proto3" json:"position,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldPlaySoundAction) Reset() { + *x = WorldPlaySoundAction{} + mi := &file_actions_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldPlaySoundAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldPlaySoundAction) ProtoMessage() {} + +func (x *WorldPlaySoundAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[24] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldPlaySoundAction.ProtoReflect.Descriptor instead. +func (*WorldPlaySoundAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{24} +} + +func (x *WorldPlaySoundAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldPlaySoundAction) GetSound() Sound { + if x != nil { + return x.Sound + } + return Sound_SOUND_UNKNOWN +} + +func (x *WorldPlaySoundAction) GetPosition() *Vec3 { + if x != nil { + return x.Position + } + return nil +} + +type WorldAddParticleAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Position *Vec3 `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` + Particle ParticleType `protobuf:"varint,3,opt,name=particle,proto3,enum=df.plugin.ParticleType" json:"particle,omitempty"` + Block *BlockState `protobuf:"bytes,4,opt,name=block,proto3,oneof" json:"block,omitempty"` // used for block-based particles when provided + Face *int32 `protobuf:"varint,5,opt,name=face,proto3,oneof" json:"face,omitempty"` // used for punch_block when provided + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldAddParticleAction) Reset() { + *x = WorldAddParticleAction{} + mi := &file_actions_proto_msgTypes[25] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldAddParticleAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldAddParticleAction) ProtoMessage() {} + +func (x *WorldAddParticleAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[25] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldAddParticleAction.ProtoReflect.Descriptor instead. +func (*WorldAddParticleAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{25} +} + +func (x *WorldAddParticleAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldAddParticleAction) GetPosition() *Vec3 { + if x != nil { + return x.Position + } + return nil +} + +func (x *WorldAddParticleAction) GetParticle() ParticleType { + if x != nil { + return x.Particle + } + return ParticleType_PARTICLE_TYPE_UNSPECIFIED +} + +func (x *WorldAddParticleAction) GetBlock() *BlockState { + if x != nil { + return x.Block + } + return nil +} + +func (x *WorldAddParticleAction) GetFace() int32 { + if x != nil && x.Face != nil { + return *x.Face + } + return 0 +} + +type WorldQueryEntitiesAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldQueryEntitiesAction) Reset() { + *x = WorldQueryEntitiesAction{} + mi := &file_actions_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldQueryEntitiesAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldQueryEntitiesAction) ProtoMessage() {} + +func (x *WorldQueryEntitiesAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[26] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldQueryEntitiesAction.ProtoReflect.Descriptor instead. +func (*WorldQueryEntitiesAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{26} +} + +func (x *WorldQueryEntitiesAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +type WorldQueryPlayersAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldQueryPlayersAction) Reset() { + *x = WorldQueryPlayersAction{} + mi := &file_actions_proto_msgTypes[27] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldQueryPlayersAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldQueryPlayersAction) ProtoMessage() {} + +func (x *WorldQueryPlayersAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[27] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldQueryPlayersAction.ProtoReflect.Descriptor instead. +func (*WorldQueryPlayersAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{27} +} + +func (x *WorldQueryPlayersAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +type WorldQueryEntitiesWithinAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Box *BBox `protobuf:"bytes,2,opt,name=box,proto3" json:"box,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldQueryEntitiesWithinAction) Reset() { + *x = WorldQueryEntitiesWithinAction{} + mi := &file_actions_proto_msgTypes[28] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldQueryEntitiesWithinAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldQueryEntitiesWithinAction) ProtoMessage() {} + +func (x *WorldQueryEntitiesWithinAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[28] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldQueryEntitiesWithinAction.ProtoReflect.Descriptor instead. +func (*WorldQueryEntitiesWithinAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{28} +} + +func (x *WorldQueryEntitiesWithinAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldQueryEntitiesWithinAction) GetBox() *BBox { + if x != nil { + return x.Box + } + return nil +} + +type WorldQueryViewersAction struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Position *Vec3 `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldQueryViewersAction) Reset() { + *x = WorldQueryViewersAction{} + mi := &file_actions_proto_msgTypes[29] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldQueryViewersAction) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldQueryViewersAction) ProtoMessage() {} + +func (x *WorldQueryViewersAction) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[29] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldQueryViewersAction.ProtoReflect.Descriptor instead. +func (*WorldQueryViewersAction) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{29} +} + +func (x *WorldQueryViewersAction) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldQueryViewersAction) GetPosition() *Vec3 { + if x != nil { + return x.Position + } + return nil +} + +type ActionStatus struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` + Error *string `protobuf:"bytes,2,opt,name=error,proto3,oneof" json:"error,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActionStatus) Reset() { + *x = ActionStatus{} + mi := &file_actions_proto_msgTypes[30] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActionStatus) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionStatus) ProtoMessage() {} + +func (x *ActionStatus) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[30] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionStatus.ProtoReflect.Descriptor instead. +func (*ActionStatus) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{30} +} + +func (x *ActionStatus) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +func (x *ActionStatus) GetError() string { + if x != nil && x.Error != nil { + return *x.Error + } + return "" +} + +type WorldEntitiesResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Entities []*EntityRef `protobuf:"bytes,2,rep,name=entities,proto3" json:"entities,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldEntitiesResult) Reset() { + *x = WorldEntitiesResult{} + mi := &file_actions_proto_msgTypes[31] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldEntitiesResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldEntitiesResult) ProtoMessage() {} + +func (x *WorldEntitiesResult) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[31] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldEntitiesResult.ProtoReflect.Descriptor instead. +func (*WorldEntitiesResult) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{31} +} + +func (x *WorldEntitiesResult) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldEntitiesResult) GetEntities() []*EntityRef { + if x != nil { + return x.Entities + } + return nil +} + +type WorldEntitiesWithinResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Box *BBox `protobuf:"bytes,2,opt,name=box,proto3" json:"box,omitempty"` + Entities []*EntityRef `protobuf:"bytes,3,rep,name=entities,proto3" json:"entities,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldEntitiesWithinResult) Reset() { + *x = WorldEntitiesWithinResult{} + mi := &file_actions_proto_msgTypes[32] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldEntitiesWithinResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldEntitiesWithinResult) ProtoMessage() {} + +func (x *WorldEntitiesWithinResult) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[32] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldEntitiesWithinResult.ProtoReflect.Descriptor instead. +func (*WorldEntitiesWithinResult) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{32} +} + +func (x *WorldEntitiesWithinResult) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldEntitiesWithinResult) GetBox() *BBox { + if x != nil { + return x.Box + } + return nil +} + +func (x *WorldEntitiesWithinResult) GetEntities() []*EntityRef { + if x != nil { + return x.Entities + } + return nil +} + +type WorldPlayersResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Players []*EntityRef `protobuf:"bytes,2,rep,name=players,proto3" json:"players,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldPlayersResult) Reset() { + *x = WorldPlayersResult{} + mi := &file_actions_proto_msgTypes[33] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldPlayersResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldPlayersResult) ProtoMessage() {} + +func (x *WorldPlayersResult) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[33] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldPlayersResult.ProtoReflect.Descriptor instead. +func (*WorldPlayersResult) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{33} +} + +func (x *WorldPlayersResult) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldPlayersResult) GetPlayers() []*EntityRef { + if x != nil { + return x.Players + } + return nil +} + +type WorldViewersResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` + Position *Vec3 `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` + ViewerUuids []string `protobuf:"bytes,3,rep,name=viewer_uuids,json=viewerUuids,proto3" json:"viewer_uuids,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *WorldViewersResult) Reset() { + *x = WorldViewersResult{} + mi := &file_actions_proto_msgTypes[34] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *WorldViewersResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*WorldViewersResult) ProtoMessage() {} + +func (x *WorldViewersResult) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[34] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use WorldViewersResult.ProtoReflect.Descriptor instead. +func (*WorldViewersResult) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{34} +} + +func (x *WorldViewersResult) GetWorld() *WorldRef { + if x != nil { + return x.World + } + return nil +} + +func (x *WorldViewersResult) GetPosition() *Vec3 { + if x != nil { + return x.Position + } + return nil +} + +func (x *WorldViewersResult) GetViewerUuids() []string { + if x != nil { + return x.ViewerUuids + } + return nil +} + +type ActionResult struct { + state protoimpl.MessageState `protogen:"open.v1"` + CorrelationId string `protobuf:"bytes,1,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"` + Status *ActionStatus `protobuf:"bytes,2,opt,name=status,proto3,oneof" json:"status,omitempty"` + // Types that are valid to be assigned to Result: + // + // *ActionResult_WorldEntities + // *ActionResult_WorldPlayers + // *ActionResult_WorldEntitiesWithin + // *ActionResult_WorldViewers + Result isActionResult_Result `protobuf_oneof:"result"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActionResult) Reset() { + *x = ActionResult{} + mi := &file_actions_proto_msgTypes[35] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActionResult) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActionResult) ProtoMessage() {} + +func (x *ActionResult) ProtoReflect() protoreflect.Message { + mi := &file_actions_proto_msgTypes[35] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. +func (*ActionResult) Descriptor() ([]byte, []int) { + return file_actions_proto_rawDescGZIP(), []int{35} +} + +func (x *ActionResult) GetCorrelationId() string { + if x != nil { + return x.CorrelationId + } + return "" +} + +func (x *ActionResult) GetStatus() *ActionStatus { + if x != nil { + return x.Status + } + return nil +} + +func (x *ActionResult) GetResult() isActionResult_Result { + if x != nil { + return x.Result + } + return nil +} + +func (x *ActionResult) GetWorldEntities() *WorldEntitiesResult { + if x != nil { + if x, ok := x.Result.(*ActionResult_WorldEntities); ok { + return x.WorldEntities + } + } + return nil +} + +func (x *ActionResult) GetWorldPlayers() *WorldPlayersResult { + if x != nil { + if x, ok := x.Result.(*ActionResult_WorldPlayers); ok { + return x.WorldPlayers + } + } + return nil +} + +func (x *ActionResult) GetWorldEntitiesWithin() *WorldEntitiesWithinResult { + if x != nil { + if x, ok := x.Result.(*ActionResult_WorldEntitiesWithin); ok { + return x.WorldEntitiesWithin + } + } + return nil +} + +func (x *ActionResult) GetWorldViewers() *WorldViewersResult { + if x != nil { + if x, ok := x.Result.(*ActionResult_WorldViewers); ok { + return x.WorldViewers + } + } + return nil +} + +type isActionResult_Result interface { + isActionResult_Result() +} + +type ActionResult_WorldEntities struct { + WorldEntities *WorldEntitiesResult `protobuf:"bytes,10,opt,name=world_entities,json=worldEntities,proto3,oneof"` +} + +type ActionResult_WorldPlayers struct { + WorldPlayers *WorldPlayersResult `protobuf:"bytes,11,opt,name=world_players,json=worldPlayers,proto3,oneof"` +} + +type ActionResult_WorldEntitiesWithin struct { + WorldEntitiesWithin *WorldEntitiesWithinResult `protobuf:"bytes,12,opt,name=world_entities_within,json=worldEntitiesWithin,proto3,oneof"` +} + +type ActionResult_WorldViewers struct { + WorldViewers *WorldViewersResult `protobuf:"bytes,13,opt,name=world_viewers,json=worldViewers,proto3,oneof"` +} + +func (*ActionResult_WorldEntities) isActionResult_Result() {} + +func (*ActionResult_WorldPlayers) isActionResult_Result() {} + +func (*ActionResult_WorldEntitiesWithin) isActionResult_Result() {} + +func (*ActionResult_WorldViewers) isActionResult_Result() {} + +var File_actions_proto protoreflect.FileDescriptor + +const file_actions_proto_rawDesc = "" + + "\n" + + "\ractions.proto\x12\tdf.plugin\x1a\fcommon.proto\":\n" + + "\vActionBatch\x12+\n" + + "\aactions\x18\x01 \x03(\v2\x11.df.plugin.ActionR\aactions\"\xaf\x10\n" + + "\x06Action\x12*\n" + + "\x0ecorrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x128\n" + + "\tsend_chat\x18\n" + + " \x01(\v2\x19.df.plugin.SendChatActionH\x00R\bsendChat\x127\n" + + "\bteleport\x18\v \x01(\v2\x19.df.plugin.TeleportActionH\x00R\bteleport\x12+\n" + + "\x04kick\x18\f \x01(\v2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\n" + + "\rset_game_mode\x18\r \x01(\v2\x1c.df.plugin.SetGameModeActionH\x00R\vsetGameMode\x128\n" + + "\tgive_item\x18\x0e \x01(\v2\x19.df.plugin.GiveItemActionH\x00R\bgiveItem\x12J\n" + + "\x0fclear_inventory\x18\x0f \x01(\v2\x1f.df.plugin.ClearInventoryActionH\x00R\x0eclearInventory\x12B\n" + + "\rset_held_item\x18\x10 \x01(\v2\x1c.df.plugin.SetHeldItemActionH\x00R\vsetHeldItem\x12;\n" + + "\n" + + "set_health\x18\x14 \x01(\v2\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x125\n" + + "\bset_food\x18\x15 \x01(\v2\x18.df.plugin.SetFoodActionH\x00R\asetFood\x12G\n" + + "\x0eset_experience\x18\x16 \x01(\v2\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12A\n" + + "\fset_velocity\x18\x17 \x01(\v2\x1c.df.plugin.SetVelocityActionH\x00R\vsetVelocity\x12;\n" + + "\n" + + "add_effect\x18\x1e \x01(\v2\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12D\n" + + "\rremove_effect\x18\x1f \x01(\v2\x1d.df.plugin.RemoveEffectActionH\x00R\fremoveEffect\x12;\n" + + "\n" + + "send_title\x18( \x01(\v2\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n" + + "\n" + + "send_popup\x18) \x01(\v2\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x125\n" + + "\bsend_tip\x18* \x01(\v2\x18.df.plugin.SendTipActionH\x00R\asendTip\x12;\n" + + "\n" + + "play_sound\x18+ \x01(\v2\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n" + + "\x0fexecute_command\x182 \x01(\v2\x1f.df.plugin.ExecuteCommandActionH\x00R\x0eexecuteCommand\x12h\n" + + "\x1bworld_set_default_game_mode\x18< \x01(\v2(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\n" + + "\x14world_set_difficulty\x18= \x01(\v2#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\n" + + "\x14world_set_tick_range\x18> \x01(\v2\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\n" + + "\x0fworld_set_block\x18? \x01(\v2\x1e.df.plugin.WorldSetBlockActionH\x00R\rworldSetBlock\x12K\n" + + "\x10world_play_sound\x18@ \x01(\v2\x1f.df.plugin.WorldPlaySoundActionH\x00R\x0eworldPlaySound\x12Q\n" + + "\x12world_add_particle\x18A \x01(\v2!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\n" + + "\x14world_query_entities\x18F \x01(\v2#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\n" + + "\x13world_query_players\x18G \x01(\v2\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\n" + + "\x1bworld_query_entities_within\x18H \x01(\v2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\n" + + "\x13world_query_viewers\x18I \x01(\v2\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\n" + + "\x04kindB\x11\n" + + "\x0f_correlation_id\"K\n" + + "\x0eSendChatAction\x12\x1f\n" + + "\vtarget_uuid\x18\x01 \x01(\tR\n" + + "targetUuid\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\"\x8b\x01\n" + + "\x0eTeleportAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12+\n" + + "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\x12+\n" + + "\brotation\x18\x03 \x01(\v2\x0f.df.plugin.Vec3R\brotation\"E\n" + + "\n" + + "KickAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x16\n" + + "\x06reason\x18\x02 \x01(\tR\x06reason\"f\n" + + "\x11SetGameModeAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x120\n" + + "\tgame_mode\x18\x02 \x01(\x0e2\x13.df.plugin.GameModeR\bgameMode\"[\n" + + "\x0eGiveItemAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12(\n" + + "\x04item\x18\x02 \x01(\v2\x14.df.plugin.ItemStackR\x04item\"7\n" + + "\x14ClearInventoryAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\"\xad\x01\n" + + "\x11SetHeldItemAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12-\n" + + "\x04main\x18\x02 \x01(\v2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\n" + + "\aoffhand\x18\x03 \x01(\v2\x14.df.plugin.ItemStackH\x01R\aoffhand\x88\x01\x01B\a\n" + + "\x05_mainB\n" + + "\n" + + "\b_offhand\"}\n" + + "\x0fSetHealthAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x16\n" + + "\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n" + + "\n" + + "max_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01B\r\n" + + "\v_max_health\"D\n" + + "\rSetFoodAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x12\n" + + "\x04food\x18\x02 \x01(\x05R\x04food\"\xb1\x01\n" + + "\x13SetExperienceAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x19\n" + + "\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n" + + "\bprogress\x18\x03 \x01(\x02H\x01R\bprogress\x88\x01\x01\x12\x1b\n" + + "\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\b\n" + + "\x06_levelB\v\n" + + "\t_progressB\t\n" + + "\a_amount\"a\n" + + "\x11SetVelocityAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12+\n" + + "\bvelocity\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bvelocity\"\xc8\x01\n" + + "\x0fAddEffectAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x126\n" + + "\veffect_type\x18\x02 \x01(\x0e2\x15.df.plugin.EffectTypeR\n" + + "effectType\x12\x14\n" + + "\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n" + + "\vduration_ms\x18\x04 \x01(\x03R\n" + + "durationMs\x12%\n" + + "\x0eshow_particles\x18\x05 \x01(\bR\rshowParticles\"m\n" + + "\x12RemoveEffectAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x126\n" + + "\veffect_type\x18\x02 \x01(\x0e2\x15.df.plugin.EffectTypeR\n" + + "effectType\"\x93\x02\n" + + "\x0fSendTitleAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x14\n" + + "\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n" + + "\bsubtitle\x18\x03 \x01(\tH\x00R\bsubtitle\x88\x01\x01\x12!\n" + + "\n" + + "fade_in_ms\x18\x04 \x01(\x03H\x01R\bfadeInMs\x88\x01\x01\x12$\n" + + "\vduration_ms\x18\x05 \x01(\x03H\x02R\n" + + "durationMs\x88\x01\x01\x12#\n" + + "\vfade_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01B\v\n" + + "\t_subtitleB\r\n" + + "\v_fade_in_msB\x0e\n" + + "\f_duration_msB\x0e\n" + + "\f_fade_out_ms\"L\n" + + "\x0fSendPopupAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\"J\n" + + "\rSendTipAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x18\n" + + "\amessage\x18\x02 \x01(\tR\amessage\"\xe6\x01\n" + + "\x0fPlaySoundAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12&\n" + + "\x05sound\x18\x02 \x01(\x0e2\x10.df.plugin.SoundR\x05sound\x120\n" + + "\bposition\x18\x03 \x01(\v2\x0f.df.plugin.Vec3H\x00R\bposition\x88\x01\x01\x12\x1b\n" + + "\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n" + + "\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\v\n" + + "\t_positionB\t\n" + + "\a_volumeB\b\n" + + "\x06_pitch\"Q\n" + + "\x14ExecuteCommandAction\x12\x1f\n" + + "\vplayer_uuid\x18\x01 \x01(\tR\n" + + "playerUuid\x12\x18\n" + + "\acommand\x18\x02 \x01(\tR\acommand\"|\n" + + "\x1dWorldSetDefaultGameModeAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x120\n" + + "\tgame_mode\x18\x02 \x01(\x0e2\x13.df.plugin.GameModeR\bgameMode\"|\n" + + "\x18WorldSetDifficultyAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x125\n" + + "\n" + + "difficulty\x18\x02 \x01(\x0e2\x15.df.plugin.DifficultyR\n" + + "difficulty\"c\n" + + "\x17WorldSetTickRangeAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12\x1d\n" + + "\n" + + "tick_range\x18\x02 \x01(\x05R\ttickRange\"\xad\x01\n" + + "\x13WorldSetBlockAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12/\n" + + "\bposition\x18\x02 \x01(\v2\x13.df.plugin.BlockPosR\bposition\x120\n" + + "\x05block\x18\x03 \x01(\v2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01B\b\n" + + "\x06_block\"\x96\x01\n" + + "\x14WorldPlaySoundAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12&\n" + + "\x05sound\x18\x02 \x01(\x0e2\x10.df.plugin.SoundR\x05sound\x12+\n" + + "\bposition\x18\x03 \x01(\v2\x0f.df.plugin.Vec3R\bposition\"\x83\x02\n" + + "\x16WorldAddParticleAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12+\n" + + "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\x123\n" + + "\bparticle\x18\x03 \x01(\x0e2\x17.df.plugin.ParticleTypeR\bparticle\x120\n" + + "\x05block\x18\x04 \x01(\v2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01\x12\x17\n" + + "\x04face\x18\x05 \x01(\x05H\x01R\x04face\x88\x01\x01B\b\n" + + "\x06_blockB\a\n" + + "\x05_face\"E\n" + + "\x18WorldQueryEntitiesAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\"D\n" + + "\x17WorldQueryPlayersAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\"n\n" + + "\x1eWorldQueryEntitiesWithinAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12!\n" + + "\x03box\x18\x02 \x01(\v2\x0f.df.plugin.BBoxR\x03box\"q\n" + + "\x17WorldQueryViewersAction\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12+\n" + + "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\"C\n" + + "\fActionStatus\x12\x0e\n" + + "\x02ok\x18\x01 \x01(\bR\x02ok\x12\x19\n" + + "\x05error\x18\x02 \x01(\tH\x00R\x05error\x88\x01\x01B\b\n" + + "\x06_error\"r\n" + + "\x13WorldEntitiesResult\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x120\n" + + "\bentities\x18\x02 \x03(\v2\x14.df.plugin.EntityRefR\bentities\"\x9b\x01\n" + + "\x19WorldEntitiesWithinResult\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12!\n" + + "\x03box\x18\x02 \x01(\v2\x0f.df.plugin.BBoxR\x03box\x120\n" + + "\bentities\x18\x03 \x03(\v2\x14.df.plugin.EntityRefR\bentities\"o\n" + + "\x12WorldPlayersResult\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12.\n" + + "\aplayers\x18\x02 \x03(\v2\x14.df.plugin.EntityRefR\aplayers\"\x8f\x01\n" + + "\x12WorldViewersResult\x12)\n" + + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12+\n" + + "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\x12!\n" + + "\fviewer_uuids\x18\x03 \x03(\tR\vviewerUuids\"\xb1\x03\n" + + "\fActionResult\x12%\n" + + "\x0ecorrelation_id\x18\x01 \x01(\tR\rcorrelationId\x124\n" + + "\x06status\x18\x02 \x01(\v2\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\n" + + "\x0eworld_entities\x18\n" + + " \x01(\v2\x1e.df.plugin.WorldEntitiesResultH\x00R\rworldEntities\x12D\n" + + "\rworld_players\x18\v \x01(\v2\x1d.df.plugin.WorldPlayersResultH\x00R\fworldPlayers\x12Z\n" + + "\x15world_entities_within\x18\f \x01(\v2$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12D\n" + + "\rworld_viewers\x18\r \x01(\v2\x1d.df.plugin.WorldViewersResultH\x00R\fworldViewersB\b\n" + + "\x06resultB\t\n" + + "\a_status*\xeb\x03\n" + + "\fParticleType\x12\x1d\n" + + "\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n" + + "\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1e\n" + + "\x1aPARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1a\n" + + "\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\n" + + "\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\n" + + "\x0fPARTICLE_SPLASH\x10\x05\x12\x13\n" + + "\x0fPARTICLE_EFFECT\x10\x06\x12\x19\n" + + "\x15PARTICLE_ENTITY_FLAME\x10\a\x12\x12\n" + + "\x0ePARTICLE_FLAME\x10\b\x12\x11\n" + + "\rPARTICLE_DUST\x10\t\x12\x1e\n" + + "\x1aPARTICLE_BLOCK_FORCE_FIELD\x10\n" + + "\x12\x16\n" + + "\x12PARTICLE_BONE_MEAL\x10\v\x12\x16\n" + + "\x12PARTICLE_EVAPORATE\x10\f\x12\x17\n" + + "\x13PARTICLE_WATER_DRIP\x10\r\x12\x16\n" + + "\x12PARTICLE_LAVA_DRIP\x10\x0e\x12\x11\n" + + "\rPARTICLE_LAVA\x10\x0f\x12\x17\n" + + "\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\n" + + "\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\n" + + "\x14PARTICLE_PUNCH_BLOCK\x10\x12B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + +var ( file_actions_proto_rawDescOnce sync.Once file_actions_proto_rawDescData []byte ) @@ -1632,70 +2937,139 @@ func file_actions_proto_rawDescGZIP() []byte { return file_actions_proto_rawDescData } -var file_actions_proto_msgTypes = make([]protoimpl.MessageInfo, 20) +var file_actions_proto_enumTypes = make([]protoimpl.EnumInfo, 1) +var file_actions_proto_msgTypes = make([]protoimpl.MessageInfo, 36) var file_actions_proto_goTypes = []any{ - (*ActionBatch)(nil), // 0: df.plugin.ActionBatch - (*Action)(nil), // 1: df.plugin.Action - (*SendChatAction)(nil), // 2: df.plugin.SendChatAction - (*TeleportAction)(nil), // 3: df.plugin.TeleportAction - (*KickAction)(nil), // 4: df.plugin.KickAction - (*SetGameModeAction)(nil), // 5: df.plugin.SetGameModeAction - (*GiveItemAction)(nil), // 6: df.plugin.GiveItemAction - (*ClearInventoryAction)(nil), // 7: df.plugin.ClearInventoryAction - (*SetHeldItemAction)(nil), // 8: df.plugin.SetHeldItemAction - (*SetHealthAction)(nil), // 9: df.plugin.SetHealthAction - (*SetFoodAction)(nil), // 10: df.plugin.SetFoodAction - (*SetExperienceAction)(nil), // 11: df.plugin.SetExperienceAction - (*SetVelocityAction)(nil), // 12: df.plugin.SetVelocityAction - (*AddEffectAction)(nil), // 13: df.plugin.AddEffectAction - (*RemoveEffectAction)(nil), // 14: df.plugin.RemoveEffectAction - (*SendTitleAction)(nil), // 15: df.plugin.SendTitleAction - (*SendPopupAction)(nil), // 16: df.plugin.SendPopupAction - (*SendTipAction)(nil), // 17: df.plugin.SendTipAction - (*PlaySoundAction)(nil), // 18: df.plugin.PlaySoundAction - (*ExecuteCommandAction)(nil), // 19: df.plugin.ExecuteCommandAction - (*Vec3)(nil), // 20: df.plugin.Vec3 - (GameMode)(0), // 21: df.plugin.GameMode - (*ItemStack)(nil), // 22: df.plugin.ItemStack - (EffectType)(0), // 23: df.plugin.EffectType - (Sound)(0), // 24: df.plugin.Sound + (ParticleType)(0), // 0: df.plugin.ParticleType + (*ActionBatch)(nil), // 1: df.plugin.ActionBatch + (*Action)(nil), // 2: df.plugin.Action + (*SendChatAction)(nil), // 3: df.plugin.SendChatAction + (*TeleportAction)(nil), // 4: df.plugin.TeleportAction + (*KickAction)(nil), // 5: df.plugin.KickAction + (*SetGameModeAction)(nil), // 6: df.plugin.SetGameModeAction + (*GiveItemAction)(nil), // 7: df.plugin.GiveItemAction + (*ClearInventoryAction)(nil), // 8: df.plugin.ClearInventoryAction + (*SetHeldItemAction)(nil), // 9: df.plugin.SetHeldItemAction + (*SetHealthAction)(nil), // 10: df.plugin.SetHealthAction + (*SetFoodAction)(nil), // 11: df.plugin.SetFoodAction + (*SetExperienceAction)(nil), // 12: df.plugin.SetExperienceAction + (*SetVelocityAction)(nil), // 13: df.plugin.SetVelocityAction + (*AddEffectAction)(nil), // 14: df.plugin.AddEffectAction + (*RemoveEffectAction)(nil), // 15: df.plugin.RemoveEffectAction + (*SendTitleAction)(nil), // 16: df.plugin.SendTitleAction + (*SendPopupAction)(nil), // 17: df.plugin.SendPopupAction + (*SendTipAction)(nil), // 18: df.plugin.SendTipAction + (*PlaySoundAction)(nil), // 19: df.plugin.PlaySoundAction + (*ExecuteCommandAction)(nil), // 20: df.plugin.ExecuteCommandAction + (*WorldSetDefaultGameModeAction)(nil), // 21: df.plugin.WorldSetDefaultGameModeAction + (*WorldSetDifficultyAction)(nil), // 22: df.plugin.WorldSetDifficultyAction + (*WorldSetTickRangeAction)(nil), // 23: df.plugin.WorldSetTickRangeAction + (*WorldSetBlockAction)(nil), // 24: df.plugin.WorldSetBlockAction + (*WorldPlaySoundAction)(nil), // 25: df.plugin.WorldPlaySoundAction + (*WorldAddParticleAction)(nil), // 26: df.plugin.WorldAddParticleAction + (*WorldQueryEntitiesAction)(nil), // 27: df.plugin.WorldQueryEntitiesAction + (*WorldQueryPlayersAction)(nil), // 28: df.plugin.WorldQueryPlayersAction + (*WorldQueryEntitiesWithinAction)(nil), // 29: df.plugin.WorldQueryEntitiesWithinAction + (*WorldQueryViewersAction)(nil), // 30: df.plugin.WorldQueryViewersAction + (*ActionStatus)(nil), // 31: df.plugin.ActionStatus + (*WorldEntitiesResult)(nil), // 32: df.plugin.WorldEntitiesResult + (*WorldEntitiesWithinResult)(nil), // 33: df.plugin.WorldEntitiesWithinResult + (*WorldPlayersResult)(nil), // 34: df.plugin.WorldPlayersResult + (*WorldViewersResult)(nil), // 35: df.plugin.WorldViewersResult + (*ActionResult)(nil), // 36: df.plugin.ActionResult + (*Vec3)(nil), // 37: df.plugin.Vec3 + (GameMode)(0), // 38: df.plugin.GameMode + (*ItemStack)(nil), // 39: df.plugin.ItemStack + (EffectType)(0), // 40: df.plugin.EffectType + (Sound)(0), // 41: df.plugin.Sound + (*WorldRef)(nil), // 42: df.plugin.WorldRef + (Difficulty)(0), // 43: df.plugin.Difficulty + (*BlockPos)(nil), // 44: df.plugin.BlockPos + (*BlockState)(nil), // 45: df.plugin.BlockState + (*BBox)(nil), // 46: df.plugin.BBox + (*EntityRef)(nil), // 47: df.plugin.EntityRef } var file_actions_proto_depIdxs = []int32{ - 1, // 0: df.plugin.ActionBatch.actions:type_name -> df.plugin.Action - 2, // 1: df.plugin.Action.send_chat:type_name -> df.plugin.SendChatAction - 3, // 2: df.plugin.Action.teleport:type_name -> df.plugin.TeleportAction - 4, // 3: df.plugin.Action.kick:type_name -> df.plugin.KickAction - 5, // 4: df.plugin.Action.set_game_mode:type_name -> df.plugin.SetGameModeAction - 6, // 5: df.plugin.Action.give_item:type_name -> df.plugin.GiveItemAction - 7, // 6: df.plugin.Action.clear_inventory:type_name -> df.plugin.ClearInventoryAction - 8, // 7: df.plugin.Action.set_held_item:type_name -> df.plugin.SetHeldItemAction - 9, // 8: df.plugin.Action.set_health:type_name -> df.plugin.SetHealthAction - 10, // 9: df.plugin.Action.set_food:type_name -> df.plugin.SetFoodAction - 11, // 10: df.plugin.Action.set_experience:type_name -> df.plugin.SetExperienceAction - 12, // 11: df.plugin.Action.set_velocity:type_name -> df.plugin.SetVelocityAction - 13, // 12: df.plugin.Action.add_effect:type_name -> df.plugin.AddEffectAction - 14, // 13: df.plugin.Action.remove_effect:type_name -> df.plugin.RemoveEffectAction - 15, // 14: df.plugin.Action.send_title:type_name -> df.plugin.SendTitleAction - 16, // 15: df.plugin.Action.send_popup:type_name -> df.plugin.SendPopupAction - 17, // 16: df.plugin.Action.send_tip:type_name -> df.plugin.SendTipAction - 18, // 17: df.plugin.Action.play_sound:type_name -> df.plugin.PlaySoundAction - 19, // 18: df.plugin.Action.execute_command:type_name -> df.plugin.ExecuteCommandAction - 20, // 19: df.plugin.TeleportAction.position:type_name -> df.plugin.Vec3 - 20, // 20: df.plugin.TeleportAction.rotation:type_name -> df.plugin.Vec3 - 21, // 21: df.plugin.SetGameModeAction.game_mode:type_name -> df.plugin.GameMode - 22, // 22: df.plugin.GiveItemAction.item:type_name -> df.plugin.ItemStack - 22, // 23: df.plugin.SetHeldItemAction.main:type_name -> df.plugin.ItemStack - 22, // 24: df.plugin.SetHeldItemAction.offhand:type_name -> df.plugin.ItemStack - 20, // 25: df.plugin.SetVelocityAction.velocity:type_name -> df.plugin.Vec3 - 23, // 26: df.plugin.AddEffectAction.effect_type:type_name -> df.plugin.EffectType - 23, // 27: df.plugin.RemoveEffectAction.effect_type:type_name -> df.plugin.EffectType - 24, // 28: df.plugin.PlaySoundAction.sound:type_name -> df.plugin.Sound - 20, // 29: df.plugin.PlaySoundAction.position:type_name -> df.plugin.Vec3 - 30, // [30:30] is the sub-list for method output_type - 30, // [30:30] is the sub-list for method input_type - 30, // [30:30] is the sub-list for extension type_name - 30, // [30:30] is the sub-list for extension extendee - 0, // [0:30] is the sub-list for field type_name + 2, // 0: df.plugin.ActionBatch.actions:type_name -> df.plugin.Action + 3, // 1: df.plugin.Action.send_chat:type_name -> df.plugin.SendChatAction + 4, // 2: df.plugin.Action.teleport:type_name -> df.plugin.TeleportAction + 5, // 3: df.plugin.Action.kick:type_name -> df.plugin.KickAction + 6, // 4: df.plugin.Action.set_game_mode:type_name -> df.plugin.SetGameModeAction + 7, // 5: df.plugin.Action.give_item:type_name -> df.plugin.GiveItemAction + 8, // 6: df.plugin.Action.clear_inventory:type_name -> df.plugin.ClearInventoryAction + 9, // 7: df.plugin.Action.set_held_item:type_name -> df.plugin.SetHeldItemAction + 10, // 8: df.plugin.Action.set_health:type_name -> df.plugin.SetHealthAction + 11, // 9: df.plugin.Action.set_food:type_name -> df.plugin.SetFoodAction + 12, // 10: df.plugin.Action.set_experience:type_name -> df.plugin.SetExperienceAction + 13, // 11: df.plugin.Action.set_velocity:type_name -> df.plugin.SetVelocityAction + 14, // 12: df.plugin.Action.add_effect:type_name -> df.plugin.AddEffectAction + 15, // 13: df.plugin.Action.remove_effect:type_name -> df.plugin.RemoveEffectAction + 16, // 14: df.plugin.Action.send_title:type_name -> df.plugin.SendTitleAction + 17, // 15: df.plugin.Action.send_popup:type_name -> df.plugin.SendPopupAction + 18, // 16: df.plugin.Action.send_tip:type_name -> df.plugin.SendTipAction + 19, // 17: df.plugin.Action.play_sound:type_name -> df.plugin.PlaySoundAction + 20, // 18: df.plugin.Action.execute_command:type_name -> df.plugin.ExecuteCommandAction + 21, // 19: df.plugin.Action.world_set_default_game_mode:type_name -> df.plugin.WorldSetDefaultGameModeAction + 22, // 20: df.plugin.Action.world_set_difficulty:type_name -> df.plugin.WorldSetDifficultyAction + 23, // 21: df.plugin.Action.world_set_tick_range:type_name -> df.plugin.WorldSetTickRangeAction + 24, // 22: df.plugin.Action.world_set_block:type_name -> df.plugin.WorldSetBlockAction + 25, // 23: df.plugin.Action.world_play_sound:type_name -> df.plugin.WorldPlaySoundAction + 26, // 24: df.plugin.Action.world_add_particle:type_name -> df.plugin.WorldAddParticleAction + 27, // 25: df.plugin.Action.world_query_entities:type_name -> df.plugin.WorldQueryEntitiesAction + 28, // 26: df.plugin.Action.world_query_players:type_name -> df.plugin.WorldQueryPlayersAction + 29, // 27: df.plugin.Action.world_query_entities_within:type_name -> df.plugin.WorldQueryEntitiesWithinAction + 30, // 28: df.plugin.Action.world_query_viewers:type_name -> df.plugin.WorldQueryViewersAction + 37, // 29: df.plugin.TeleportAction.position:type_name -> df.plugin.Vec3 + 37, // 30: df.plugin.TeleportAction.rotation:type_name -> df.plugin.Vec3 + 38, // 31: df.plugin.SetGameModeAction.game_mode:type_name -> df.plugin.GameMode + 39, // 32: df.plugin.GiveItemAction.item:type_name -> df.plugin.ItemStack + 39, // 33: df.plugin.SetHeldItemAction.main:type_name -> df.plugin.ItemStack + 39, // 34: df.plugin.SetHeldItemAction.offhand:type_name -> df.plugin.ItemStack + 37, // 35: df.plugin.SetVelocityAction.velocity:type_name -> df.plugin.Vec3 + 40, // 36: df.plugin.AddEffectAction.effect_type:type_name -> df.plugin.EffectType + 40, // 37: df.plugin.RemoveEffectAction.effect_type:type_name -> df.plugin.EffectType + 41, // 38: df.plugin.PlaySoundAction.sound:type_name -> df.plugin.Sound + 37, // 39: df.plugin.PlaySoundAction.position:type_name -> df.plugin.Vec3 + 42, // 40: df.plugin.WorldSetDefaultGameModeAction.world:type_name -> df.plugin.WorldRef + 38, // 41: df.plugin.WorldSetDefaultGameModeAction.game_mode:type_name -> df.plugin.GameMode + 42, // 42: df.plugin.WorldSetDifficultyAction.world:type_name -> df.plugin.WorldRef + 43, // 43: df.plugin.WorldSetDifficultyAction.difficulty:type_name -> df.plugin.Difficulty + 42, // 44: df.plugin.WorldSetTickRangeAction.world:type_name -> df.plugin.WorldRef + 42, // 45: df.plugin.WorldSetBlockAction.world:type_name -> df.plugin.WorldRef + 44, // 46: df.plugin.WorldSetBlockAction.position:type_name -> df.plugin.BlockPos + 45, // 47: df.plugin.WorldSetBlockAction.block:type_name -> df.plugin.BlockState + 42, // 48: df.plugin.WorldPlaySoundAction.world:type_name -> df.plugin.WorldRef + 41, // 49: df.plugin.WorldPlaySoundAction.sound:type_name -> df.plugin.Sound + 37, // 50: df.plugin.WorldPlaySoundAction.position:type_name -> df.plugin.Vec3 + 42, // 51: df.plugin.WorldAddParticleAction.world:type_name -> df.plugin.WorldRef + 37, // 52: df.plugin.WorldAddParticleAction.position:type_name -> df.plugin.Vec3 + 0, // 53: df.plugin.WorldAddParticleAction.particle:type_name -> df.plugin.ParticleType + 45, // 54: df.plugin.WorldAddParticleAction.block:type_name -> df.plugin.BlockState + 42, // 55: df.plugin.WorldQueryEntitiesAction.world:type_name -> df.plugin.WorldRef + 42, // 56: df.plugin.WorldQueryPlayersAction.world:type_name -> df.plugin.WorldRef + 42, // 57: df.plugin.WorldQueryEntitiesWithinAction.world:type_name -> df.plugin.WorldRef + 46, // 58: df.plugin.WorldQueryEntitiesWithinAction.box:type_name -> df.plugin.BBox + 42, // 59: df.plugin.WorldQueryViewersAction.world:type_name -> df.plugin.WorldRef + 37, // 60: df.plugin.WorldQueryViewersAction.position:type_name -> df.plugin.Vec3 + 42, // 61: df.plugin.WorldEntitiesResult.world:type_name -> df.plugin.WorldRef + 47, // 62: df.plugin.WorldEntitiesResult.entities:type_name -> df.plugin.EntityRef + 42, // 63: df.plugin.WorldEntitiesWithinResult.world:type_name -> df.plugin.WorldRef + 46, // 64: df.plugin.WorldEntitiesWithinResult.box:type_name -> df.plugin.BBox + 47, // 65: df.plugin.WorldEntitiesWithinResult.entities:type_name -> df.plugin.EntityRef + 42, // 66: df.plugin.WorldPlayersResult.world:type_name -> df.plugin.WorldRef + 47, // 67: df.plugin.WorldPlayersResult.players:type_name -> df.plugin.EntityRef + 42, // 68: df.plugin.WorldViewersResult.world:type_name -> df.plugin.WorldRef + 37, // 69: df.plugin.WorldViewersResult.position:type_name -> df.plugin.Vec3 + 31, // 70: df.plugin.ActionResult.status:type_name -> df.plugin.ActionStatus + 32, // 71: df.plugin.ActionResult.world_entities:type_name -> df.plugin.WorldEntitiesResult + 34, // 72: df.plugin.ActionResult.world_players:type_name -> df.plugin.WorldPlayersResult + 33, // 73: df.plugin.ActionResult.world_entities_within:type_name -> df.plugin.WorldEntitiesWithinResult + 35, // 74: df.plugin.ActionResult.world_viewers:type_name -> df.plugin.WorldViewersResult + 75, // [75:75] is the sub-list for method output_type + 75, // [75:75] is the sub-list for method input_type + 75, // [75:75] is the sub-list for extension type_name + 75, // [75:75] is the sub-list for extension extendee + 0, // [0:75] is the sub-list for field type_name } func init() { file_actions_proto_init() } @@ -1723,24 +3097,44 @@ func file_actions_proto_init() { (*Action_SendTip)(nil), (*Action_PlaySound)(nil), (*Action_ExecuteCommand)(nil), + (*Action_WorldSetDefaultGameMode)(nil), + (*Action_WorldSetDifficulty)(nil), + (*Action_WorldSetTickRange)(nil), + (*Action_WorldSetBlock)(nil), + (*Action_WorldPlaySound)(nil), + (*Action_WorldAddParticle)(nil), + (*Action_WorldQueryEntities)(nil), + (*Action_WorldQueryPlayers)(nil), + (*Action_WorldQueryEntitiesWithin)(nil), + (*Action_WorldQueryViewers)(nil), } file_actions_proto_msgTypes[8].OneofWrappers = []any{} file_actions_proto_msgTypes[9].OneofWrappers = []any{} file_actions_proto_msgTypes[11].OneofWrappers = []any{} file_actions_proto_msgTypes[15].OneofWrappers = []any{} file_actions_proto_msgTypes[18].OneofWrappers = []any{} + file_actions_proto_msgTypes[23].OneofWrappers = []any{} + file_actions_proto_msgTypes[25].OneofWrappers = []any{} + file_actions_proto_msgTypes[30].OneofWrappers = []any{} + file_actions_proto_msgTypes[35].OneofWrappers = []any{ + (*ActionResult_WorldEntities)(nil), + (*ActionResult_WorldPlayers)(nil), + (*ActionResult_WorldEntitiesWithin)(nil), + (*ActionResult_WorldViewers)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_actions_proto_rawDesc), len(file_actions_proto_rawDesc)), - NumEnums: 0, - NumMessages: 20, + NumEnums: 1, + NumMessages: 36, NumExtensions: 0, NumServices: 0, }, GoTypes: file_actions_proto_goTypes, DependencyIndexes: file_actions_proto_depIdxs, + EnumInfos: file_actions_proto_enumTypes, MessageInfos: file_actions_proto_msgTypes, }.Build() File_actions_proto = out.File diff --git a/proto/generated/command.pb.go b/proto/generated/command.pb.go index 4600f4a..146a56e 100644 --- a/proto/generated/command.pb.go +++ b/proto/generated/command.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: command.proto package generated @@ -338,9 +338,7 @@ const file_command_proto_rawDesc = "" + "PARAM_BOOL\x10\x03\x12\x11\n" + "\rPARAM_VARARGS\x10\x04\x12\x0e\n" + "\n" + - "PARAM_ENUM\x10\x05B\x8b\x01\n" + - "\rcom.df.pluginB\fCommandProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + "PARAM_ENUM\x10\x05B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_command_proto_rawDescOnce sync.Once diff --git a/proto/generated/common.pb.go b/proto/generated/common.pb.go index 8802bb4..c5f177c 100644 --- a/proto/generated/common.pb.go +++ b/proto/generated/common.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: common.proto package generated @@ -73,6 +73,58 @@ func (GameMode) EnumDescriptor() ([]byte, []int) { return file_common_proto_rawDescGZIP(), []int{0} } +type Difficulty int32 + +const ( + Difficulty_PEACEFUL Difficulty = 0 + Difficulty_EASY Difficulty = 1 + Difficulty_NORMAL Difficulty = 2 + Difficulty_HARD Difficulty = 3 +) + +// Enum value maps for Difficulty. +var ( + Difficulty_name = map[int32]string{ + 0: "PEACEFUL", + 1: "EASY", + 2: "NORMAL", + 3: "HARD", + } + Difficulty_value = map[string]int32{ + "PEACEFUL": 0, + "EASY": 1, + "NORMAL": 2, + "HARD": 3, + } +) + +func (x Difficulty) Enum() *Difficulty { + p := new(Difficulty) + *p = x + return p +} + +func (x Difficulty) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Difficulty) Descriptor() protoreflect.EnumDescriptor { + return file_common_proto_enumTypes[1].Descriptor() +} + +func (Difficulty) Type() protoreflect.EnumType { + return &file_common_proto_enumTypes[1] +} + +func (x Difficulty) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Difficulty.Descriptor instead. +func (Difficulty) EnumDescriptor() ([]byte, []int) { + return file_common_proto_rawDescGZIP(), []int{1} +} + // EffectType mirrors Dragonfly's registered effect IDs for straightforward mapping. // Keep numeric values aligned with dragonfly/server/entity/effect/register.go. type EffectType int32 @@ -187,11 +239,11 @@ func (x EffectType) String() string { } func (EffectType) Descriptor() protoreflect.EnumDescriptor { - return file_common_proto_enumTypes[1].Descriptor() + return file_common_proto_enumTypes[2].Descriptor() } func (EffectType) Type() protoreflect.EnumType { - return &file_common_proto_enumTypes[1] + return &file_common_proto_enumTypes[2] } func (x EffectType) Number() protoreflect.EnumNumber { @@ -200,7 +252,7 @@ func (x EffectType) Number() protoreflect.EnumNumber { // Deprecated: Use EffectType.Descriptor instead. func (EffectType) EnumDescriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{1} + return file_common_proto_rawDescGZIP(), []int{2} } // Sound is a curated list of common sounds that don't require extra parameters. @@ -293,11 +345,11 @@ func (x Sound) String() string { } func (Sound) Descriptor() protoreflect.EnumDescriptor { - return file_common_proto_enumTypes[2].Descriptor() + return file_common_proto_enumTypes[3].Descriptor() } func (Sound) Type() protoreflect.EnumType { - return &file_common_proto_enumTypes[2] + return &file_common_proto_enumTypes[3] } func (x Sound) Number() protoreflect.EnumNumber { @@ -306,7 +358,7 @@ func (x Sound) Number() protoreflect.EnumNumber { // Deprecated: Use Sound.Descriptor instead. func (Sound) EnumDescriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{2} + return file_common_proto_rawDescGZIP(), []int{3} } // Category for creative inventory @@ -346,11 +398,11 @@ func (x ItemCategory) String() string { } func (ItemCategory) Descriptor() protoreflect.EnumDescriptor { - return file_common_proto_enumTypes[3].Descriptor() + return file_common_proto_enumTypes[4].Descriptor() } func (ItemCategory) Type() protoreflect.EnumType { - return &file_common_proto_enumTypes[3] + return &file_common_proto_enumTypes[4] } func (x ItemCategory) Number() protoreflect.EnumNumber { @@ -359,7 +411,7 @@ func (x ItemCategory) Number() protoreflect.EnumNumber { // Deprecated: Use ItemCategory.Descriptor instead. func (ItemCategory) EnumDescriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{3} + return file_common_proto_rawDescGZIP(), []int{4} } type Vec3 struct { @@ -474,6 +526,58 @@ func (x *Rotation) GetPitch() float32 { return 0 } +type BBox struct { + state protoimpl.MessageState `protogen:"open.v1"` + Min *Vec3 `protobuf:"bytes,1,opt,name=min,proto3" json:"min,omitempty"` + Max *Vec3 `protobuf:"bytes,2,opt,name=max,proto3" json:"max,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *BBox) Reset() { + *x = BBox{} + mi := &file_common_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *BBox) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*BBox) ProtoMessage() {} + +func (x *BBox) ProtoReflect() protoreflect.Message { + mi := &file_common_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use BBox.ProtoReflect.Descriptor instead. +func (*BBox) Descriptor() ([]byte, []int) { + return file_common_proto_rawDescGZIP(), []int{2} +} + +func (x *BBox) GetMin() *Vec3 { + if x != nil { + return x.Min + } + return nil +} + +func (x *BBox) GetMax() *Vec3 { + if x != nil { + return x.Max + } + return nil +} + type BlockPos struct { state protoimpl.MessageState `protogen:"open.v1"` X int32 `protobuf:"varint,1,opt,name=x,proto3" json:"x,omitempty"` @@ -485,7 +589,7 @@ type BlockPos struct { func (x *BlockPos) Reset() { *x = BlockPos{} - mi := &file_common_proto_msgTypes[2] + mi := &file_common_proto_msgTypes[3] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -497,7 +601,7 @@ func (x *BlockPos) String() string { func (*BlockPos) ProtoMessage() {} func (x *BlockPos) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[2] + mi := &file_common_proto_msgTypes[3] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -510,7 +614,7 @@ func (x *BlockPos) ProtoReflect() protoreflect.Message { // Deprecated: Use BlockPos.ProtoReflect.Descriptor instead. func (*BlockPos) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{2} + return file_common_proto_rawDescGZIP(), []int{3} } func (x *BlockPos) GetX() int32 { @@ -545,7 +649,7 @@ type ItemStack struct { func (x *ItemStack) Reset() { *x = ItemStack{} - mi := &file_common_proto_msgTypes[3] + mi := &file_common_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -557,7 +661,7 @@ func (x *ItemStack) String() string { func (*ItemStack) ProtoMessage() {} func (x *ItemStack) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[3] + mi := &file_common_proto_msgTypes[4] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -570,7 +674,7 @@ func (x *ItemStack) ProtoReflect() protoreflect.Message { // Deprecated: Use ItemStack.ProtoReflect.Descriptor instead. func (*ItemStack) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{3} + return file_common_proto_rawDescGZIP(), []int{4} } func (x *ItemStack) GetName() string { @@ -604,7 +708,7 @@ type BlockState struct { func (x *BlockState) Reset() { *x = BlockState{} - mi := &file_common_proto_msgTypes[4] + mi := &file_common_proto_msgTypes[5] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -616,7 +720,7 @@ func (x *BlockState) String() string { func (*BlockState) ProtoMessage() {} func (x *BlockState) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[4] + mi := &file_common_proto_msgTypes[5] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -629,7 +733,7 @@ func (x *BlockState) ProtoReflect() protoreflect.Message { // Deprecated: Use BlockState.ProtoReflect.Descriptor instead. func (*BlockState) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{4} + return file_common_proto_rawDescGZIP(), []int{5} } func (x *BlockState) GetName() string { @@ -658,7 +762,7 @@ type LiquidState struct { func (x *LiquidState) Reset() { *x = LiquidState{} - mi := &file_common_proto_msgTypes[5] + mi := &file_common_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -670,7 +774,7 @@ func (x *LiquidState) String() string { func (*LiquidState) ProtoMessage() {} func (x *LiquidState) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[5] + mi := &file_common_proto_msgTypes[6] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -683,7 +787,7 @@ func (x *LiquidState) ProtoReflect() protoreflect.Message { // Deprecated: Use LiquidState.ProtoReflect.Descriptor instead. func (*LiquidState) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{5} + return file_common_proto_rawDescGZIP(), []int{6} } func (x *LiquidState) GetBlock() *BlockState { @@ -724,7 +828,7 @@ type WorldRef struct { func (x *WorldRef) Reset() { *x = WorldRef{} - mi := &file_common_proto_msgTypes[6] + mi := &file_common_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -736,7 +840,7 @@ func (x *WorldRef) String() string { func (*WorldRef) ProtoMessage() {} func (x *WorldRef) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[6] + mi := &file_common_proto_msgTypes[7] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -749,7 +853,7 @@ func (x *WorldRef) ProtoReflect() protoreflect.Message { // Deprecated: Use WorldRef.ProtoReflect.Descriptor instead. func (*WorldRef) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{6} + return file_common_proto_rawDescGZIP(), []int{7} } func (x *WorldRef) GetName() string { @@ -779,7 +883,7 @@ type EntityRef struct { func (x *EntityRef) Reset() { *x = EntityRef{} - mi := &file_common_proto_msgTypes[7] + mi := &file_common_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -791,7 +895,7 @@ func (x *EntityRef) String() string { func (*EntityRef) ProtoMessage() {} func (x *EntityRef) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[7] + mi := &file_common_proto_msgTypes[8] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -804,7 +908,7 @@ func (x *EntityRef) ProtoReflect() protoreflect.Message { // Deprecated: Use EntityRef.ProtoReflect.Descriptor instead. func (*EntityRef) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{7} + return file_common_proto_rawDescGZIP(), []int{8} } func (x *EntityRef) GetUuid() string { @@ -852,7 +956,7 @@ type DamageSource struct { func (x *DamageSource) Reset() { *x = DamageSource{} - mi := &file_common_proto_msgTypes[8] + mi := &file_common_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -864,7 +968,7 @@ func (x *DamageSource) String() string { func (*DamageSource) ProtoMessage() {} func (x *DamageSource) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[8] + mi := &file_common_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -877,7 +981,7 @@ func (x *DamageSource) ProtoReflect() protoreflect.Message { // Deprecated: Use DamageSource.ProtoReflect.Descriptor instead. func (*DamageSource) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{8} + return file_common_proto_rawDescGZIP(), []int{9} } func (x *DamageSource) GetType() string { @@ -904,7 +1008,7 @@ type HealingSource struct { func (x *HealingSource) Reset() { *x = HealingSource{} - mi := &file_common_proto_msgTypes[9] + mi := &file_common_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -916,7 +1020,7 @@ func (x *HealingSource) String() string { func (*HealingSource) ProtoMessage() {} func (x *HealingSource) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[9] + mi := &file_common_proto_msgTypes[10] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -929,7 +1033,7 @@ func (x *HealingSource) ProtoReflect() protoreflect.Message { // Deprecated: Use HealingSource.ProtoReflect.Descriptor instead. func (*HealingSource) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{9} + return file_common_proto_rawDescGZIP(), []int{10} } func (x *HealingSource) GetType() string { @@ -956,7 +1060,7 @@ type Address struct { func (x *Address) Reset() { *x = Address{} - mi := &file_common_proto_msgTypes[10] + mi := &file_common_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -968,7 +1072,7 @@ func (x *Address) String() string { func (*Address) ProtoMessage() {} func (x *Address) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[10] + mi := &file_common_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -981,7 +1085,7 @@ func (x *Address) ProtoReflect() protoreflect.Message { // Deprecated: Use Address.ProtoReflect.Descriptor instead. func (*Address) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{10} + return file_common_proto_rawDescGZIP(), []int{11} } func (x *Address) GetHost() string { @@ -1014,7 +1118,7 @@ type CustomItemDefinition struct { func (x *CustomItemDefinition) Reset() { *x = CustomItemDefinition{} - mi := &file_common_proto_msgTypes[11] + mi := &file_common_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1026,7 +1130,7 @@ func (x *CustomItemDefinition) String() string { func (*CustomItemDefinition) ProtoMessage() {} func (x *CustomItemDefinition) ProtoReflect() protoreflect.Message { - mi := &file_common_proto_msgTypes[11] + mi := &file_common_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1039,7 +1143,7 @@ func (x *CustomItemDefinition) ProtoReflect() protoreflect.Message { // Deprecated: Use CustomItemDefinition.ProtoReflect.Descriptor instead. func (*CustomItemDefinition) Descriptor() ([]byte, []int) { - return file_common_proto_rawDescGZIP(), []int{11} + return file_common_proto_rawDescGZIP(), []int{12} } func (x *CustomItemDefinition) GetId() string { @@ -1095,7 +1199,10 @@ const file_common_proto_rawDesc = "" + "\x01z\x18\x03 \x01(\x01R\x01z\"2\n" + "\bRotation\x12\x10\n" + "\x03yaw\x18\x01 \x01(\x02R\x03yaw\x12\x14\n" + - "\x05pitch\x18\x02 \x01(\x02R\x05pitch\"4\n" + + "\x05pitch\x18\x02 \x01(\x02R\x05pitch\"L\n" + + "\x04BBox\x12!\n" + + "\x03min\x18\x01 \x01(\v2\x0f.df.plugin.Vec3R\x03min\x12!\n" + + "\x03max\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\x03max\"4\n" + "\bBlockPos\x12\f\n" + "\x01x\x18\x01 \x01(\x05R\x01x\x12\f\n" + "\x01y\x18\x02 \x01(\x05R\x01y\x12\f\n" + @@ -1154,7 +1261,14 @@ const file_common_proto_rawDesc = "" + "\bSURVIVAL\x10\x00\x12\f\n" + "\bCREATIVE\x10\x01\x12\r\n" + "\tADVENTURE\x10\x02\x12\r\n" + - "\tSPECTATOR\x10\x03*\xe2\x03\n" + + "\tSPECTATOR\x10\x03*:\n" + + "\n" + + "Difficulty\x12\f\n" + + "\bPEACEFUL\x10\x00\x12\b\n" + + "\x04EASY\x10\x01\x12\n" + + "\n" + + "\x06NORMAL\x10\x02\x12\b\n" + + "\x04HARD\x10\x03*\xe2\x03\n" + "\n" + "EffectType\x12\x12\n" + "\x0eEFFECT_UNKNOWN\x10\x00\x12\t\n" + @@ -1227,9 +1341,7 @@ const file_common_proto_rawDesc = "" + "\x1aITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\n" + "\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1b\n" + "\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\n" + - "\x13ITEM_CATEGORY_ITEMS\x10\x03B\x8a\x01\n" + - "\rcom.df.pluginB\vCommonProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + "\x13ITEM_CATEGORY_ITEMS\x10\x03B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_common_proto_rawDescOnce sync.Once @@ -1243,38 +1355,42 @@ func file_common_proto_rawDescGZIP() []byte { return file_common_proto_rawDescData } -var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 4) -var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 13) +var file_common_proto_enumTypes = make([]protoimpl.EnumInfo, 5) +var file_common_proto_msgTypes = make([]protoimpl.MessageInfo, 14) var file_common_proto_goTypes = []any{ (GameMode)(0), // 0: df.plugin.GameMode - (EffectType)(0), // 1: df.plugin.EffectType - (Sound)(0), // 2: df.plugin.Sound - (ItemCategory)(0), // 3: df.plugin.ItemCategory - (*Vec3)(nil), // 4: df.plugin.Vec3 - (*Rotation)(nil), // 5: df.plugin.Rotation - (*BlockPos)(nil), // 6: df.plugin.BlockPos - (*ItemStack)(nil), // 7: df.plugin.ItemStack - (*BlockState)(nil), // 8: df.plugin.BlockState - (*LiquidState)(nil), // 9: df.plugin.LiquidState - (*WorldRef)(nil), // 10: df.plugin.WorldRef - (*EntityRef)(nil), // 11: df.plugin.EntityRef - (*DamageSource)(nil), // 12: df.plugin.DamageSource - (*HealingSource)(nil), // 13: df.plugin.HealingSource - (*Address)(nil), // 14: df.plugin.Address - (*CustomItemDefinition)(nil), // 15: df.plugin.CustomItemDefinition - nil, // 16: df.plugin.BlockState.PropertiesEntry + (Difficulty)(0), // 1: df.plugin.Difficulty + (EffectType)(0), // 2: df.plugin.EffectType + (Sound)(0), // 3: df.plugin.Sound + (ItemCategory)(0), // 4: df.plugin.ItemCategory + (*Vec3)(nil), // 5: df.plugin.Vec3 + (*Rotation)(nil), // 6: df.plugin.Rotation + (*BBox)(nil), // 7: df.plugin.BBox + (*BlockPos)(nil), // 8: df.plugin.BlockPos + (*ItemStack)(nil), // 9: df.plugin.ItemStack + (*BlockState)(nil), // 10: df.plugin.BlockState + (*LiquidState)(nil), // 11: df.plugin.LiquidState + (*WorldRef)(nil), // 12: df.plugin.WorldRef + (*EntityRef)(nil), // 13: df.plugin.EntityRef + (*DamageSource)(nil), // 14: df.plugin.DamageSource + (*HealingSource)(nil), // 15: df.plugin.HealingSource + (*Address)(nil), // 16: df.plugin.Address + (*CustomItemDefinition)(nil), // 17: df.plugin.CustomItemDefinition + nil, // 18: df.plugin.BlockState.PropertiesEntry } var file_common_proto_depIdxs = []int32{ - 16, // 0: df.plugin.BlockState.properties:type_name -> df.plugin.BlockState.PropertiesEntry - 8, // 1: df.plugin.LiquidState.block:type_name -> df.plugin.BlockState - 4, // 2: df.plugin.EntityRef.position:type_name -> df.plugin.Vec3 - 5, // 3: df.plugin.EntityRef.rotation:type_name -> df.plugin.Rotation - 3, // 4: df.plugin.CustomItemDefinition.category:type_name -> df.plugin.ItemCategory - 5, // [5:5] is the sub-list for method output_type - 5, // [5:5] is the sub-list for method input_type - 5, // [5:5] is the sub-list for extension type_name - 5, // [5:5] is the sub-list for extension extendee - 0, // [0:5] is the sub-list for field type_name + 5, // 0: df.plugin.BBox.min:type_name -> df.plugin.Vec3 + 5, // 1: df.plugin.BBox.max:type_name -> df.plugin.Vec3 + 18, // 2: df.plugin.BlockState.properties:type_name -> df.plugin.BlockState.PropertiesEntry + 10, // 3: df.plugin.LiquidState.block:type_name -> df.plugin.BlockState + 5, // 4: df.plugin.EntityRef.position:type_name -> df.plugin.Vec3 + 6, // 5: df.plugin.EntityRef.rotation:type_name -> df.plugin.Rotation + 4, // 6: df.plugin.CustomItemDefinition.category:type_name -> df.plugin.ItemCategory + 7, // [7:7] is the sub-list for method output_type + 7, // [7:7] is the sub-list for method input_type + 7, // [7:7] is the sub-list for extension type_name + 7, // [7:7] is the sub-list for extension extendee + 0, // [0:7] is the sub-list for field type_name } func init() { file_common_proto_init() } @@ -1282,17 +1398,17 @@ func file_common_proto_init() { if File_common_proto != nil { return } - file_common_proto_msgTypes[7].OneofWrappers = []any{} file_common_proto_msgTypes[8].OneofWrappers = []any{} file_common_proto_msgTypes[9].OneofWrappers = []any{} - file_common_proto_msgTypes[11].OneofWrappers = []any{} + file_common_proto_msgTypes[10].OneofWrappers = []any{} + file_common_proto_msgTypes[12].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_common_proto_rawDesc), len(file_common_proto_rawDesc)), - NumEnums: 4, - NumMessages: 13, + NumEnums: 5, + NumMessages: 14, NumExtensions: 0, NumServices: 0, }, diff --git a/proto/generated/mutations.pb.go b/proto/generated/mutations.pb.go index f1c5768..ae2e9de 100644 --- a/proto/generated/mutations.pb.go +++ b/proto/generated/mutations.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: mutations.proto package generated @@ -1155,9 +1155,7 @@ const file_mutations_proto_rawDesc = "" + "\r_entity_uuidsB\t\n" + "\a_blocksB\x13\n" + "\x11_item_drop_chanceB\r\n" + - "\v_spawn_fireB\x8d\x01\n" + - "\rcom.df.pluginB\x0eMutationsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + "\v_spawn_fireB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_mutations_proto_rawDescOnce sync.Once diff --git a/proto/generated/player_events.pb.go b/proto/generated/player_events.pb.go index fe2c301..dc9d03f 100644 --- a/proto/generated/player_events.pb.go +++ b/proto/generated/player_events.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: player_events.proto package generated @@ -2902,9 +2902,7 @@ const file_player_events_proto_rawDesc = "" + "\x16average_end_frame_time\x18\t \x01(\x01R\x13averageEndFrameTime\x12C\n" + "\x1eaverage_remainder_time_percent\x18\n" + " \x01(\x01R\x1baverageRemainderTimePercent\x12G\n" + - " average_unaccounted_time_percent\x18\v \x01(\x01R\x1daverageUnaccountedTimePercentB\x90\x01\n" + - "\rcom.df.pluginB\x11PlayerEventsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + " average_unaccounted_time_percent\x18\v \x01(\x01R\x1daverageUnaccountedTimePercentB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_player_events_proto_rawDescOnce sync.Once diff --git a/proto/generated/plugin.pb.go b/proto/generated/plugin.pb.go index 56bba10..52d8c77 100644 --- a/proto/generated/plugin.pb.go +++ b/proto/generated/plugin.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: plugin.proto package generated @@ -222,6 +222,7 @@ type HostToPlugin struct { // *HostToPlugin_Hello // *HostToPlugin_Shutdown // *HostToPlugin_Event + // *HostToPlugin_ActionResult Payload isHostToPlugin_Payload `protobuf_oneof:"payload"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -298,6 +299,15 @@ func (x *HostToPlugin) GetEvent() *EventEnvelope { return nil } +func (x *HostToPlugin) GetActionResult() *ActionResult { + if x != nil { + if x, ok := x.Payload.(*HostToPlugin_ActionResult); ok { + return x.ActionResult + } + } + return nil +} + type isHostToPlugin_Payload interface { isHostToPlugin_Payload() } @@ -314,12 +324,18 @@ type HostToPlugin_Event struct { Event *EventEnvelope `protobuf:"bytes,20,opt,name=event,proto3,oneof"` } +type HostToPlugin_ActionResult struct { + ActionResult *ActionResult `protobuf:"bytes,21,opt,name=action_result,json=actionResult,proto3,oneof"` +} + func (*HostToPlugin_Hello) isHostToPlugin_Payload() {} func (*HostToPlugin_Shutdown) isHostToPlugin_Payload() {} func (*HostToPlugin_Event) isHostToPlugin_Payload() {} +func (*HostToPlugin_ActionResult) isHostToPlugin_Payload() {} + type HostHello struct { state protoimpl.MessageState `protogen:"open.v1"` ApiVersion string `protobuf:"bytes,1,opt,name=api_version,json=apiVersion,proto3" json:"api_version,omitempty"` @@ -1580,13 +1596,14 @@ var File_plugin_proto protoreflect.FileDescriptor const file_plugin_proto_rawDesc = "" + "\n" + - "\fplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\fcommon.proto\"\xcd\x01\n" + + "\fplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\fcommon.proto\"\x8d\x02\n" + "\fHostToPlugin\x12\x1b\n" + "\tplugin_id\x18\x01 \x01(\tR\bpluginId\x12,\n" + "\x05hello\x18\n" + " \x01(\v2\x14.df.plugin.HostHelloH\x00R\x05hello\x125\n" + "\bshutdown\x18\v \x01(\v2\x17.df.plugin.HostShutdownH\x00R\bshutdown\x120\n" + - "\x05event\x18\x14 \x01(\v2\x18.df.plugin.EventEnvelopeH\x00R\x05eventB\t\n" + + "\x05event\x18\x14 \x01(\v2\x18.df.plugin.EventEnvelopeH\x00R\x05event\x12>\n" + + "\raction_result\x18\x15 \x01(\v2\x17.df.plugin.ActionResultH\x00R\factionResultB\t\n" + "\apayload\",\n" + "\tHostHello\x12\x1f\n" + "\vapi_version\x18\x01 \x01(\tR\n" + @@ -1733,9 +1750,7 @@ const file_plugin_proto_rawDesc = "" + "\x0fWORLD_EXPLOSION\x10P\x12\x0f\n" + "\vWORLD_CLOSE\x10Q2M\n" + "\x06Plugin\x12C\n" + - "\vEventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x010\x01B\x8a\x01\n" + - "\rcom.df.pluginB\vPluginProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + "\vEventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x010\x01B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_plugin_proto_rawDescOnce sync.Once @@ -1761,129 +1776,131 @@ var file_plugin_proto_goTypes = []any{ (*PluginHello)(nil), // 6: df.plugin.PluginHello (*LogMessage)(nil), // 7: df.plugin.LogMessage (*EventSubscribe)(nil), // 8: df.plugin.EventSubscribe - (*PlayerJoinEvent)(nil), // 9: df.plugin.PlayerJoinEvent - (*PlayerQuitEvent)(nil), // 10: df.plugin.PlayerQuitEvent - (*PlayerMoveEvent)(nil), // 11: df.plugin.PlayerMoveEvent - (*PlayerJumpEvent)(nil), // 12: df.plugin.PlayerJumpEvent - (*PlayerTeleportEvent)(nil), // 13: df.plugin.PlayerTeleportEvent - (*PlayerChangeWorldEvent)(nil), // 14: df.plugin.PlayerChangeWorldEvent - (*PlayerToggleSprintEvent)(nil), // 15: df.plugin.PlayerToggleSprintEvent - (*PlayerToggleSneakEvent)(nil), // 16: df.plugin.PlayerToggleSneakEvent - (*ChatEvent)(nil), // 17: df.plugin.ChatEvent - (*PlayerFoodLossEvent)(nil), // 18: df.plugin.PlayerFoodLossEvent - (*PlayerHealEvent)(nil), // 19: df.plugin.PlayerHealEvent - (*PlayerHurtEvent)(nil), // 20: df.plugin.PlayerHurtEvent - (*PlayerDeathEvent)(nil), // 21: df.plugin.PlayerDeathEvent - (*PlayerRespawnEvent)(nil), // 22: df.plugin.PlayerRespawnEvent - (*PlayerSkinChangeEvent)(nil), // 23: df.plugin.PlayerSkinChangeEvent - (*PlayerFireExtinguishEvent)(nil), // 24: df.plugin.PlayerFireExtinguishEvent - (*PlayerStartBreakEvent)(nil), // 25: df.plugin.PlayerStartBreakEvent - (*BlockBreakEvent)(nil), // 26: df.plugin.BlockBreakEvent - (*PlayerBlockPlaceEvent)(nil), // 27: df.plugin.PlayerBlockPlaceEvent - (*PlayerBlockPickEvent)(nil), // 28: df.plugin.PlayerBlockPickEvent - (*PlayerItemUseEvent)(nil), // 29: df.plugin.PlayerItemUseEvent - (*PlayerItemUseOnBlockEvent)(nil), // 30: df.plugin.PlayerItemUseOnBlockEvent - (*PlayerItemUseOnEntityEvent)(nil), // 31: df.plugin.PlayerItemUseOnEntityEvent - (*PlayerItemReleaseEvent)(nil), // 32: df.plugin.PlayerItemReleaseEvent - (*PlayerItemConsumeEvent)(nil), // 33: df.plugin.PlayerItemConsumeEvent - (*PlayerAttackEntityEvent)(nil), // 34: df.plugin.PlayerAttackEntityEvent - (*PlayerExperienceGainEvent)(nil), // 35: df.plugin.PlayerExperienceGainEvent - (*PlayerPunchAirEvent)(nil), // 36: df.plugin.PlayerPunchAirEvent - (*PlayerSignEditEvent)(nil), // 37: df.plugin.PlayerSignEditEvent - (*PlayerLecternPageTurnEvent)(nil), // 38: df.plugin.PlayerLecternPageTurnEvent - (*PlayerItemDamageEvent)(nil), // 39: df.plugin.PlayerItemDamageEvent - (*PlayerItemPickupEvent)(nil), // 40: df.plugin.PlayerItemPickupEvent - (*PlayerHeldSlotChangeEvent)(nil), // 41: df.plugin.PlayerHeldSlotChangeEvent - (*PlayerItemDropEvent)(nil), // 42: df.plugin.PlayerItemDropEvent - (*PlayerTransferEvent)(nil), // 43: df.plugin.PlayerTransferEvent - (*CommandEvent)(nil), // 44: df.plugin.CommandEvent - (*PlayerDiagnosticsEvent)(nil), // 45: df.plugin.PlayerDiagnosticsEvent - (*WorldLiquidFlowEvent)(nil), // 46: df.plugin.WorldLiquidFlowEvent - (*WorldLiquidDecayEvent)(nil), // 47: df.plugin.WorldLiquidDecayEvent - (*WorldLiquidHardenEvent)(nil), // 48: df.plugin.WorldLiquidHardenEvent - (*WorldSoundEvent)(nil), // 49: df.plugin.WorldSoundEvent - (*WorldFireSpreadEvent)(nil), // 50: df.plugin.WorldFireSpreadEvent - (*WorldBlockBurnEvent)(nil), // 51: df.plugin.WorldBlockBurnEvent - (*WorldCropTrampleEvent)(nil), // 52: df.plugin.WorldCropTrampleEvent - (*WorldLeavesDecayEvent)(nil), // 53: df.plugin.WorldLeavesDecayEvent - (*WorldEntitySpawnEvent)(nil), // 54: df.plugin.WorldEntitySpawnEvent - (*WorldEntityDespawnEvent)(nil), // 55: df.plugin.WorldEntityDespawnEvent - (*WorldExplosionEvent)(nil), // 56: df.plugin.WorldExplosionEvent - (*WorldCloseEvent)(nil), // 57: df.plugin.WorldCloseEvent - (*ActionBatch)(nil), // 58: df.plugin.ActionBatch - (*EventResult)(nil), // 59: df.plugin.EventResult - (*CommandSpec)(nil), // 60: df.plugin.CommandSpec - (*CustomItemDefinition)(nil), // 61: df.plugin.CustomItemDefinition + (*ActionResult)(nil), // 9: df.plugin.ActionResult + (*PlayerJoinEvent)(nil), // 10: df.plugin.PlayerJoinEvent + (*PlayerQuitEvent)(nil), // 11: df.plugin.PlayerQuitEvent + (*PlayerMoveEvent)(nil), // 12: df.plugin.PlayerMoveEvent + (*PlayerJumpEvent)(nil), // 13: df.plugin.PlayerJumpEvent + (*PlayerTeleportEvent)(nil), // 14: df.plugin.PlayerTeleportEvent + (*PlayerChangeWorldEvent)(nil), // 15: df.plugin.PlayerChangeWorldEvent + (*PlayerToggleSprintEvent)(nil), // 16: df.plugin.PlayerToggleSprintEvent + (*PlayerToggleSneakEvent)(nil), // 17: df.plugin.PlayerToggleSneakEvent + (*ChatEvent)(nil), // 18: df.plugin.ChatEvent + (*PlayerFoodLossEvent)(nil), // 19: df.plugin.PlayerFoodLossEvent + (*PlayerHealEvent)(nil), // 20: df.plugin.PlayerHealEvent + (*PlayerHurtEvent)(nil), // 21: df.plugin.PlayerHurtEvent + (*PlayerDeathEvent)(nil), // 22: df.plugin.PlayerDeathEvent + (*PlayerRespawnEvent)(nil), // 23: df.plugin.PlayerRespawnEvent + (*PlayerSkinChangeEvent)(nil), // 24: df.plugin.PlayerSkinChangeEvent + (*PlayerFireExtinguishEvent)(nil), // 25: df.plugin.PlayerFireExtinguishEvent + (*PlayerStartBreakEvent)(nil), // 26: df.plugin.PlayerStartBreakEvent + (*BlockBreakEvent)(nil), // 27: df.plugin.BlockBreakEvent + (*PlayerBlockPlaceEvent)(nil), // 28: df.plugin.PlayerBlockPlaceEvent + (*PlayerBlockPickEvent)(nil), // 29: df.plugin.PlayerBlockPickEvent + (*PlayerItemUseEvent)(nil), // 30: df.plugin.PlayerItemUseEvent + (*PlayerItemUseOnBlockEvent)(nil), // 31: df.plugin.PlayerItemUseOnBlockEvent + (*PlayerItemUseOnEntityEvent)(nil), // 32: df.plugin.PlayerItemUseOnEntityEvent + (*PlayerItemReleaseEvent)(nil), // 33: df.plugin.PlayerItemReleaseEvent + (*PlayerItemConsumeEvent)(nil), // 34: df.plugin.PlayerItemConsumeEvent + (*PlayerAttackEntityEvent)(nil), // 35: df.plugin.PlayerAttackEntityEvent + (*PlayerExperienceGainEvent)(nil), // 36: df.plugin.PlayerExperienceGainEvent + (*PlayerPunchAirEvent)(nil), // 37: df.plugin.PlayerPunchAirEvent + (*PlayerSignEditEvent)(nil), // 38: df.plugin.PlayerSignEditEvent + (*PlayerLecternPageTurnEvent)(nil), // 39: df.plugin.PlayerLecternPageTurnEvent + (*PlayerItemDamageEvent)(nil), // 40: df.plugin.PlayerItemDamageEvent + (*PlayerItemPickupEvent)(nil), // 41: df.plugin.PlayerItemPickupEvent + (*PlayerHeldSlotChangeEvent)(nil), // 42: df.plugin.PlayerHeldSlotChangeEvent + (*PlayerItemDropEvent)(nil), // 43: df.plugin.PlayerItemDropEvent + (*PlayerTransferEvent)(nil), // 44: df.plugin.PlayerTransferEvent + (*CommandEvent)(nil), // 45: df.plugin.CommandEvent + (*PlayerDiagnosticsEvent)(nil), // 46: df.plugin.PlayerDiagnosticsEvent + (*WorldLiquidFlowEvent)(nil), // 47: df.plugin.WorldLiquidFlowEvent + (*WorldLiquidDecayEvent)(nil), // 48: df.plugin.WorldLiquidDecayEvent + (*WorldLiquidHardenEvent)(nil), // 49: df.plugin.WorldLiquidHardenEvent + (*WorldSoundEvent)(nil), // 50: df.plugin.WorldSoundEvent + (*WorldFireSpreadEvent)(nil), // 51: df.plugin.WorldFireSpreadEvent + (*WorldBlockBurnEvent)(nil), // 52: df.plugin.WorldBlockBurnEvent + (*WorldCropTrampleEvent)(nil), // 53: df.plugin.WorldCropTrampleEvent + (*WorldLeavesDecayEvent)(nil), // 54: df.plugin.WorldLeavesDecayEvent + (*WorldEntitySpawnEvent)(nil), // 55: df.plugin.WorldEntitySpawnEvent + (*WorldEntityDespawnEvent)(nil), // 56: df.plugin.WorldEntityDespawnEvent + (*WorldExplosionEvent)(nil), // 57: df.plugin.WorldExplosionEvent + (*WorldCloseEvent)(nil), // 58: df.plugin.WorldCloseEvent + (*ActionBatch)(nil), // 59: df.plugin.ActionBatch + (*EventResult)(nil), // 60: df.plugin.EventResult + (*CommandSpec)(nil), // 61: df.plugin.CommandSpec + (*CustomItemDefinition)(nil), // 62: df.plugin.CustomItemDefinition } var file_plugin_proto_depIdxs = []int32{ 2, // 0: df.plugin.HostToPlugin.hello:type_name -> df.plugin.HostHello 3, // 1: df.plugin.HostToPlugin.shutdown:type_name -> df.plugin.HostShutdown 4, // 2: df.plugin.HostToPlugin.event:type_name -> df.plugin.EventEnvelope - 0, // 3: df.plugin.EventEnvelope.type:type_name -> df.plugin.EventType - 9, // 4: df.plugin.EventEnvelope.player_join:type_name -> df.plugin.PlayerJoinEvent - 10, // 5: df.plugin.EventEnvelope.player_quit:type_name -> df.plugin.PlayerQuitEvent - 11, // 6: df.plugin.EventEnvelope.player_move:type_name -> df.plugin.PlayerMoveEvent - 12, // 7: df.plugin.EventEnvelope.player_jump:type_name -> df.plugin.PlayerJumpEvent - 13, // 8: df.plugin.EventEnvelope.player_teleport:type_name -> df.plugin.PlayerTeleportEvent - 14, // 9: df.plugin.EventEnvelope.player_change_world:type_name -> df.plugin.PlayerChangeWorldEvent - 15, // 10: df.plugin.EventEnvelope.player_toggle_sprint:type_name -> df.plugin.PlayerToggleSprintEvent - 16, // 11: df.plugin.EventEnvelope.player_toggle_sneak:type_name -> df.plugin.PlayerToggleSneakEvent - 17, // 12: df.plugin.EventEnvelope.chat:type_name -> df.plugin.ChatEvent - 18, // 13: df.plugin.EventEnvelope.player_food_loss:type_name -> df.plugin.PlayerFoodLossEvent - 19, // 14: df.plugin.EventEnvelope.player_heal:type_name -> df.plugin.PlayerHealEvent - 20, // 15: df.plugin.EventEnvelope.player_hurt:type_name -> df.plugin.PlayerHurtEvent - 21, // 16: df.plugin.EventEnvelope.player_death:type_name -> df.plugin.PlayerDeathEvent - 22, // 17: df.plugin.EventEnvelope.player_respawn:type_name -> df.plugin.PlayerRespawnEvent - 23, // 18: df.plugin.EventEnvelope.player_skin_change:type_name -> df.plugin.PlayerSkinChangeEvent - 24, // 19: df.plugin.EventEnvelope.player_fire_extinguish:type_name -> df.plugin.PlayerFireExtinguishEvent - 25, // 20: df.plugin.EventEnvelope.player_start_break:type_name -> df.plugin.PlayerStartBreakEvent - 26, // 21: df.plugin.EventEnvelope.block_break:type_name -> df.plugin.BlockBreakEvent - 27, // 22: df.plugin.EventEnvelope.player_block_place:type_name -> df.plugin.PlayerBlockPlaceEvent - 28, // 23: df.plugin.EventEnvelope.player_block_pick:type_name -> df.plugin.PlayerBlockPickEvent - 29, // 24: df.plugin.EventEnvelope.player_item_use:type_name -> df.plugin.PlayerItemUseEvent - 30, // 25: df.plugin.EventEnvelope.player_item_use_on_block:type_name -> df.plugin.PlayerItemUseOnBlockEvent - 31, // 26: df.plugin.EventEnvelope.player_item_use_on_entity:type_name -> df.plugin.PlayerItemUseOnEntityEvent - 32, // 27: df.plugin.EventEnvelope.player_item_release:type_name -> df.plugin.PlayerItemReleaseEvent - 33, // 28: df.plugin.EventEnvelope.player_item_consume:type_name -> df.plugin.PlayerItemConsumeEvent - 34, // 29: df.plugin.EventEnvelope.player_attack_entity:type_name -> df.plugin.PlayerAttackEntityEvent - 35, // 30: df.plugin.EventEnvelope.player_experience_gain:type_name -> df.plugin.PlayerExperienceGainEvent - 36, // 31: df.plugin.EventEnvelope.player_punch_air:type_name -> df.plugin.PlayerPunchAirEvent - 37, // 32: df.plugin.EventEnvelope.player_sign_edit:type_name -> df.plugin.PlayerSignEditEvent - 38, // 33: df.plugin.EventEnvelope.player_lectern_page_turn:type_name -> df.plugin.PlayerLecternPageTurnEvent - 39, // 34: df.plugin.EventEnvelope.player_item_damage:type_name -> df.plugin.PlayerItemDamageEvent - 40, // 35: df.plugin.EventEnvelope.player_item_pickup:type_name -> df.plugin.PlayerItemPickupEvent - 41, // 36: df.plugin.EventEnvelope.player_held_slot_change:type_name -> df.plugin.PlayerHeldSlotChangeEvent - 42, // 37: df.plugin.EventEnvelope.player_item_drop:type_name -> df.plugin.PlayerItemDropEvent - 43, // 38: df.plugin.EventEnvelope.player_transfer:type_name -> df.plugin.PlayerTransferEvent - 44, // 39: df.plugin.EventEnvelope.command:type_name -> df.plugin.CommandEvent - 45, // 40: df.plugin.EventEnvelope.player_diagnostics:type_name -> df.plugin.PlayerDiagnosticsEvent - 46, // 41: df.plugin.EventEnvelope.world_liquid_flow:type_name -> df.plugin.WorldLiquidFlowEvent - 47, // 42: df.plugin.EventEnvelope.world_liquid_decay:type_name -> df.plugin.WorldLiquidDecayEvent - 48, // 43: df.plugin.EventEnvelope.world_liquid_harden:type_name -> df.plugin.WorldLiquidHardenEvent - 49, // 44: df.plugin.EventEnvelope.world_sound:type_name -> df.plugin.WorldSoundEvent - 50, // 45: df.plugin.EventEnvelope.world_fire_spread:type_name -> df.plugin.WorldFireSpreadEvent - 51, // 46: df.plugin.EventEnvelope.world_block_burn:type_name -> df.plugin.WorldBlockBurnEvent - 52, // 47: df.plugin.EventEnvelope.world_crop_trample:type_name -> df.plugin.WorldCropTrampleEvent - 53, // 48: df.plugin.EventEnvelope.world_leaves_decay:type_name -> df.plugin.WorldLeavesDecayEvent - 54, // 49: df.plugin.EventEnvelope.world_entity_spawn:type_name -> df.plugin.WorldEntitySpawnEvent - 55, // 50: df.plugin.EventEnvelope.world_entity_despawn:type_name -> df.plugin.WorldEntityDespawnEvent - 56, // 51: df.plugin.EventEnvelope.world_explosion:type_name -> df.plugin.WorldExplosionEvent - 57, // 52: df.plugin.EventEnvelope.world_close:type_name -> df.plugin.WorldCloseEvent - 6, // 53: df.plugin.PluginToHost.hello:type_name -> df.plugin.PluginHello - 8, // 54: df.plugin.PluginToHost.subscribe:type_name -> df.plugin.EventSubscribe - 58, // 55: df.plugin.PluginToHost.actions:type_name -> df.plugin.ActionBatch - 7, // 56: df.plugin.PluginToHost.log:type_name -> df.plugin.LogMessage - 59, // 57: df.plugin.PluginToHost.event_result:type_name -> df.plugin.EventResult - 60, // 58: df.plugin.PluginHello.commands:type_name -> df.plugin.CommandSpec - 61, // 59: df.plugin.PluginHello.custom_items:type_name -> df.plugin.CustomItemDefinition - 0, // 60: df.plugin.EventSubscribe.events:type_name -> df.plugin.EventType - 5, // 61: df.plugin.Plugin.EventStream:input_type -> df.plugin.PluginToHost - 1, // 62: df.plugin.Plugin.EventStream:output_type -> df.plugin.HostToPlugin - 62, // [62:63] is the sub-list for method output_type - 61, // [61:62] is the sub-list for method input_type - 61, // [61:61] is the sub-list for extension type_name - 61, // [61:61] is the sub-list for extension extendee - 0, // [0:61] is the sub-list for field type_name + 9, // 3: df.plugin.HostToPlugin.action_result:type_name -> df.plugin.ActionResult + 0, // 4: df.plugin.EventEnvelope.type:type_name -> df.plugin.EventType + 10, // 5: df.plugin.EventEnvelope.player_join:type_name -> df.plugin.PlayerJoinEvent + 11, // 6: df.plugin.EventEnvelope.player_quit:type_name -> df.plugin.PlayerQuitEvent + 12, // 7: df.plugin.EventEnvelope.player_move:type_name -> df.plugin.PlayerMoveEvent + 13, // 8: df.plugin.EventEnvelope.player_jump:type_name -> df.plugin.PlayerJumpEvent + 14, // 9: df.plugin.EventEnvelope.player_teleport:type_name -> df.plugin.PlayerTeleportEvent + 15, // 10: df.plugin.EventEnvelope.player_change_world:type_name -> df.plugin.PlayerChangeWorldEvent + 16, // 11: df.plugin.EventEnvelope.player_toggle_sprint:type_name -> df.plugin.PlayerToggleSprintEvent + 17, // 12: df.plugin.EventEnvelope.player_toggle_sneak:type_name -> df.plugin.PlayerToggleSneakEvent + 18, // 13: df.plugin.EventEnvelope.chat:type_name -> df.plugin.ChatEvent + 19, // 14: df.plugin.EventEnvelope.player_food_loss:type_name -> df.plugin.PlayerFoodLossEvent + 20, // 15: df.plugin.EventEnvelope.player_heal:type_name -> df.plugin.PlayerHealEvent + 21, // 16: df.plugin.EventEnvelope.player_hurt:type_name -> df.plugin.PlayerHurtEvent + 22, // 17: df.plugin.EventEnvelope.player_death:type_name -> df.plugin.PlayerDeathEvent + 23, // 18: df.plugin.EventEnvelope.player_respawn:type_name -> df.plugin.PlayerRespawnEvent + 24, // 19: df.plugin.EventEnvelope.player_skin_change:type_name -> df.plugin.PlayerSkinChangeEvent + 25, // 20: df.plugin.EventEnvelope.player_fire_extinguish:type_name -> df.plugin.PlayerFireExtinguishEvent + 26, // 21: df.plugin.EventEnvelope.player_start_break:type_name -> df.plugin.PlayerStartBreakEvent + 27, // 22: df.plugin.EventEnvelope.block_break:type_name -> df.plugin.BlockBreakEvent + 28, // 23: df.plugin.EventEnvelope.player_block_place:type_name -> df.plugin.PlayerBlockPlaceEvent + 29, // 24: df.plugin.EventEnvelope.player_block_pick:type_name -> df.plugin.PlayerBlockPickEvent + 30, // 25: df.plugin.EventEnvelope.player_item_use:type_name -> df.plugin.PlayerItemUseEvent + 31, // 26: df.plugin.EventEnvelope.player_item_use_on_block:type_name -> df.plugin.PlayerItemUseOnBlockEvent + 32, // 27: df.plugin.EventEnvelope.player_item_use_on_entity:type_name -> df.plugin.PlayerItemUseOnEntityEvent + 33, // 28: df.plugin.EventEnvelope.player_item_release:type_name -> df.plugin.PlayerItemReleaseEvent + 34, // 29: df.plugin.EventEnvelope.player_item_consume:type_name -> df.plugin.PlayerItemConsumeEvent + 35, // 30: df.plugin.EventEnvelope.player_attack_entity:type_name -> df.plugin.PlayerAttackEntityEvent + 36, // 31: df.plugin.EventEnvelope.player_experience_gain:type_name -> df.plugin.PlayerExperienceGainEvent + 37, // 32: df.plugin.EventEnvelope.player_punch_air:type_name -> df.plugin.PlayerPunchAirEvent + 38, // 33: df.plugin.EventEnvelope.player_sign_edit:type_name -> df.plugin.PlayerSignEditEvent + 39, // 34: df.plugin.EventEnvelope.player_lectern_page_turn:type_name -> df.plugin.PlayerLecternPageTurnEvent + 40, // 35: df.plugin.EventEnvelope.player_item_damage:type_name -> df.plugin.PlayerItemDamageEvent + 41, // 36: df.plugin.EventEnvelope.player_item_pickup:type_name -> df.plugin.PlayerItemPickupEvent + 42, // 37: df.plugin.EventEnvelope.player_held_slot_change:type_name -> df.plugin.PlayerHeldSlotChangeEvent + 43, // 38: df.plugin.EventEnvelope.player_item_drop:type_name -> df.plugin.PlayerItemDropEvent + 44, // 39: df.plugin.EventEnvelope.player_transfer:type_name -> df.plugin.PlayerTransferEvent + 45, // 40: df.plugin.EventEnvelope.command:type_name -> df.plugin.CommandEvent + 46, // 41: df.plugin.EventEnvelope.player_diagnostics:type_name -> df.plugin.PlayerDiagnosticsEvent + 47, // 42: df.plugin.EventEnvelope.world_liquid_flow:type_name -> df.plugin.WorldLiquidFlowEvent + 48, // 43: df.plugin.EventEnvelope.world_liquid_decay:type_name -> df.plugin.WorldLiquidDecayEvent + 49, // 44: df.plugin.EventEnvelope.world_liquid_harden:type_name -> df.plugin.WorldLiquidHardenEvent + 50, // 45: df.plugin.EventEnvelope.world_sound:type_name -> df.plugin.WorldSoundEvent + 51, // 46: df.plugin.EventEnvelope.world_fire_spread:type_name -> df.plugin.WorldFireSpreadEvent + 52, // 47: df.plugin.EventEnvelope.world_block_burn:type_name -> df.plugin.WorldBlockBurnEvent + 53, // 48: df.plugin.EventEnvelope.world_crop_trample:type_name -> df.plugin.WorldCropTrampleEvent + 54, // 49: df.plugin.EventEnvelope.world_leaves_decay:type_name -> df.plugin.WorldLeavesDecayEvent + 55, // 50: df.plugin.EventEnvelope.world_entity_spawn:type_name -> df.plugin.WorldEntitySpawnEvent + 56, // 51: df.plugin.EventEnvelope.world_entity_despawn:type_name -> df.plugin.WorldEntityDespawnEvent + 57, // 52: df.plugin.EventEnvelope.world_explosion:type_name -> df.plugin.WorldExplosionEvent + 58, // 53: df.plugin.EventEnvelope.world_close:type_name -> df.plugin.WorldCloseEvent + 6, // 54: df.plugin.PluginToHost.hello:type_name -> df.plugin.PluginHello + 8, // 55: df.plugin.PluginToHost.subscribe:type_name -> df.plugin.EventSubscribe + 59, // 56: df.plugin.PluginToHost.actions:type_name -> df.plugin.ActionBatch + 7, // 57: df.plugin.PluginToHost.log:type_name -> df.plugin.LogMessage + 60, // 58: df.plugin.PluginToHost.event_result:type_name -> df.plugin.EventResult + 61, // 59: df.plugin.PluginHello.commands:type_name -> df.plugin.CommandSpec + 62, // 60: df.plugin.PluginHello.custom_items:type_name -> df.plugin.CustomItemDefinition + 0, // 61: df.plugin.EventSubscribe.events:type_name -> df.plugin.EventType + 5, // 62: df.plugin.Plugin.EventStream:input_type -> df.plugin.PluginToHost + 1, // 63: df.plugin.Plugin.EventStream:output_type -> df.plugin.HostToPlugin + 63, // [63:64] is the sub-list for method output_type + 62, // [62:63] is the sub-list for method input_type + 62, // [62:62] is the sub-list for extension type_name + 62, // [62:62] is the sub-list for extension extendee + 0, // [0:62] is the sub-list for field type_name } func init() { file_plugin_proto_init() } @@ -1901,6 +1918,7 @@ func file_plugin_proto_init() { (*HostToPlugin_Hello)(nil), (*HostToPlugin_Shutdown)(nil), (*HostToPlugin_Event)(nil), + (*HostToPlugin_ActionResult)(nil), } file_plugin_proto_msgTypes[3].OneofWrappers = []any{ (*EventEnvelope_PlayerJoin)(nil), diff --git a/proto/generated/world_events.pb.go b/proto/generated/world_events.pb.go index 61164c5..446acad 100644 --- a/proto/generated/world_events.pb.go +++ b/proto/generated/world_events.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc (unknown) +// protoc v3.21.12 // source: world_events.proto package generated @@ -809,9 +809,7 @@ const file_world_events_proto_rawDesc = "" + "\n" + "spawn_fire\x18\x06 \x01(\bR\tspawnFire\"<\n" + "\x0fWorldCloseEvent\x12)\n" + - "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05worldB\x8f\x01\n" + - "\rcom.df.pluginB\x10WorldEventsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + - "Df::Pluginb\x06proto3" + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05worldB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" var ( file_world_events_proto_rawDescOnce sync.Once diff --git a/proto/types/actions.proto b/proto/types/actions.proto index f82e899..087fde2 100644 --- a/proto/types/actions.proto +++ b/proto/types/actions.proto @@ -35,6 +35,18 @@ message Action { PlaySoundAction play_sound = 43; // Commands ExecuteCommandAction execute_command = 50; + // World configuration and effects + WorldSetDefaultGameModeAction world_set_default_game_mode = 60; + WorldSetDifficultyAction world_set_difficulty = 61; + WorldSetTickRangeAction world_set_tick_range = 62; + WorldSetBlockAction world_set_block = 63; + WorldPlaySoundAction world_play_sound = 64; + WorldAddParticleAction world_add_particle = 65; + // World queries + WorldQueryEntitiesAction world_query_entities = 70; + WorldQueryPlayersAction world_query_players = 71; + WorldQueryEntitiesWithinAction world_query_entities_within = 72; + WorldQueryViewersAction world_query_viewers = 73; } } @@ -151,3 +163,116 @@ message ExecuteCommandAction { string player_uuid = 1; string command = 2; // without leading slash } + +message WorldSetDefaultGameModeAction { + WorldRef world = 1; + GameMode game_mode = 2; +} + +message WorldSetDifficultyAction { + WorldRef world = 1; + Difficulty difficulty = 2; +} + +message WorldSetTickRangeAction { + WorldRef world = 1; + int32 tick_range = 2; +} + +message WorldSetBlockAction { + WorldRef world = 1; + BlockPos position = 2; + optional BlockState block = 3; // nil clears to air +} + +message WorldPlaySoundAction { + WorldRef world = 1; + Sound sound = 2; + Vec3 position = 3; +} + +message WorldAddParticleAction { + WorldRef world = 1; + Vec3 position = 2; + ParticleType particle = 3; + optional BlockState block = 4; // used for block-based particles when provided + optional int32 face = 5; // used for punch_block when provided +} + +enum ParticleType { + PARTICLE_TYPE_UNSPECIFIED = 0; + PARTICLE_HUGE_EXPLOSION = 1; + PARTICLE_ENDERMAN_TELEPORT = 2; + PARTICLE_SNOWBALL_POOF = 3; + PARTICLE_EGG_SMASH = 4; + PARTICLE_SPLASH = 5; + PARTICLE_EFFECT = 6; + PARTICLE_ENTITY_FLAME = 7; + PARTICLE_FLAME = 8; + PARTICLE_DUST = 9; + PARTICLE_BLOCK_FORCE_FIELD = 10; + PARTICLE_BONE_MEAL = 11; + PARTICLE_EVAPORATE = 12; + PARTICLE_WATER_DRIP = 13; + PARTICLE_LAVA_DRIP = 14; + PARTICLE_LAVA = 15; + PARTICLE_DUST_PLUME = 16; + PARTICLE_BLOCK_BREAK = 17; + PARTICLE_PUNCH_BLOCK = 18; +} + +message WorldQueryEntitiesAction { + WorldRef world = 1; +} + +message WorldQueryPlayersAction { + WorldRef world = 1; +} + +message WorldQueryEntitiesWithinAction { + WorldRef world = 1; + BBox box = 2; +} + +message WorldQueryViewersAction { + WorldRef world = 1; + Vec3 position = 2; +} + +message ActionStatus { + bool ok = 1; + optional string error = 2; +} + +message WorldEntitiesResult { + WorldRef world = 1; + repeated EntityRef entities = 2; +} + +message WorldEntitiesWithinResult { + WorldRef world = 1; + BBox box = 2; + repeated EntityRef entities = 3; +} + +message WorldPlayersResult { + WorldRef world = 1; + repeated EntityRef players = 2; +} + +message WorldViewersResult { + WorldRef world = 1; + Vec3 position = 2; + repeated string viewer_uuids = 3; +} + +message ActionResult { + string correlation_id = 1; + optional ActionStatus status = 2; + oneof result { + WorldEntitiesResult world_entities = 10; + WorldPlayersResult world_players = 11; + WorldEntitiesWithinResult world_entities_within = 12; + WorldViewersResult world_viewers = 13; + } +} diff --git a/proto/types/common.proto b/proto/types/common.proto index 6e3f814..4f948a2 100644 --- a/proto/types/common.proto +++ b/proto/types/common.proto @@ -9,6 +9,13 @@ enum GameMode { SPECTATOR = 3; } +enum Difficulty { + PEACEFUL = 0; + EASY = 1; + NORMAL = 2; + HARD = 3; +} + // EffectType mirrors Dragonfly's registered effect IDs for straightforward mapping. // Keep numeric values aligned with dragonfly/server/entity/effect/register.go. enum EffectType { @@ -82,6 +89,11 @@ message Rotation { float pitch = 2; } +message BBox { + Vec3 min = 1; + Vec3 max = 2; +} + message BlockPos { int32 x = 1; int32 y = 2; diff --git a/proto/types/plugin.proto b/proto/types/plugin.proto index 354d793..4187175 100644 --- a/proto/types/plugin.proto +++ b/proto/types/plugin.proto @@ -21,6 +21,7 @@ message HostToPlugin { HostHello hello = 10; HostShutdown shutdown = 11; EventEnvelope event = 20; + ActionResult action_result = 21; } } From fe51878def37f2869dd052b18520c7d9b17df297 Mon Sep 17 00:00:00 2001 From: HashimTheArab Date: Mon, 24 Nov 2025 20:30:25 +0300 Subject: [PATCH 2/3] generate types --- packages/cpp/src/generated/actions.pb.cc | 12872 ++++++++++--- packages/cpp/src/generated/actions.pb.h | 15645 ++++++++++++---- packages/cpp/src/generated/common.pb.cc | 518 +- packages/cpp/src/generated/common.pb.h | 487 +- packages/cpp/src/generated/plugin.pb.cc | 451 +- packages/cpp/src/generated/plugin.pb.h | 1920 +- packages/node/src/generated/actions.js | 1619 +- packages/node/src/generated/actions.ts | 1888 +- packages/node/src/generated/common.js | 111 + packages/node/src/generated/common.ts | 126 + packages/node/src/generated/plugin.js | 28 +- packages/node/src/generated/plugin.ts | 30 +- .../php/src/generated/Df/Plugin/Action.php | 290 + .../src/generated/Df/Plugin/ActionResult.php | 217 + .../src/generated/Df/Plugin/ActionStatus.php | 96 + packages/php/src/generated/Df/Plugin/BBox.php | 106 + .../src/generated/Df/Plugin/Difficulty.php | 59 + .../Df/Plugin/GPBMetadata/Actions.php | 2 +- .../Df/Plugin/GPBMetadata/Common.php | 2 +- .../Df/Plugin/GPBMetadata/Plugin.php | 2 +- .../src/generated/Df/Plugin/HostToPlugin.php | 28 + .../src/generated/Df/Plugin/ParticleType.php | 134 + .../Df/Plugin/WorldAddParticleAction.php | 221 + .../Df/Plugin/WorldEntitiesResult.php | 96 + .../Df/Plugin/WorldEntitiesWithinResult.php | 133 + .../Df/Plugin/WorldPlaySoundAction.php | 133 + .../Df/Plugin/WorldPlayersResult.php | 96 + .../Df/Plugin/WorldQueryEntitiesAction.php | 69 + .../Plugin/WorldQueryEntitiesWithinAction.php | 106 + .../Df/Plugin/WorldQueryPlayersAction.php | 69 + .../Df/Plugin/WorldQueryViewersAction.php | 106 + .../Df/Plugin/WorldSetBlockAction.php | 150 + .../Plugin/WorldSetDefaultGameModeAction.php | 96 + .../Df/Plugin/WorldSetDifficultyAction.php | 96 + .../Df/Plugin/WorldSetTickRangeAction.php | 96 + .../Df/Plugin/WorldViewersResult.php | 133 + packages/python/src/generated/actions_pb2.py | 110 +- packages/python/src/generated/common_pb2.py | 66 +- packages/python/src/generated/plugin_pb2.py | 48 +- packages/rust/src/generated/df.plugin.rs | 303 +- proto/generated/go/actions.pb.go | 6 +- proto/generated/go/command.pb.go | 6 +- proto/generated/go/common.pb.go | 6 +- proto/generated/go/mutations.pb.go | 6 +- proto/generated/go/player_events.pb.go | 6 +- proto/generated/go/plugin.pb.go | 401 +- proto/generated/go/world_events.pb.go | 6 +- 47 files changed, 30737 insertions(+), 8458 deletions(-) create mode 100644 packages/php/src/generated/Df/Plugin/ActionResult.php create mode 100644 packages/php/src/generated/Df/Plugin/ActionStatus.php create mode 100644 packages/php/src/generated/Df/Plugin/BBox.php create mode 100644 packages/php/src/generated/Df/Plugin/Difficulty.php create mode 100644 packages/php/src/generated/Df/Plugin/ParticleType.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldAddParticleAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldEntitiesResult.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldEntitiesWithinResult.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldPlaySoundAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldPlayersResult.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldQueryEntitiesAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldQueryEntitiesWithinAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldQueryPlayersAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldQueryViewersAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldSetBlockAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldSetDefaultGameModeAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldSetDifficultyAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldSetTickRangeAction.php create mode 100644 packages/php/src/generated/Df/Plugin/WorldViewersResult.php diff --git a/packages/cpp/src/generated/actions.pb.cc b/packages/cpp/src/generated/actions.pb.cc index c244ac6..1670c27 100644 --- a/packages/cpp/src/generated/actions.pb.cc +++ b/packages/cpp/src/generated/actions.pb.cc @@ -414,6 +414,242 @@ struct AddEffectActionDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AddEffectActionDefaultTypeInternal _AddEffectAction_default_instance_; +inline constexpr ActionStatus::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + error_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + ok_{false} {} + +template +PROTOBUF_CONSTEXPR ActionStatus::ActionStatus(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ActionStatus_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ActionStatusDefaultTypeInternal { + PROTOBUF_CONSTEXPR ActionStatusDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ActionStatusDefaultTypeInternal() {} + union { + ActionStatus _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionStatusDefaultTypeInternal _ActionStatus_default_instance_; + +inline constexpr WorldViewersResult::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + viewer_uuids_{}, + world_{nullptr}, + position_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldViewersResult::WorldViewersResult(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldViewersResult_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldViewersResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldViewersResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldViewersResultDefaultTypeInternal() {} + union { + WorldViewersResult _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldViewersResultDefaultTypeInternal _WorldViewersResult_default_instance_; + +inline constexpr WorldSetTickRangeAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + tick_range_{0} {} + +template +PROTOBUF_CONSTEXPR WorldSetTickRangeAction::WorldSetTickRangeAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldSetTickRangeAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldSetTickRangeActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldSetTickRangeActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldSetTickRangeActionDefaultTypeInternal() {} + union { + WorldSetTickRangeAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldSetTickRangeActionDefaultTypeInternal _WorldSetTickRangeAction_default_instance_; + +inline constexpr WorldSetDifficultyAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + difficulty_{static_cast< ::df::plugin::Difficulty >(0)} {} + +template +PROTOBUF_CONSTEXPR WorldSetDifficultyAction::WorldSetDifficultyAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldSetDifficultyAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldSetDifficultyActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldSetDifficultyActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldSetDifficultyActionDefaultTypeInternal() {} + union { + WorldSetDifficultyAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldSetDifficultyActionDefaultTypeInternal _WorldSetDifficultyAction_default_instance_; + +inline constexpr WorldSetDefaultGameModeAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + game_mode_{static_cast< ::df::plugin::GameMode >(0)} {} + +template +PROTOBUF_CONSTEXPR WorldSetDefaultGameModeAction::WorldSetDefaultGameModeAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldSetDefaultGameModeAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldSetDefaultGameModeActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldSetDefaultGameModeActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldSetDefaultGameModeActionDefaultTypeInternal() {} + union { + WorldSetDefaultGameModeAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldSetDefaultGameModeActionDefaultTypeInternal _WorldSetDefaultGameModeAction_default_instance_; + +inline constexpr WorldQueryViewersAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + position_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldQueryViewersAction::WorldQueryViewersAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldQueryViewersAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldQueryViewersActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldQueryViewersActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldQueryViewersActionDefaultTypeInternal() {} + union { + WorldQueryViewersAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldQueryViewersActionDefaultTypeInternal _WorldQueryViewersAction_default_instance_; + +inline constexpr WorldQueryPlayersAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldQueryPlayersAction::WorldQueryPlayersAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldQueryPlayersAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldQueryPlayersActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldQueryPlayersActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldQueryPlayersActionDefaultTypeInternal() {} + union { + WorldQueryPlayersAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldQueryPlayersActionDefaultTypeInternal _WorldQueryPlayersAction_default_instance_; + +inline constexpr WorldQueryEntitiesAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldQueryEntitiesAction::WorldQueryEntitiesAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldQueryEntitiesAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldQueryEntitiesActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldQueryEntitiesActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldQueryEntitiesActionDefaultTypeInternal() {} + union { + WorldQueryEntitiesAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldQueryEntitiesActionDefaultTypeInternal _WorldQueryEntitiesAction_default_instance_; + +inline constexpr WorldPlaySoundAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + position_{nullptr}, + sound_{static_cast< ::df::plugin::Sound >(0)} {} + +template +PROTOBUF_CONSTEXPR WorldPlaySoundAction::WorldPlaySoundAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldPlaySoundAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldPlaySoundActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldPlaySoundActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldPlaySoundActionDefaultTypeInternal() {} + union { + WorldPlaySoundAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldPlaySoundActionDefaultTypeInternal _WorldPlaySoundAction_default_instance_; + inline constexpr TeleportAction::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -559,147 +795,358 @@ struct GiveItemActionDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GiveItemActionDefaultTypeInternal _GiveItemAction_default_instance_; -inline constexpr Action::Impl_::Impl_( +inline constexpr WorldSetBlockAction::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - correlation_id_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - kind_{}, - _oneof_case_{} {} + world_{nullptr}, + position_{nullptr}, + block_{nullptr} {} template -PROTOBUF_CONSTEXPR Action::Action(::_pbi::ConstantInitialized) +PROTOBUF_CONSTEXPR WorldSetBlockAction::WorldSetBlockAction(::_pbi::ConstantInitialized) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(Action_class_data_.base()), + : ::google::protobuf::Message(WorldSetBlockAction_class_data_.base()), #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(), #endif // PROTOBUF_CUSTOM_VTABLE _impl_(::_pbi::ConstantInitialized()) { } -struct ActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR ActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ActionDefaultTypeInternal() {} +struct WorldSetBlockActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldSetBlockActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldSetBlockActionDefaultTypeInternal() {} union { - Action _instance; + WorldSetBlockAction _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionDefaultTypeInternal _Action_default_instance_; + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldSetBlockActionDefaultTypeInternal _WorldSetBlockAction_default_instance_; -inline constexpr ActionBatch::Impl_::Impl_( +inline constexpr WorldQueryEntitiesWithinAction::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - actions_{} {} + world_{nullptr}, + box_{nullptr} {} template -PROTOBUF_CONSTEXPR ActionBatch::ActionBatch(::_pbi::ConstantInitialized) +PROTOBUF_CONSTEXPR WorldQueryEntitiesWithinAction::WorldQueryEntitiesWithinAction(::_pbi::ConstantInitialized) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(ActionBatch_class_data_.base()), + : ::google::protobuf::Message(WorldQueryEntitiesWithinAction_class_data_.base()), #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(), #endif // PROTOBUF_CUSTOM_VTABLE _impl_(::_pbi::ConstantInitialized()) { } -struct ActionBatchDefaultTypeInternal { - PROTOBUF_CONSTEXPR ActionBatchDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ActionBatchDefaultTypeInternal() {} +struct WorldQueryEntitiesWithinActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldQueryEntitiesWithinActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldQueryEntitiesWithinActionDefaultTypeInternal() {} union { - ActionBatch _instance; + WorldQueryEntitiesWithinAction _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionBatchDefaultTypeInternal _ActionBatch_default_instance_; -} // namespace plugin -} // namespace df -static constexpr const ::_pb::EnumDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE - file_level_enum_descriptors_actions_2eproto = nullptr; -static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE - file_level_service_descriptors_actions_2eproto = nullptr; -const ::uint32_t - TableStruct_actions_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( - protodesc_cold) = { - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::ActionBatch, _impl_._has_bits_), - 4, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::ActionBatch, _impl_.actions_), - 0, - 0x085, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._has_bits_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._oneof_case_[0]), - 24, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.correlation_id_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - 0, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - ~0u, - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_._has_bits_), - 5, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_.target_uuid_), - PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_.message_), - 0, - 1, - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_._has_bits_), - 6, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.player_uuid_), - PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.position_), - PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.rotation_), - 0, - 1, - 2, - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_._has_bits_), - 5, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_.player_uuid_), - PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_.reason_), - 0, - 1, - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_._has_bits_), - 5, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_.player_uuid_), - PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_.game_mode_), - 0, - 1, - 0x081, // bitmap + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldQueryEntitiesWithinActionDefaultTypeInternal _WorldQueryEntitiesWithinAction_default_instance_; + +inline constexpr WorldPlayersResult::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + players_{}, + world_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldPlayersResult::WorldPlayersResult(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldPlayersResult_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldPlayersResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldPlayersResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldPlayersResultDefaultTypeInternal() {} + union { + WorldPlayersResult _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldPlayersResultDefaultTypeInternal _WorldPlayersResult_default_instance_; + +inline constexpr WorldEntitiesWithinResult::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + entities_{}, + world_{nullptr}, + box_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldEntitiesWithinResult::WorldEntitiesWithinResult(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldEntitiesWithinResult_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldEntitiesWithinResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldEntitiesWithinResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldEntitiesWithinResultDefaultTypeInternal() {} + union { + WorldEntitiesWithinResult _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldEntitiesWithinResultDefaultTypeInternal _WorldEntitiesWithinResult_default_instance_; + +inline constexpr WorldEntitiesResult::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + entities_{}, + world_{nullptr} {} + +template +PROTOBUF_CONSTEXPR WorldEntitiesResult::WorldEntitiesResult(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldEntitiesResult_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldEntitiesResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldEntitiesResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldEntitiesResultDefaultTypeInternal() {} + union { + WorldEntitiesResult _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldEntitiesResultDefaultTypeInternal _WorldEntitiesResult_default_instance_; + +inline constexpr WorldAddParticleAction::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + world_{nullptr}, + position_{nullptr}, + block_{nullptr}, + particle_{static_cast< ::df::plugin::ParticleType >(0)}, + face_{0} {} + +template +PROTOBUF_CONSTEXPR WorldAddParticleAction::WorldAddParticleAction(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(WorldAddParticleAction_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct WorldAddParticleActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR WorldAddParticleActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~WorldAddParticleActionDefaultTypeInternal() {} + union { + WorldAddParticleAction _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldAddParticleActionDefaultTypeInternal _WorldAddParticleAction_default_instance_; + +inline constexpr ActionResult::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + correlation_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + status_{nullptr}, + result_{}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR ActionResult::ActionResult(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ActionResult_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ActionResultDefaultTypeInternal { + PROTOBUF_CONSTEXPR ActionResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ActionResultDefaultTypeInternal() {} + union { + ActionResult _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionResultDefaultTypeInternal _ActionResult_default_instance_; + +inline constexpr Action::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + correlation_id_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + kind_{}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Action::Action(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(Action_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ActionDefaultTypeInternal { + PROTOBUF_CONSTEXPR ActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ActionDefaultTypeInternal() {} + union { + Action _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionDefaultTypeInternal _Action_default_instance_; + +inline constexpr ActionBatch::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + actions_{} {} + +template +PROTOBUF_CONSTEXPR ActionBatch::ActionBatch(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(ActionBatch_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ActionBatchDefaultTypeInternal { + PROTOBUF_CONSTEXPR ActionBatchDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ActionBatchDefaultTypeInternal() {} + union { + ActionBatch _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionBatchDefaultTypeInternal _ActionBatch_default_instance_; +} // namespace plugin +} // namespace df +static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL + file_level_enum_descriptors_actions_2eproto[1]; +static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE + file_level_service_descriptors_actions_2eproto = nullptr; +const ::uint32_t + TableStruct_actions_2eproto::offsets[] ABSL_ATTRIBUTE_SECTION_VARIABLE( + protodesc_cold) = { + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionBatch, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionBatch, _impl_.actions_), + 0, + 0x085, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._oneof_case_[0]), + 34, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.correlation_id_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), + 0, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + ~0u, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_.target_uuid_), + PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_.message_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.player_uuid_), + PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.position_), + PROTOBUF_FIELD_OFFSET(::df::plugin::TeleportAction, _impl_.rotation_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_.player_uuid_), + PROTOBUF_FIELD_OFFSET(::df::plugin::KickAction, _impl_.reason_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_.player_uuid_), + PROTOBUF_FIELD_OFFSET(::df::plugin::SetGameModeAction, _impl_.game_mode_), + 0, + 1, + 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::GiveItemAction, _impl_._has_bits_), 5, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::GiveItemAction, _impl_.player_uuid_), @@ -823,36 +1270,184 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::df::plugin::ExecuteCommandAction, _impl_.command_), 0, 1, -}; - -static const ::_pbi::MigrationSchema - schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { - {0, sizeof(::df::plugin::ActionBatch)}, - {5, sizeof(::df::plugin::Action)}, - {48, sizeof(::df::plugin::SendChatAction)}, - {55, sizeof(::df::plugin::TeleportAction)}, - {64, sizeof(::df::plugin::KickAction)}, - {71, sizeof(::df::plugin::SetGameModeAction)}, - {78, sizeof(::df::plugin::GiveItemAction)}, - {85, sizeof(::df::plugin::ClearInventoryAction)}, - {90, sizeof(::df::plugin::SetHeldItemAction)}, - {99, sizeof(::df::plugin::SetHealthAction)}, - {108, sizeof(::df::plugin::SetFoodAction)}, - {115, sizeof(::df::plugin::SetExperienceAction)}, - {126, sizeof(::df::plugin::SetVelocityAction)}, - {133, sizeof(::df::plugin::AddEffectAction)}, - {146, sizeof(::df::plugin::RemoveEffectAction)}, - {153, sizeof(::df::plugin::SendTitleAction)}, - {168, sizeof(::df::plugin::SendPopupAction)}, - {175, sizeof(::df::plugin::SendTipAction)}, - {182, sizeof(::df::plugin::PlaySoundAction)}, - {195, sizeof(::df::plugin::ExecuteCommandAction)}, -}; -static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { - &::df::plugin::_ActionBatch_default_instance_._instance, - &::df::plugin::_Action_default_instance_._instance, - &::df::plugin::_SendChatAction_default_instance_._instance, - &::df::plugin::_TeleportAction_default_instance_._instance, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDefaultGameModeAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDefaultGameModeAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDefaultGameModeAction, _impl_.game_mode_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDifficultyAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDifficultyAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetDifficultyAction, _impl_.difficulty_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetTickRangeAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetTickRangeAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetTickRangeAction, _impl_.tick_range_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetBlockAction, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetBlockAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetBlockAction, _impl_.position_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldSetBlockAction, _impl_.block_), + 0, + 1, + 2, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlaySoundAction, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlaySoundAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlaySoundAction, _impl_.sound_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlaySoundAction, _impl_.position_), + 0, + 2, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_._has_bits_), + 8, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_.position_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_.particle_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_.block_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldAddParticleAction, _impl_.face_), + 0, + 1, + 3, + 2, + 4, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryEntitiesAction, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryEntitiesAction, _impl_.world_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryPlayersAction, _impl_._has_bits_), + 4, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryPlayersAction, _impl_.world_), + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryEntitiesWithinAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryEntitiesWithinAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryEntitiesWithinAction, _impl_.box_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_.position_), + 0, + 1, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionStatus, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionStatus, _impl_.ok_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionStatus, _impl_.error_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesResult, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesResult, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesResult, _impl_.entities_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesWithinResult, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesWithinResult, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesWithinResult, _impl_.box_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldEntitiesWithinResult, _impl_.entities_), + 1, + 2, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlayersResult, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlayersResult, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlayersResult, _impl_.players_), + 1, + 0, + 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_._has_bits_), + 6, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.world_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.position_), + PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.viewer_uuids_), + 1, + 2, + 0, + 0x085, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_._oneof_case_[0]), + 11, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.correlation_id_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.status_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), + 0, + 1, + ~0u, + ~0u, + ~0u, + ~0u, +}; + +static const ::_pbi::MigrationSchema + schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { + {0, sizeof(::df::plugin::ActionBatch)}, + {5, sizeof(::df::plugin::Action)}, + {68, sizeof(::df::plugin::SendChatAction)}, + {75, sizeof(::df::plugin::TeleportAction)}, + {84, sizeof(::df::plugin::KickAction)}, + {91, sizeof(::df::plugin::SetGameModeAction)}, + {98, sizeof(::df::plugin::GiveItemAction)}, + {105, sizeof(::df::plugin::ClearInventoryAction)}, + {110, sizeof(::df::plugin::SetHeldItemAction)}, + {119, sizeof(::df::plugin::SetHealthAction)}, + {128, sizeof(::df::plugin::SetFoodAction)}, + {135, sizeof(::df::plugin::SetExperienceAction)}, + {146, sizeof(::df::plugin::SetVelocityAction)}, + {153, sizeof(::df::plugin::AddEffectAction)}, + {166, sizeof(::df::plugin::RemoveEffectAction)}, + {173, sizeof(::df::plugin::SendTitleAction)}, + {188, sizeof(::df::plugin::SendPopupAction)}, + {195, sizeof(::df::plugin::SendTipAction)}, + {202, sizeof(::df::plugin::PlaySoundAction)}, + {215, sizeof(::df::plugin::ExecuteCommandAction)}, + {222, sizeof(::df::plugin::WorldSetDefaultGameModeAction)}, + {229, sizeof(::df::plugin::WorldSetDifficultyAction)}, + {236, sizeof(::df::plugin::WorldSetTickRangeAction)}, + {243, sizeof(::df::plugin::WorldSetBlockAction)}, + {252, sizeof(::df::plugin::WorldPlaySoundAction)}, + {261, sizeof(::df::plugin::WorldAddParticleAction)}, + {274, sizeof(::df::plugin::WorldQueryEntitiesAction)}, + {279, sizeof(::df::plugin::WorldQueryPlayersAction)}, + {284, sizeof(::df::plugin::WorldQueryEntitiesWithinAction)}, + {291, sizeof(::df::plugin::WorldQueryViewersAction)}, + {298, sizeof(::df::plugin::ActionStatus)}, + {305, sizeof(::df::plugin::WorldEntitiesResult)}, + {312, sizeof(::df::plugin::WorldEntitiesWithinResult)}, + {321, sizeof(::df::plugin::WorldPlayersResult)}, + {328, sizeof(::df::plugin::WorldViewersResult)}, + {337, sizeof(::df::plugin::ActionResult)}, +}; +static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { + &::df::plugin::_ActionBatch_default_instance_._instance, + &::df::plugin::_Action_default_instance_._instance, + &::df::plugin::_SendChatAction_default_instance_._instance, + &::df::plugin::_TeleportAction_default_instance_._instance, &::df::plugin::_KickAction_default_instance_._instance, &::df::plugin::_SetGameModeAction_default_instance_._instance, &::df::plugin::_GiveItemAction_default_instance_._instance, @@ -869,12 +1464,28 @@ static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::df::plugin::_SendTipAction_default_instance_._instance, &::df::plugin::_PlaySoundAction_default_instance_._instance, &::df::plugin::_ExecuteCommandAction_default_instance_._instance, + &::df::plugin::_WorldSetDefaultGameModeAction_default_instance_._instance, + &::df::plugin::_WorldSetDifficultyAction_default_instance_._instance, + &::df::plugin::_WorldSetTickRangeAction_default_instance_._instance, + &::df::plugin::_WorldSetBlockAction_default_instance_._instance, + &::df::plugin::_WorldPlaySoundAction_default_instance_._instance, + &::df::plugin::_WorldAddParticleAction_default_instance_._instance, + &::df::plugin::_WorldQueryEntitiesAction_default_instance_._instance, + &::df::plugin::_WorldQueryPlayersAction_default_instance_._instance, + &::df::plugin::_WorldQueryEntitiesWithinAction_default_instance_._instance, + &::df::plugin::_WorldQueryViewersAction_default_instance_._instance, + &::df::plugin::_ActionStatus_default_instance_._instance, + &::df::plugin::_WorldEntitiesResult_default_instance_._instance, + &::df::plugin::_WorldEntitiesWithinResult_default_instance_._instance, + &::df::plugin::_WorldPlayersResult_default_instance_._instance, + &::df::plugin::_WorldViewersResult_default_instance_._instance, + &::df::plugin::_ActionResult_default_instance_._instance, }; const char descriptor_table_protodef_actions_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\ractions.proto\022\tdf.plugin\032\014common.proto" "\":\n\013ActionBatch\022+\n\007actions\030\001 \003(\0132\021.df.pl" - "ugin.ActionR\007actions\"\272\t\n\006Action\022*\n\016corre" + "ugin.ActionR\007actions\"\257\020\n\006Action\022*\n\016corre" "lation_id\030\001 \001(\tH\001R\rcorrelationId\210\001\001\0228\n\ts" "end_chat\030\n \001(\0132\031.df.plugin.SendChatActio" "nH\000R\010sendChat\0227\n\010teleport\030\013 \001(\0132\031.df.plu" @@ -904,68 +1515,161 @@ const char descriptor_table_protodef_actions_2eproto[] ABSL_ATTRIBUTE_SECTION_VA "und\030+ \001(\0132\032.df.plugin.PlaySoundActionH\000R" "\tplaySound\022J\n\017execute_command\0302 \001(\0132\037.df" ".plugin.ExecuteCommandActionH\000R\016executeC" - "ommandB\006\n\004kindB\021\n\017_correlation_id\"K\n\016Sen" - "dChatAction\022\037\n\013target_uuid\030\001 \001(\tR\ntarget" - "Uuid\022\030\n\007message\030\002 \001(\tR\007message\"\213\001\n\016Telep" - "ortAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUu" - "id\022+\n\010position\030\002 \001(\0132\017.df.plugin.Vec3R\010p" - "osition\022+\n\010rotation\030\003 \001(\0132\017.df.plugin.Ve" - "c3R\010rotation\"E\n\nKickAction\022\037\n\013player_uui" - "d\030\001 \001(\tR\nplayerUuid\022\026\n\006reason\030\002 \001(\tR\006rea" - "son\"f\n\021SetGameModeAction\022\037\n\013player_uuid\030" - "\001 \001(\tR\nplayerUuid\0220\n\tgame_mode\030\002 \001(\0162\023.d" - "f.plugin.GameModeR\010gameMode\"[\n\016GiveItemA" - "ction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022(" - "\n\004item\030\002 \001(\0132\024.df.plugin.ItemStackR\004item" - "\"7\n\024ClearInventoryAction\022\037\n\013player_uuid\030" - "\001 \001(\tR\nplayerUuid\"\255\001\n\021SetHeldItemAction\022" - "\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022-\n\004main" - "\030\002 \001(\0132\024.df.plugin.ItemStackH\000R\004main\210\001\001\022" - "3\n\007offhand\030\003 \001(\0132\024.df.plugin.ItemStackH\001" - "R\007offhand\210\001\001B\007\n\005_mainB\n\n\010_offhand\"}\n\017Set" - "HealthAction\022\037\n\013player_uuid\030\001 \001(\tR\nplaye" - "rUuid\022\026\n\006health\030\002 \001(\001R\006health\022\"\n\nmax_hea" - "lth\030\003 \001(\001H\000R\tmaxHealth\210\001\001B\r\n\013_max_health" - "\"D\n\rSetFoodAction\022\037\n\013player_uuid\030\001 \001(\tR\n" - "playerUuid\022\022\n\004food\030\002 \001(\005R\004food\"\261\001\n\023SetEx" - "perienceAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" - "yerUuid\022\031\n\005level\030\002 \001(\005H\000R\005level\210\001\001\022\037\n\010pr" - "ogress\030\003 \001(\002H\001R\010progress\210\001\001\022\033\n\006amount\030\004 " - "\001(\005H\002R\006amount\210\001\001B\010\n\006_levelB\013\n\t_progressB" - "\t\n\007_amount\"a\n\021SetVelocityAction\022\037\n\013playe" - "r_uuid\030\001 \001(\tR\nplayerUuid\022+\n\010velocity\030\002 \001" - "(\0132\017.df.plugin.Vec3R\010velocity\"\310\001\n\017AddEff" - "ectAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUu" - "id\0226\n\013effect_type\030\002 \001(\0162\025.df.plugin.Effe" - "ctTypeR\neffectType\022\024\n\005level\030\003 \001(\005R\005level" - "\022\037\n\013duration_ms\030\004 \001(\003R\ndurationMs\022%\n\016sho" - "w_particles\030\005 \001(\010R\rshowParticles\"m\n\022Remo" - "veEffectAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" + "ommand\022h\n\033world_set_default_game_mode\030< " + "\001(\0132(.df.plugin.WorldSetDefaultGameModeA" + "ctionH\000R\027worldSetDefaultGameMode\022W\n\024worl" + "d_set_difficulty\030= \001(\0132#.df.plugin.World" + "SetDifficultyActionH\000R\022worldSetDifficult" + "y\022U\n\024world_set_tick_range\030> \001(\0132\".df.plu" + "gin.WorldSetTickRangeActionH\000R\021worldSetT" + "ickRange\022H\n\017world_set_block\030\? \001(\0132\036.df.p" + "lugin.WorldSetBlockActionH\000R\rworldSetBlo" + "ck\022K\n\020world_play_sound\030@ \001(\0132\037.df.plugin" + ".WorldPlaySoundActionH\000R\016worldPlaySound\022" + "Q\n\022world_add_particle\030A \001(\0132!.df.plugin." + "WorldAddParticleActionH\000R\020worldAddPartic" + "le\022W\n\024world_query_entities\030F \001(\0132#.df.pl" + "ugin.WorldQueryEntitiesActionH\000R\022worldQu" + "eryEntities\022T\n\023world_query_players\030G \001(\013" + "2\".df.plugin.WorldQueryPlayersActionH\000R\021" + "worldQueryPlayers\022j\n\033world_query_entitie" + "s_within\030H \001(\0132).df.plugin.WorldQueryEnt" + "itiesWithinActionH\000R\030worldQueryEntitiesW" + "ithin\022T\n\023world_query_viewers\030I \001(\0132\".df." + "plugin.WorldQueryViewersActionH\000R\021worldQ" + "ueryViewersB\006\n\004kindB\021\n\017_correlation_id\"K" + "\n\016SendChatAction\022\037\n\013target_uuid\030\001 \001(\tR\nt" + "argetUuid\022\030\n\007message\030\002 \001(\tR\007message\"\213\001\n\016" + "TeleportAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" + "yerUuid\022+\n\010position\030\002 \001(\0132\017.df.plugin.Ve" + "c3R\010position\022+\n\010rotation\030\003 \001(\0132\017.df.plug" + "in.Vec3R\010rotation\"E\n\nKickAction\022\037\n\013playe" + "r_uuid\030\001 \001(\tR\nplayerUuid\022\026\n\006reason\030\002 \001(\t" + "R\006reason\"f\n\021SetGameModeAction\022\037\n\013player_" + "uuid\030\001 \001(\tR\nplayerUuid\0220\n\tgame_mode\030\002 \001(" + "\0162\023.df.plugin.GameModeR\010gameMode\"[\n\016Give" + "ItemAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerU" + "uid\022(\n\004item\030\002 \001(\0132\024.df.plugin.ItemStackR" + "\004item\"7\n\024ClearInventoryAction\022\037\n\013player_" + "uuid\030\001 \001(\tR\nplayerUuid\"\255\001\n\021SetHeldItemAc" + "tion\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022-\n" + "\004main\030\002 \001(\0132\024.df.plugin.ItemStackH\000R\004mai" + "n\210\001\001\0223\n\007offhand\030\003 \001(\0132\024.df.plugin.ItemSt" + "ackH\001R\007offhand\210\001\001B\007\n\005_mainB\n\n\010_offhand\"}" + "\n\017SetHealthAction\022\037\n\013player_uuid\030\001 \001(\tR\n" + "playerUuid\022\026\n\006health\030\002 \001(\001R\006health\022\"\n\nma" + "x_health\030\003 \001(\001H\000R\tmaxHealth\210\001\001B\r\n\013_max_h" + "ealth\"D\n\rSetFoodAction\022\037\n\013player_uuid\030\001 " + "\001(\tR\nplayerUuid\022\022\n\004food\030\002 \001(\005R\004food\"\261\001\n\023" + "SetExperienceAction\022\037\n\013player_uuid\030\001 \001(\t" + "R\nplayerUuid\022\031\n\005level\030\002 \001(\005H\000R\005level\210\001\001\022" + "\037\n\010progress\030\003 \001(\002H\001R\010progress\210\001\001\022\033\n\006amou" + "nt\030\004 \001(\005H\002R\006amount\210\001\001B\010\n\006_levelB\013\n\t_prog" + "ressB\t\n\007_amount\"a\n\021SetVelocityAction\022\037\n\013" + "player_uuid\030\001 \001(\tR\nplayerUuid\022+\n\010velocit" + "y\030\002 \001(\0132\017.df.plugin.Vec3R\010velocity\"\310\001\n\017A" + "ddEffectAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" "yerUuid\0226\n\013effect_type\030\002 \001(\0162\025.df.plugin" - ".EffectTypeR\neffectType\"\223\002\n\017SendTitleAct" - "ion\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\024\n\005" - "title\030\002 \001(\tR\005title\022\037\n\010subtitle\030\003 \001(\tH\000R\010" - "subtitle\210\001\001\022!\n\nfade_in_ms\030\004 \001(\003H\001R\010fadeI" - "nMs\210\001\001\022$\n\013duration_ms\030\005 \001(\003H\002R\ndurationM" - "s\210\001\001\022#\n\013fade_out_ms\030\006 \001(\003H\003R\tfadeOutMs\210\001" - "\001B\013\n\t_subtitleB\r\n\013_fade_in_msB\016\n\014_durati" - "on_msB\016\n\014_fade_out_ms\"L\n\017SendPopupAction" - "\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007mes" - "sage\030\002 \001(\tR\007message\"J\n\rSendTipAction\022\037\n\013" - "player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007message" - "\030\002 \001(\tR\007message\"\346\001\n\017PlaySoundAction\022\037\n\013p" - "layer_uuid\030\001 \001(\tR\nplayerUuid\022&\n\005sound\030\002 " - "\001(\0162\020.df.plugin.SoundR\005sound\0220\n\010position" - "\030\003 \001(\0132\017.df.plugin.Vec3H\000R\010position\210\001\001\022\033" - "\n\006volume\030\004 \001(\002H\001R\006volume\210\001\001\022\031\n\005pitch\030\005 \001" - "(\002H\002R\005pitch\210\001\001B\013\n\t_positionB\t\n\007_volumeB\010" - "\n\006_pitch\"Q\n\024ExecuteCommandAction\022\037\n\013play" - "er_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007command\030\002 \001" - "(\tR\007commandB\213\001\n\rcom.df.pluginB\014ActionsPr" - "otoP\001Z\'github.com/secmc/plugin/proto/gen" - "erated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025D" - "f\\Plugin\\GPBMetadata\352\002\nDf::Pluginb\006proto" - "3" + ".EffectTypeR\neffectType\022\024\n\005level\030\003 \001(\005R\005" + "level\022\037\n\013duration_ms\030\004 \001(\003R\ndurationMs\022%" + "\n\016show_particles\030\005 \001(\010R\rshowParticles\"m\n" + "\022RemoveEffectAction\022\037\n\013player_uuid\030\001 \001(\t" + "R\nplayerUuid\0226\n\013effect_type\030\002 \001(\0162\025.df.p" + "lugin.EffectTypeR\neffectType\"\223\002\n\017SendTit" + "leAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUui" + "d\022\024\n\005title\030\002 \001(\tR\005title\022\037\n\010subtitle\030\003 \001(" + "\tH\000R\010subtitle\210\001\001\022!\n\nfade_in_ms\030\004 \001(\003H\001R\010" + "fadeInMs\210\001\001\022$\n\013duration_ms\030\005 \001(\003H\002R\ndura" + "tionMs\210\001\001\022#\n\013fade_out_ms\030\006 \001(\003H\003R\tfadeOu" + "tMs\210\001\001B\013\n\t_subtitleB\r\n\013_fade_in_msB\016\n\014_d" + "uration_msB\016\n\014_fade_out_ms\"L\n\017SendPopupA" + "ction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030" + "\n\007message\030\002 \001(\tR\007message\"J\n\rSendTipActio" + "n\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007me" + "ssage\030\002 \001(\tR\007message\"\346\001\n\017PlaySoundAction" + "\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022&\n\005sou" + "nd\030\002 \001(\0162\020.df.plugin.SoundR\005sound\0220\n\010pos" + "ition\030\003 \001(\0132\017.df.plugin.Vec3H\000R\010position" + "\210\001\001\022\033\n\006volume\030\004 \001(\002H\001R\006volume\210\001\001\022\031\n\005pitc" + "h\030\005 \001(\002H\002R\005pitch\210\001\001B\013\n\t_positionB\t\n\007_vol" + "umeB\010\n\006_pitch\"Q\n\024ExecuteCommandAction\022\037\n" + "\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007comman" + "d\030\002 \001(\tR\007command\"|\n\035WorldSetDefaultGameM" + "odeAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wor" + "ldRefR\005world\0220\n\tgame_mode\030\002 \001(\0162\023.df.plu" + "gin.GameModeR\010gameMode\"|\n\030WorldSetDiffic" + "ultyAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wo" + "rldRefR\005world\0225\n\ndifficulty\030\002 \001(\0162\025.df.p" + "lugin.DifficultyR\ndifficulty\"c\n\027WorldSet" + "TickRangeAction\022)\n\005world\030\001 \001(\0132\023.df.plug" + "in.WorldRefR\005world\022\035\n\ntick_range\030\002 \001(\005R\t" + "tickRange\"\255\001\n\023WorldSetBlockAction\022)\n\005wor" + "ld\030\001 \001(\0132\023.df.plugin.WorldRefR\005world\022/\n\010" + "position\030\002 \001(\0132\023.df.plugin.BlockPosR\010pos" + "ition\0220\n\005block\030\003 \001(\0132\025.df.plugin.BlockSt" + "ateH\000R\005block\210\001\001B\010\n\006_block\"\226\001\n\024WorldPlayS" + "oundAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wo" + "rldRefR\005world\022&\n\005sound\030\002 \001(\0162\020.df.plugin" + ".SoundR\005sound\022+\n\010position\030\003 \001(\0132\017.df.plu" + "gin.Vec3R\010position\"\203\002\n\026WorldAddParticleA" + "ction\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRe" + "fR\005world\022+\n\010position\030\002 \001(\0132\017.df.plugin.V" + "ec3R\010position\0223\n\010particle\030\003 \001(\0162\027.df.plu" + "gin.ParticleTypeR\010particle\0220\n\005block\030\004 \001(" + "\0132\025.df.plugin.BlockStateH\000R\005block\210\001\001\022\027\n\004" + "face\030\005 \001(\005H\001R\004face\210\001\001B\010\n\006_blockB\007\n\005_face" + "\"E\n\030WorldQueryEntitiesAction\022)\n\005world\030\001 " + "\001(\0132\023.df.plugin.WorldRefR\005world\"D\n\027World" + "QueryPlayersAction\022)\n\005world\030\001 \001(\0132\023.df.p" + "lugin.WorldRefR\005world\"n\n\036WorldQueryEntit" + "iesWithinAction\022)\n\005world\030\001 \001(\0132\023.df.plug" + "in.WorldRefR\005world\022!\n\003box\030\002 \001(\0132\017.df.plu" + "gin.BBoxR\003box\"q\n\027WorldQueryViewersAction" + "\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRefR\005wo" + "rld\022+\n\010position\030\002 \001(\0132\017.df.plugin.Vec3R\010" + "position\"C\n\014ActionStatus\022\016\n\002ok\030\001 \001(\010R\002ok" + "\022\031\n\005error\030\002 \001(\tH\000R\005error\210\001\001B\010\n\006_error\"r\n" + "\023WorldEntitiesResult\022)\n\005world\030\001 \001(\0132\023.df" + ".plugin.WorldRefR\005world\0220\n\010entities\030\002 \003(" + "\0132\024.df.plugin.EntityRefR\010entities\"\233\001\n\031Wo" + "rldEntitiesWithinResult\022)\n\005world\030\001 \001(\0132\023" + ".df.plugin.WorldRefR\005world\022!\n\003box\030\002 \001(\0132" + "\017.df.plugin.BBoxR\003box\0220\n\010entities\030\003 \003(\0132" + "\024.df.plugin.EntityRefR\010entities\"o\n\022World" + "PlayersResult\022)\n\005world\030\001 \001(\0132\023.df.plugin" + ".WorldRefR\005world\022.\n\007players\030\002 \003(\0132\024.df.p" + "lugin.EntityRefR\007players\"\217\001\n\022WorldViewer" + "sResult\022)\n\005world\030\001 \001(\0132\023.df.plugin.World" + "RefR\005world\022+\n\010position\030\002 \001(\0132\017.df.plugin" + ".Vec3R\010position\022!\n\014viewer_uuids\030\003 \003(\tR\013v" + "iewerUuids\"\261\003\n\014ActionResult\022%\n\016correlati" + "on_id\030\001 \001(\tR\rcorrelationId\0224\n\006status\030\002 \001" + "(\0132\027.df.plugin.ActionStatusH\001R\006status\210\001\001" + "\022G\n\016world_entities\030\n \001(\0132\036.df.plugin.Wor" + "ldEntitiesResultH\000R\rworldEntities\022D\n\rwor" + "ld_players\030\013 \001(\0132\035.df.plugin.WorldPlayer" + "sResultH\000R\014worldPlayers\022Z\n\025world_entitie" + "s_within\030\014 \001(\0132$.df.plugin.WorldEntities" + "WithinResultH\000R\023worldEntitiesWithin\022D\n\rw" + "orld_viewers\030\r \001(\0132\035.df.plugin.WorldView" + "ersResultH\000R\014worldViewersB\010\n\006resultB\t\n\007_" + "status*\353\003\n\014ParticleType\022\035\n\031PARTICLE_TYPE" + "_UNSPECIFIED\020\000\022\033\n\027PARTICLE_HUGE_EXPLOSIO" + "N\020\001\022\036\n\032PARTICLE_ENDERMAN_TELEPORT\020\002\022\032\n\026P" + "ARTICLE_SNOWBALL_POOF\020\003\022\026\n\022PARTICLE_EGG_" + "SMASH\020\004\022\023\n\017PARTICLE_SPLASH\020\005\022\023\n\017PARTICLE" + "_EFFECT\020\006\022\031\n\025PARTICLE_ENTITY_FLAME\020\007\022\022\n\016" + "PARTICLE_FLAME\020\010\022\021\n\rPARTICLE_DUST\020\t\022\036\n\032P" + "ARTICLE_BLOCK_FORCE_FIELD\020\n\022\026\n\022PARTICLE_" + "BONE_MEAL\020\013\022\026\n\022PARTICLE_EVAPORATE\020\014\022\027\n\023P" + "ARTICLE_WATER_DRIP\020\r\022\026\n\022PARTICLE_LAVA_DR" + "IP\020\016\022\021\n\rPARTICLE_LAVA\020\017\022\027\n\023PARTICLE_DUST" + "_PLUME\020\020\022\030\n\024PARTICLE_BLOCK_BREAK\020\021\022\030\n\024PA" + "RTICLE_PUNCH_BLOCK\020\022B\213\001\n\rcom.df.pluginB\014" + "ActionsProtoP\001Z\'github.com/secmc/plugin/" + "proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\P" + "lugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plug" + "inb\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_actions_2eproto_deps[1] = { @@ -975,13 +1679,13 @@ static ::absl::once_flag descriptor_table_actions_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_actions_2eproto = { false, false, - 3721, + 7450, descriptor_table_protodef_actions_2eproto, "actions.proto", &descriptor_table_actions_2eproto_once, descriptor_table_actions_2eproto_deps, 1, - 20, + 36, schemas, file_default_instances, TableStruct_actions_2eproto::offsets, @@ -990,6 +1694,12 @@ PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_actions_2eprot }; namespace df { namespace plugin { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ParticleType_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_actions_2eproto); + return file_level_enum_descriptors_actions_2eproto[0]; +} +PROTOBUF_CONSTINIT const uint32_t ParticleType_internal_data_[] = { + 1245184u, 0u, }; // =================================================================== class ActionBatch::_Internal { @@ -1520,6 +2230,136 @@ void Action::set_allocated_execute_command(::df::plugin::ExecuteCommandAction* P } // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.execute_command) } +void Action::set_allocated_world_set_default_game_mode(::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE world_set_default_game_mode) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_set_default_game_mode) { + ::google::protobuf::Arena* submessage_arena = world_set_default_game_mode->GetArena(); + if (message_arena != submessage_arena) { + world_set_default_game_mode = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_set_default_game_mode, submessage_arena); + } + set_has_world_set_default_game_mode(); + _impl_.kind_.world_set_default_game_mode_ = world_set_default_game_mode; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_set_default_game_mode) +} +void Action::set_allocated_world_set_difficulty(::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE world_set_difficulty) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_set_difficulty) { + ::google::protobuf::Arena* submessage_arena = world_set_difficulty->GetArena(); + if (message_arena != submessage_arena) { + world_set_difficulty = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_set_difficulty, submessage_arena); + } + set_has_world_set_difficulty(); + _impl_.kind_.world_set_difficulty_ = world_set_difficulty; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_set_difficulty) +} +void Action::set_allocated_world_set_tick_range(::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE world_set_tick_range) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_set_tick_range) { + ::google::protobuf::Arena* submessage_arena = world_set_tick_range->GetArena(); + if (message_arena != submessage_arena) { + world_set_tick_range = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_set_tick_range, submessage_arena); + } + set_has_world_set_tick_range(); + _impl_.kind_.world_set_tick_range_ = world_set_tick_range; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_set_tick_range) +} +void Action::set_allocated_world_set_block(::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE world_set_block) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_set_block) { + ::google::protobuf::Arena* submessage_arena = world_set_block->GetArena(); + if (message_arena != submessage_arena) { + world_set_block = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_set_block, submessage_arena); + } + set_has_world_set_block(); + _impl_.kind_.world_set_block_ = world_set_block; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_set_block) +} +void Action::set_allocated_world_play_sound(::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE world_play_sound) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_play_sound) { + ::google::protobuf::Arena* submessage_arena = world_play_sound->GetArena(); + if (message_arena != submessage_arena) { + world_play_sound = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_play_sound, submessage_arena); + } + set_has_world_play_sound(); + _impl_.kind_.world_play_sound_ = world_play_sound; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_play_sound) +} +void Action::set_allocated_world_add_particle(::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE world_add_particle) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_add_particle) { + ::google::protobuf::Arena* submessage_arena = world_add_particle->GetArena(); + if (message_arena != submessage_arena) { + world_add_particle = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_add_particle, submessage_arena); + } + set_has_world_add_particle(); + _impl_.kind_.world_add_particle_ = world_add_particle; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_add_particle) +} +void Action::set_allocated_world_query_entities(::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE world_query_entities) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_query_entities) { + ::google::protobuf::Arena* submessage_arena = world_query_entities->GetArena(); + if (message_arena != submessage_arena) { + world_query_entities = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_query_entities, submessage_arena); + } + set_has_world_query_entities(); + _impl_.kind_.world_query_entities_ = world_query_entities; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_entities) +} +void Action::set_allocated_world_query_players(::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE world_query_players) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_query_players) { + ::google::protobuf::Arena* submessage_arena = world_query_players->GetArena(); + if (message_arena != submessage_arena) { + world_query_players = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_query_players, submessage_arena); + } + set_has_world_query_players(); + _impl_.kind_.world_query_players_ = world_query_players; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_players) +} +void Action::set_allocated_world_query_entities_within(::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE world_query_entities_within) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_query_entities_within) { + ::google::protobuf::Arena* submessage_arena = world_query_entities_within->GetArena(); + if (message_arena != submessage_arena) { + world_query_entities_within = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_query_entities_within, submessage_arena); + } + set_has_world_query_entities_within(); + _impl_.kind_.world_query_entities_within_ = world_query_entities_within; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_entities_within) +} +void Action::set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE world_query_viewers) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_kind(); + if (world_query_viewers) { + ::google::protobuf::Arena* submessage_arena = world_query_viewers->GetArena(); + if (message_arena != submessage_arena) { + world_query_viewers = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_query_viewers, submessage_arena); + } + set_has_world_query_viewers(); + _impl_.kind_.world_query_viewers_ = world_query_viewers; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_viewers) +} Action::Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) : ::google::protobuf::Message(arena, Action_class_data_.base()) { @@ -1609,6 +2449,36 @@ Action::Action( case kExecuteCommand: _impl_.kind_.execute_command_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.execute_command_); break; + case kWorldSetDefaultGameMode: + _impl_.kind_.world_set_default_game_mode_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_default_game_mode_); + break; + case kWorldSetDifficulty: + _impl_.kind_.world_set_difficulty_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_difficulty_); + break; + case kWorldSetTickRange: + _impl_.kind_.world_set_tick_range_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_tick_range_); + break; + case kWorldSetBlock: + _impl_.kind_.world_set_block_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_block_); + break; + case kWorldPlaySound: + _impl_.kind_.world_play_sound_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_play_sound_); + break; + case kWorldAddParticle: + _impl_.kind_.world_add_particle_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_add_particle_); + break; + case kWorldQueryEntities: + _impl_.kind_.world_query_entities_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_entities_); + break; + case kWorldQueryPlayers: + _impl_.kind_.world_query_players_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_players_); + break; + case kWorldQueryEntitiesWithin: + _impl_.kind_.world_query_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_entities_within_); + break; + case kWorldQueryViewers: + _impl_.kind_.world_query_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_viewers_); + break; } // @@protoc_insertion_point(copy_constructor:df.plugin.Action) @@ -1790,6 +2660,86 @@ void Action::clear_kind() { } break; } + case kWorldSetDefaultGameMode: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_default_game_mode_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_default_game_mode_); + } + break; + } + case kWorldSetDifficulty: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_difficulty_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_difficulty_); + } + break; + } + case kWorldSetTickRange: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_tick_range_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_tick_range_); + } + break; + } + case kWorldSetBlock: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_block_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_block_); + } + break; + } + case kWorldPlaySound: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_play_sound_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_play_sound_); + } + break; + } + case kWorldAddParticle: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_add_particle_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_add_particle_); + } + break; + } + case kWorldQueryEntities: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_entities_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_entities_); + } + break; + } + case kWorldQueryPlayers: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_players_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_players_); + } + break; + } + case kWorldQueryEntitiesWithin: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_entities_within_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_entities_within_); + } + break; + } + case kWorldQueryViewers: { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_viewers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_viewers_); + } + break; + } case KIND_NOT_SET: { break; } @@ -1841,17 +2791,17 @@ Action::GetClassData() const { return Action_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 19, 18, 55, 7> +const ::_pbi::TcParseTable<0, 29, 28, 63, 11> Action::_table_ = { { PROTOBUF_FIELD_OFFSET(Action, _impl_._has_bits_), 0, // no _extensions_ - 50, 0, // max_field_number, fast_idx_mask + 73, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 2676425214, // skipmap offsetof(decltype(_table_), field_entries), - 19, // num_field_entries - 18, // num_aux_entries + 29, // num_field_entries + 28, // num_aux_entries offsetof(decltype(_table_), aux_entries), Action_class_data_.base(), nullptr, // post_loop_handler @@ -1865,8 +2815,10 @@ Action::_table_ = { {10, 0, 0, PROTOBUF_FIELD_OFFSET(Action, _impl_.correlation_id_)}}, }}, {{ - 40, 0, 1, + 40, 0, 3, 64496, 14, + 15375, 19, + 65532, 27, 65535, 65535 }}, {{ // optional string correlation_id = 1 [json_name = "correlationId"]; @@ -1907,6 +2859,26 @@ Action::_table_ = { {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.play_sound_), _Internal::kOneofCaseOffset + 0, 16, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, // .df.plugin.ExecuteCommandAction execute_command = 50 [json_name = "executeCommand"]; {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.execute_command_), _Internal::kOneofCaseOffset + 0, 17, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_set_default_game_mode_), _Internal::kOneofCaseOffset + 0, 18, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_set_difficulty_), _Internal::kOneofCaseOffset + 0, 19, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_set_tick_range_), _Internal::kOneofCaseOffset + 0, 20, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_set_block_), _Internal::kOneofCaseOffset + 0, 21, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_play_sound_), _Internal::kOneofCaseOffset + 0, 22, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_add_particle_), _Internal::kOneofCaseOffset + 0, 23, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_entities_), _Internal::kOneofCaseOffset + 0, 24, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_players_), _Internal::kOneofCaseOffset + 0, 25, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_entities_within_), _Internal::kOneofCaseOffset + 0, 26, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; + {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_viewers_), _Internal::kOneofCaseOffset + 0, 27, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::SendChatAction>()}, @@ -1927,9 +2899,19 @@ Action::_table_ = { {::_pbi::TcParser::GetTable<::df::plugin::SendTipAction>()}, {::_pbi::TcParser::GetTable<::df::plugin::PlaySoundAction>()}, {::_pbi::TcParser::GetTable<::df::plugin::ExecuteCommandAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldSetDefaultGameModeAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldSetDifficultyAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldSetTickRangeAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldSetBlockAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldPlaySoundAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldAddParticleAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryPlayersAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesWithinAction>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryViewersAction>()}, }}, {{ - "\20\16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "\20\16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "df.plugin.Action" "correlation_id" }}, @@ -2086,6 +3068,66 @@ ::uint8_t* PROTOBUF_NONNULL Action::_InternalSerialize( stream); break; } + case kWorldSetDefaultGameMode: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 60, *this_._impl_.kind_.world_set_default_game_mode_, this_._impl_.kind_.world_set_default_game_mode_->GetCachedSize(), target, + stream); + break; + } + case kWorldSetDifficulty: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 61, *this_._impl_.kind_.world_set_difficulty_, this_._impl_.kind_.world_set_difficulty_->GetCachedSize(), target, + stream); + break; + } + case kWorldSetTickRange: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 62, *this_._impl_.kind_.world_set_tick_range_, this_._impl_.kind_.world_set_tick_range_->GetCachedSize(), target, + stream); + break; + } + case kWorldSetBlock: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 63, *this_._impl_.kind_.world_set_block_, this_._impl_.kind_.world_set_block_->GetCachedSize(), target, + stream); + break; + } + case kWorldPlaySound: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 64, *this_._impl_.kind_.world_play_sound_, this_._impl_.kind_.world_play_sound_->GetCachedSize(), target, + stream); + break; + } + case kWorldAddParticle: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 65, *this_._impl_.kind_.world_add_particle_, this_._impl_.kind_.world_add_particle_->GetCachedSize(), target, + stream); + break; + } + case kWorldQueryEntities: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 70, *this_._impl_.kind_.world_query_entities_, this_._impl_.kind_.world_query_entities_->GetCachedSize(), target, + stream); + break; + } + case kWorldQueryPlayers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 71, *this_._impl_.kind_.world_query_players_, this_._impl_.kind_.world_query_players_->GetCachedSize(), target, + stream); + break; + } + case kWorldQueryEntitiesWithin: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 72, *this_._impl_.kind_.world_query_entities_within_, this_._impl_.kind_.world_query_entities_within_->GetCachedSize(), target, + stream); + break; + } + case kWorldQueryViewers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 73, *this_._impl_.kind_.world_query_viewers_, this_._impl_.kind_.world_query_viewers_->GetCachedSize(), target, + stream); + break; + } default: break; } @@ -2229,18 +3271,78 @@ ::size_t Action::ByteSizeLong() const { ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.execute_command_); break; } - case KIND_NOT_SET: { + // .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; + case kWorldSetDefaultGameMode: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_set_default_game_mode_); break; } - } - return this_.MaybeComputeUnknownFieldsSize(total_size, - &this_._impl_._cached_size_); -} - -void Action::MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = - static_cast(&to_msg); + // .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; + case kWorldSetDifficulty: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_set_difficulty_); + break; + } + // .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; + case kWorldSetTickRange: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_set_tick_range_); + break; + } + // .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; + case kWorldSetBlock: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_set_block_); + break; + } + // .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; + case kWorldPlaySound: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_play_sound_); + break; + } + // .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; + case kWorldAddParticle: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_add_particle_); + break; + } + // .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; + case kWorldQueryEntities: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_entities_); + break; + } + // .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; + case kWorldQueryPlayers: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_players_); + break; + } + // .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; + case kWorldQueryEntitiesWithin: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_entities_within_); + break; + } + // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; + case kWorldQueryViewers: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_viewers_); + break; + } + case KIND_NOT_SET: { + break; + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void Action::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); @@ -2412,6 +3514,86 @@ void Action::MergeImpl(::google::protobuf::MessageLite& to_msg, } break; } + case kWorldSetDefaultGameMode: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_set_default_game_mode_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_default_game_mode_); + } else { + _this->_impl_.kind_.world_set_default_game_mode_->MergeFrom(*from._impl_.kind_.world_set_default_game_mode_); + } + break; + } + case kWorldSetDifficulty: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_set_difficulty_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_difficulty_); + } else { + _this->_impl_.kind_.world_set_difficulty_->MergeFrom(*from._impl_.kind_.world_set_difficulty_); + } + break; + } + case kWorldSetTickRange: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_set_tick_range_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_tick_range_); + } else { + _this->_impl_.kind_.world_set_tick_range_->MergeFrom(*from._impl_.kind_.world_set_tick_range_); + } + break; + } + case kWorldSetBlock: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_set_block_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_set_block_); + } else { + _this->_impl_.kind_.world_set_block_->MergeFrom(*from._impl_.kind_.world_set_block_); + } + break; + } + case kWorldPlaySound: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_play_sound_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_play_sound_); + } else { + _this->_impl_.kind_.world_play_sound_->MergeFrom(*from._impl_.kind_.world_play_sound_); + } + break; + } + case kWorldAddParticle: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_add_particle_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_add_particle_); + } else { + _this->_impl_.kind_.world_add_particle_->MergeFrom(*from._impl_.kind_.world_add_particle_); + } + break; + } + case kWorldQueryEntities: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_query_entities_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_entities_); + } else { + _this->_impl_.kind_.world_query_entities_->MergeFrom(*from._impl_.kind_.world_query_entities_); + } + break; + } + case kWorldQueryPlayers: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_query_players_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_players_); + } else { + _this->_impl_.kind_.world_query_players_->MergeFrom(*from._impl_.kind_.world_query_players_); + } + break; + } + case kWorldQueryEntitiesWithin: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_query_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_entities_within_); + } else { + _this->_impl_.kind_.world_query_entities_within_->MergeFrom(*from._impl_.kind_.world_query_entities_within_); + } + break; + } + case kWorldQueryViewers: { + if (oneof_needs_init) { + _this->_impl_.kind_.world_query_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_viewers_); + } else { + _this->_impl_.kind_.world_query_viewers_->MergeFrom(*from._impl_.kind_.world_query_viewers_); + } + break; + } case KIND_NOT_SET: break; } @@ -2486,120 +3668,5611 @@ SendChatAction::SendChatAction( // @@protoc_insertion_point(copy_constructor:df.plugin.SendChatAction) } -PROTOBUF_NDEBUG_INLINE SendChatAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE SendChatAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + target_uuid_(arena), + message_(arena) {} + +inline void SendChatAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +SendChatAction::~SendChatAction() { + // @@protoc_insertion_point(destructor:df.plugin.SendChatAction) + SharedDtor(*this); +} +inline void SendChatAction::SharedDtor(MessageLite& self) { + SendChatAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.target_uuid_.Destroy(); + this_._impl_.message_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SendChatAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SendChatAction(arena); +} +constexpr auto SendChatAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendChatAction), + alignof(SendChatAction)); +} +constexpr auto SendChatAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SendChatAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SendChatAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SendChatAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SendChatAction::ByteSizeLong, + &SendChatAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_._cached_size_), + false, + }, + &SendChatAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SendChatAction_class_data_ = + SendChatAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SendChatAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SendChatAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SendChatAction_class_data_.tc_table); + return SendChatAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 51, 2> +SendChatAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SendChatAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SendChatAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string message = 2 [json_name = "message"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.message_)}}, + // string target_uuid = 1 [json_name = "targetUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.target_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string target_uuid = 1 [json_name = "targetUuid"]; + {PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.target_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string message = 2 [json_name = "message"]; + {PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\30\13\7\0\0\0\0\0" + "df.plugin.SendChatAction" + "target_uuid" + "message" + }}, +}; +PROTOBUF_NOINLINE void SendChatAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SendChatAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.target_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _impl_.message_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SendChatAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SendChatAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SendChatAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SendChatAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendChatAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string target_uuid = 1 [json_name = "targetUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_target_uuid().empty()) { + const ::std::string& _s = this_._internal_target_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendChatAction.target_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + const ::std::string& _s = this_._internal_message(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendChatAction.message"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendChatAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SendChatAction::ByteSizeLong(const MessageLite& base) { + const SendChatAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SendChatAction::ByteSizeLong() const { + const SendChatAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendChatAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string target_uuid = 1 [json_name = "targetUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_target_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_target_uuid()); + } + } + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_message()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SendChatAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendChatAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_target_uuid().empty()) { + _this->_internal_set_target_uuid(from._internal_target_uuid()); + } else { + if (_this->_impl_.target_uuid_.IsDefault()) { + _this->_internal_set_target_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } else { + if (_this->_impl_.message_.IsDefault()) { + _this->_internal_set_message(""); + } + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SendChatAction::CopyFrom(const SendChatAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendChatAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SendChatAction::InternalSwap(SendChatAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.target_uuid_, &other->_impl_.target_uuid_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); +} + +::google::protobuf::Metadata SendChatAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class TeleportAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._has_bits_); +}; + +void TeleportAction::clear_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void TeleportAction::clear_rotation() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.rotation_ != nullptr) _impl_.rotation_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +TeleportAction::TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, TeleportAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.TeleportAction) +} +PROTOBUF_NDEBUG_INLINE TeleportAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::TeleportAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +TeleportAction::TeleportAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const TeleportAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, TeleportAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + TeleportAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) + : nullptr; + _impl_.rotation_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.rotation_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:df.plugin.TeleportAction) +} +PROTOBUF_NDEBUG_INLINE TeleportAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void TeleportAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, position_), + 0, + offsetof(Impl_, rotation_) - + offsetof(Impl_, position_) + + sizeof(Impl_::rotation_)); +} +TeleportAction::~TeleportAction() { + // @@protoc_insertion_point(destructor:df.plugin.TeleportAction) + SharedDtor(*this); +} +inline void TeleportAction::SharedDtor(MessageLite& self) { + TeleportAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.position_; + delete this_._impl_.rotation_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL TeleportAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) TeleportAction(arena); +} +constexpr auto TeleportAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TeleportAction), + alignof(TeleportAction)); +} +constexpr auto TeleportAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_TeleportAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TeleportAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TeleportAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &TeleportAction::ByteSizeLong, + &TeleportAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._cached_size_), + false, + }, + &TeleportAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull TeleportAction_class_data_ = + TeleportAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +TeleportAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&TeleportAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(TeleportAction_class_data_.tc_table); + return TeleportAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 44, 2> +TeleportAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._has_bits_), + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + TeleportAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::TeleportAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.player_uuid_)}}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_)}}, + // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; + {::_pbi::TcParser::FastMtS1, + {26, 2, 1, + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; + {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + }}, + {{ + "\30\13\0\0\0\0\0\0" + "df.plugin.TeleportAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void TeleportAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.TeleportAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.rotation_ != nullptr); + _impl_.rotation_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const TeleportAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const TeleportAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.TeleportAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.TeleportAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); + } + + // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.rotation_, this_._impl_.rotation_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.TeleportAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t TeleportAction::ByteSizeLong(const MessageLite& base) { + const TeleportAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t TeleportAction::ByteSizeLong() const { + const TeleportAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.TeleportAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + } + // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rotation_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void TeleportAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.TeleportAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); + } else { + _this->_impl_.position_->MergeFrom(*from._impl_.position_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(from._impl_.rotation_ != nullptr); + if (_this->_impl_.rotation_ == nullptr) { + _this->_impl_.rotation_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.rotation_); + } else { + _this->_impl_.rotation_->MergeFrom(*from._impl_.rotation_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void TeleportAction::CopyFrom(const TeleportAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.TeleportAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void TeleportAction::InternalSwap(TeleportAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_) + + sizeof(TeleportAction::_impl_.rotation_) + - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_)>( + reinterpret_cast(&_impl_.position_), + reinterpret_cast(&other->_impl_.position_)); +} + +::google::protobuf::Metadata TeleportAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class KickAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(KickAction, _impl_._has_bits_); +}; + +KickAction::KickAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, KickAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.KickAction) +} +PROTOBUF_NDEBUG_INLINE KickAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::KickAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_), + reason_(arena, from.reason_) {} + +KickAction::KickAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const KickAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, KickAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + KickAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:df.plugin.KickAction) +} +PROTOBUF_NDEBUG_INLINE KickAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena), + reason_(arena) {} + +inline void KickAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +KickAction::~KickAction() { + // @@protoc_insertion_point(destructor:df.plugin.KickAction) + SharedDtor(*this); +} +inline void KickAction::SharedDtor(MessageLite& self) { + KickAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.reason_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL KickAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) KickAction(arena); +} +constexpr auto KickAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(KickAction), + alignof(KickAction)); +} +constexpr auto KickAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_KickAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &KickAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &KickAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &KickAction::ByteSizeLong, + &KickAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(KickAction, _impl_._cached_size_), + false, + }, + &KickAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull KickAction_class_data_ = + KickAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +KickAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&KickAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(KickAction_class_data_.tc_table); + return KickAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 46, 2> +KickAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(KickAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + KickAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::KickAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string reason = 2 [json_name = "reason"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(KickAction, _impl_.reason_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(KickAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(KickAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string reason = 2 [json_name = "reason"]; + {PROTOBUF_FIELD_OFFSET(KickAction, _impl_.reason_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\24\13\6\0\0\0\0\0" + "df.plugin.KickAction" + "player_uuid" + "reason" + }}, +}; +PROTOBUF_NOINLINE void KickAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.KickAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _impl_.reason_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL KickAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const KickAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL KickAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const KickAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.KickAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.KickAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // string reason = 2 [json_name = "reason"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_reason().empty()) { + const ::std::string& _s = this_._internal_reason(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.KickAction.reason"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.KickAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t KickAction::ByteSizeLong(const MessageLite& base) { + const KickAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t KickAction::ByteSizeLong() const { + const KickAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.KickAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // string reason = 2 [json_name = "reason"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_reason().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_reason()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void KickAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.KickAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_reason().empty()) { + _this->_internal_set_reason(from._internal_reason()); + } else { + if (_this->_impl_.reason_.IsDefault()) { + _this->_internal_set_reason(""); + } + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void KickAction::CopyFrom(const KickAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.KickAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void KickAction::InternalSwap(KickAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.reason_, &other->_impl_.reason_, arena); +} + +::google::protobuf::Metadata KickAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetGameModeAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._has_bits_); +}; + +SetGameModeAction::SetGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetGameModeAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetGameModeAction) +} +PROTOBUF_NDEBUG_INLINE SetGameModeAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetGameModeAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetGameModeAction::SetGameModeAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetGameModeAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetGameModeAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetGameModeAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.game_mode_ = from._impl_.game_mode_; + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetGameModeAction) +} +PROTOBUF_NDEBUG_INLINE SetGameModeAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetGameModeAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.game_mode_ = {}; +} +SetGameModeAction::~SetGameModeAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetGameModeAction) + SharedDtor(*this); +} +inline void SetGameModeAction::SharedDtor(MessageLite& self) { + SetGameModeAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetGameModeAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetGameModeAction(arena); +} +constexpr auto SetGameModeAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetGameModeAction), + alignof(SetGameModeAction)); +} +constexpr auto SetGameModeAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetGameModeAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetGameModeAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetGameModeAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetGameModeAction::ByteSizeLong, + &SetGameModeAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._cached_size_), + false, + }, + &SetGameModeAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetGameModeAction_class_data_ = + SetGameModeAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetGameModeAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetGameModeAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetGameModeAction_class_data_.tc_table); + return SetGameModeAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 47, 2> +SetGameModeAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SetGameModeAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetGameModeAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetGameModeAction, _impl_.game_mode_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.game_mode_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + {PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.game_mode_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\33\13\0\0\0\0\0\0" + "df.plugin.SetGameModeAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetGameModeAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetGameModeAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + _impl_.game_mode_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetGameModeAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetGameModeAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetGameModeAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetGameModeAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetGameModeAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetGameModeAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_game_mode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_game_mode(), target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetGameModeAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetGameModeAction::ByteSizeLong(const MessageLite& base) { + const SetGameModeAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetGameModeAction::ByteSizeLong() const { + const SetGameModeAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetGameModeAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_game_mode() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_game_mode()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetGameModeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetGameModeAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (from._internal_game_mode() != 0) { + _this->_impl_.game_mode_ = from._impl_.game_mode_; + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetGameModeAction::CopyFrom(const SetGameModeAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetGameModeAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetGameModeAction::InternalSwap(SetGameModeAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + swap(_impl_.game_mode_, other->_impl_.game_mode_); +} + +::google::protobuf::Metadata SetGameModeAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class GiveItemAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._has_bits_); +}; + +void GiveItemAction::clear_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.item_ != nullptr) _impl_.item_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +GiveItemAction::GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GiveItemAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.GiveItemAction) +} +PROTOBUF_NDEBUG_INLINE GiveItemAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::GiveItemAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +GiveItemAction::GiveItemAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const GiveItemAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, GiveItemAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + GiveItemAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.item_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.item_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:df.plugin.GiveItemAction) +} +PROTOBUF_NDEBUG_INLINE GiveItemAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void GiveItemAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.item_ = {}; +} +GiveItemAction::~GiveItemAction() { + // @@protoc_insertion_point(destructor:df.plugin.GiveItemAction) + SharedDtor(*this); +} +inline void GiveItemAction::SharedDtor(MessageLite& self) { + GiveItemAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.item_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL GiveItemAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) GiveItemAction(arena); +} +constexpr auto GiveItemAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GiveItemAction), + alignof(GiveItemAction)); +} +constexpr auto GiveItemAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_GiveItemAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GiveItemAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GiveItemAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &GiveItemAction::ByteSizeLong, + &GiveItemAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._cached_size_), + false, + }, + &GiveItemAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull GiveItemAction_class_data_ = + GiveItemAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +GiveItemAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&GiveItemAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(GiveItemAction_class_data_.tc_table); + return GiveItemAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 44, 2> +GiveItemAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + GiveItemAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::GiveItemAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .df.plugin.ItemStack item = 2 [json_name = "item"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.item_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.ItemStack item = 2 [json_name = "item"]; + {PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.item_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, + }}, + {{ + "\30\13\0\0\0\0\0\0" + "df.plugin.GiveItemAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void GiveItemAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.GiveItemAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.item_ != nullptr); + _impl_.item_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL GiveItemAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const GiveItemAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL GiveItemAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const GiveItemAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.GiveItemAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.GiveItemAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.ItemStack item = 2 [json_name = "item"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.item_, this_._impl_.item_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.GiveItemAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t GiveItemAction::ByteSizeLong(const MessageLite& base) { + const GiveItemAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t GiveItemAction::ByteSizeLong() const { + const GiveItemAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.GiveItemAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.ItemStack item = 2 [json_name = "item"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.item_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void GiveItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.GiveItemAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.item_ != nullptr); + if (_this->_impl_.item_ == nullptr) { + _this->_impl_.item_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.item_); + } else { + _this->_impl_.item_->MergeFrom(*from._impl_.item_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void GiveItemAction::CopyFrom(const GiveItemAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.GiveItemAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GiveItemAction::InternalSwap(GiveItemAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + swap(_impl_.item_, other->_impl_.item_); +} + +::google::protobuf::Metadata GiveItemAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class ClearInventoryAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._has_bits_); +}; + +ClearInventoryAction::ClearInventoryAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClearInventoryAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.ClearInventoryAction) +} +PROTOBUF_NDEBUG_INLINE ClearInventoryAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::ClearInventoryAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +ClearInventoryAction::ClearInventoryAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const ClearInventoryAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, ClearInventoryAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ClearInventoryAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:df.plugin.ClearInventoryAction) +} +PROTOBUF_NDEBUG_INLINE ClearInventoryAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void ClearInventoryAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ClearInventoryAction::~ClearInventoryAction() { + // @@protoc_insertion_point(destructor:df.plugin.ClearInventoryAction) + SharedDtor(*this); +} +inline void ClearInventoryAction::SharedDtor(MessageLite& self) { + ClearInventoryAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL ClearInventoryAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) ClearInventoryAction(arena); +} +constexpr auto ClearInventoryAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClearInventoryAction), + alignof(ClearInventoryAction)); +} +constexpr auto ClearInventoryAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_ClearInventoryAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClearInventoryAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClearInventoryAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ClearInventoryAction::ByteSizeLong, + &ClearInventoryAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._cached_size_), + false, + }, + &ClearInventoryAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull ClearInventoryAction_class_data_ = + ClearInventoryAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +ClearInventoryAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ClearInventoryAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ClearInventoryAction_class_data_.tc_table); + return ClearInventoryAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 50, 2> +ClearInventoryAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._has_bits_), + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ClearInventoryAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::ClearInventoryAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\36\13\0\0\0\0\0\0" + "df.plugin.ClearInventoryAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void ClearInventoryAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.ClearInventoryAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL ClearInventoryAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const ClearInventoryAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL ClearInventoryAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const ClearInventoryAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ClearInventoryAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ClearInventoryAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ClearInventoryAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t ClearInventoryAction::ByteSizeLong(const MessageLite& base) { + const ClearInventoryAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t ClearInventoryAction::ByteSizeLong() const { + const ClearInventoryAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.ClearInventoryAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // string player_uuid = 1 [json_name = "playerUuid"]; + cached_has_bits = this_._impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void ClearInventoryAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ClearInventoryAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void ClearInventoryAction::CopyFrom(const ClearInventoryAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ClearInventoryAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ClearInventoryAction::InternalSwap(ClearInventoryAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); +} + +::google::protobuf::Metadata ClearInventoryAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetHeldItemAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._has_bits_); +}; + +void SetHeldItemAction::clear_main() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.main_ != nullptr) _impl_.main_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void SetHeldItemAction::clear_offhand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.offhand_ != nullptr) _impl_.offhand_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +SetHeldItemAction::SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetHeldItemAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetHeldItemAction) +} +PROTOBUF_NDEBUG_INLINE SetHeldItemAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetHeldItemAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetHeldItemAction::SetHeldItemAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetHeldItemAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetHeldItemAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetHeldItemAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.main_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.main_) + : nullptr; + _impl_.offhand_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.offhand_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetHeldItemAction) +} +PROTOBUF_NDEBUG_INLINE SetHeldItemAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetHeldItemAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, main_), + 0, + offsetof(Impl_, offhand_) - + offsetof(Impl_, main_) + + sizeof(Impl_::offhand_)); +} +SetHeldItemAction::~SetHeldItemAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetHeldItemAction) + SharedDtor(*this); +} +inline void SetHeldItemAction::SharedDtor(MessageLite& self) { + SetHeldItemAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.main_; + delete this_._impl_.offhand_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetHeldItemAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetHeldItemAction(arena); +} +constexpr auto SetHeldItemAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetHeldItemAction), + alignof(SetHeldItemAction)); +} +constexpr auto SetHeldItemAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetHeldItemAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetHeldItemAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetHeldItemAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetHeldItemAction::ByteSizeLong, + &SetHeldItemAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._cached_size_), + false, + }, + &SetHeldItemAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetHeldItemAction_class_data_ = + SetHeldItemAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetHeldItemAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetHeldItemAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetHeldItemAction_class_data_.tc_table); + return SetHeldItemAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 2, 47, 2> +SetHeldItemAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._has_bits_), + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + SetHeldItemAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetHeldItemAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.player_uuid_)}}, + // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_)}}, + // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + {::_pbi::TcParser::FastMtS1, + {26, 2, 1, + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, + {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, + }}, + {{ + "\33\13\0\0\0\0\0\0" + "df.plugin.SetHeldItemAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetHeldItemAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetHeldItemAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.main_ != nullptr); + _impl_.main_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.offhand_ != nullptr); + _impl_.offhand_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetHeldItemAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetHeldItemAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetHeldItemAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetHeldItemAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetHeldItemAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetHeldItemAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.main_, this_._impl_.main_->GetCachedSize(), target, + stream); + } + + // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.offhand_, this_._impl_.offhand_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetHeldItemAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetHeldItemAction::ByteSizeLong(const MessageLite& base) { + const SetHeldItemAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetHeldItemAction::ByteSizeLong() const { + const SetHeldItemAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetHeldItemAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.main_); + } + // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.offhand_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetHeldItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetHeldItemAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.main_ != nullptr); + if (_this->_impl_.main_ == nullptr) { + _this->_impl_.main_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.main_); + } else { + _this->_impl_.main_->MergeFrom(*from._impl_.main_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(from._impl_.offhand_ != nullptr); + if (_this->_impl_.offhand_ == nullptr) { + _this->_impl_.offhand_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.offhand_); + } else { + _this->_impl_.offhand_->MergeFrom(*from._impl_.offhand_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetHeldItemAction::CopyFrom(const SetHeldItemAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetHeldItemAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetHeldItemAction::InternalSwap(SetHeldItemAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_) + + sizeof(SetHeldItemAction::_impl_.offhand_) + - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_)>( + reinterpret_cast(&_impl_.main_), + reinterpret_cast(&other->_impl_.main_)); +} + +::google::protobuf::Metadata SetHeldItemAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetHealthAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._has_bits_); +}; + +SetHealthAction::SetHealthAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetHealthAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetHealthAction) +} +PROTOBUF_NDEBUG_INLINE SetHealthAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetHealthAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetHealthAction::SetHealthAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetHealthAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetHealthAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetHealthAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, health_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, health_), + offsetof(Impl_, max_health_) - + offsetof(Impl_, health_) + + sizeof(Impl_::max_health_)); + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetHealthAction) +} +PROTOBUF_NDEBUG_INLINE SetHealthAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetHealthAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, health_), + 0, + offsetof(Impl_, max_health_) - + offsetof(Impl_, health_) + + sizeof(Impl_::max_health_)); +} +SetHealthAction::~SetHealthAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetHealthAction) + SharedDtor(*this); +} +inline void SetHealthAction::SharedDtor(MessageLite& self) { + SetHealthAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetHealthAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetHealthAction(arena); +} +constexpr auto SetHealthAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetHealthAction), + alignof(SetHealthAction)); +} +constexpr auto SetHealthAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetHealthAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetHealthAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetHealthAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetHealthAction::ByteSizeLong, + &SetHealthAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._cached_size_), + false, + }, + &SetHealthAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetHealthAction_class_data_ = + SetHealthAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetHealthAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetHealthAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetHealthAction_class_data_.tc_table); + return SetHealthAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 45, 2> +SetHealthAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._has_bits_), + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SetHealthAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetHealthAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.player_uuid_)}}, + // double health = 2 [json_name = "health"]; + {::_pbi::TcParser::FastF64S1, + {17, 1, 0, + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_)}}, + // optional double max_health = 3 [json_name = "maxHealth"]; + {::_pbi::TcParser::FastF64S1, + {25, 2, 0, + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // double health = 2 [json_name = "health"]; + {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // optional double max_health = 3 [json_name = "maxHealth"]; + {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + }}, + // no aux_entries + {{ + "\31\13\0\0\0\0\0\0" + "df.plugin.SetHealthAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetHealthAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetHealthAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (BatchCheckHasBit(cached_has_bits, 0x00000006U)) { + ::memset(&_impl_.health_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.max_health_) - + reinterpret_cast(&_impl_.health_)) + sizeof(_impl_.max_health_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetHealthAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetHealthAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetHealthAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetHealthAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetHealthAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetHealthAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // double health = 2 [json_name = "health"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (::absl::bit_cast<::uint64_t>(this_._internal_health()) != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 2, this_._internal_health(), target); + } + } + + // optional double max_health = 3 [json_name = "maxHealth"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteDoubleToArray( + 3, this_._internal_max_health(), target); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetHealthAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetHealthAction::ByteSizeLong(const MessageLite& base) { + const SetHealthAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetHealthAction::ByteSizeLong() const { + const SetHealthAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetHealthAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + total_size += static_cast(0x00000004U & cached_has_bits) * 9; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // double health = 2 [json_name = "health"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (::absl::bit_cast<::uint64_t>(this_._internal_health()) != 0) { + total_size += 9; + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetHealthAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetHealthAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (::absl::bit_cast<::uint64_t>(from._internal_health()) != 0) { + _this->_impl_.health_ = from._impl_.health_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + _this->_impl_.max_health_ = from._impl_.max_health_; + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetHealthAction::CopyFrom(const SetHealthAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetHealthAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetHealthAction::InternalSwap(SetHealthAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_) + + sizeof(SetHealthAction::_impl_.max_health_) + - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_)>( + reinterpret_cast(&_impl_.health_), + reinterpret_cast(&other->_impl_.health_)); +} + +::google::protobuf::Metadata SetHealthAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetFoodAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._has_bits_); +}; + +SetFoodAction::SetFoodAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetFoodAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetFoodAction) +} +PROTOBUF_NDEBUG_INLINE SetFoodAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetFoodAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetFoodAction::SetFoodAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetFoodAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetFoodAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetFoodAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.food_ = from._impl_.food_; + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetFoodAction) +} +PROTOBUF_NDEBUG_INLINE SetFoodAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetFoodAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.food_ = {}; +} +SetFoodAction::~SetFoodAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetFoodAction) + SharedDtor(*this); +} +inline void SetFoodAction::SharedDtor(MessageLite& self) { + SetFoodAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetFoodAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetFoodAction(arena); +} +constexpr auto SetFoodAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetFoodAction), + alignof(SetFoodAction)); +} +constexpr auto SetFoodAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetFoodAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFoodAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFoodAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetFoodAction::ByteSizeLong, + &SetFoodAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._cached_size_), + false, + }, + &SetFoodAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetFoodAction_class_data_ = + SetFoodAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetFoodAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetFoodAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetFoodAction_class_data_.tc_table); + return SetFoodAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 43, 2> +SetFoodAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SetFoodAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetFoodAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // int32 food = 2 [json_name = "food"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetFoodAction, _impl_.food_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.food_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // int32 food = 2 [json_name = "food"]; + {PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.food_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\27\13\0\0\0\0\0\0" + "df.plugin.SetFoodAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetFoodAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetFoodAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + _impl_.food_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetFoodAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetFoodAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetFoodAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetFoodAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetFoodAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetFoodAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // int32 food = 2 [json_name = "food"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_food() != 0) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>( + stream, this_._internal_food(), target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetFoodAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetFoodAction::ByteSizeLong(const MessageLite& base) { + const SetFoodAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetFoodAction::ByteSizeLong() const { + const SetFoodAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetFoodAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // int32 food = 2 [json_name = "food"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_food() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_food()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetFoodAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetFoodAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (from._internal_food() != 0) { + _this->_impl_.food_ = from._impl_.food_; + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetFoodAction::CopyFrom(const SetFoodAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetFoodAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetFoodAction::InternalSwap(SetFoodAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + swap(_impl_.food_, other->_impl_.food_); +} + +::google::protobuf::Metadata SetFoodAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetExperienceAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._has_bits_); +}; + +SetExperienceAction::SetExperienceAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetExperienceAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetExperienceAction) +} +PROTOBUF_NDEBUG_INLINE SetExperienceAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetExperienceAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetExperienceAction::SetExperienceAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetExperienceAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetExperienceAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetExperienceAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, level_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, level_), + offsetof(Impl_, amount_) - + offsetof(Impl_, level_) + + sizeof(Impl_::amount_)); + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetExperienceAction) +} +PROTOBUF_NDEBUG_INLINE SetExperienceAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetExperienceAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, level_), + 0, + offsetof(Impl_, amount_) - + offsetof(Impl_, level_) + + sizeof(Impl_::amount_)); +} +SetExperienceAction::~SetExperienceAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetExperienceAction) + SharedDtor(*this); +} +inline void SetExperienceAction::SharedDtor(MessageLite& self) { + SetExperienceAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetExperienceAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetExperienceAction(arena); +} +constexpr auto SetExperienceAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetExperienceAction), + alignof(SetExperienceAction)); +} +constexpr auto SetExperienceAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetExperienceAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetExperienceAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetExperienceAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetExperienceAction::ByteSizeLong, + &SetExperienceAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._cached_size_), + false, + }, + &SetExperienceAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetExperienceAction_class_data_ = + SetExperienceAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetExperienceAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetExperienceAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetExperienceAction_class_data_.tc_table); + return SetExperienceAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 49, 2> +SetExperienceAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._has_bits_), + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SetExperienceAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetExperienceAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // optional int32 amount = 4 [json_name = "amount"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetExperienceAction, _impl_.amount_), 3>(), + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.player_uuid_)}}, + // optional int32 level = 2 [json_name = "level"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetExperienceAction, _impl_.level_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_)}}, + // optional float progress = 3 [json_name = "progress"]; + {::_pbi::TcParser::FastF32S1, + {29, 2, 0, + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.progress_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional int32 level = 2 [json_name = "level"]; + {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // optional float progress = 3 [json_name = "progress"]; + {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.progress_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, + // optional int32 amount = 4 [json_name = "amount"]; + {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + }}, + // no aux_entries + {{ + "\35\13\0\0\0\0\0\0" + "df.plugin.SetExperienceAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetExperienceAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetExperienceAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) { + ::memset(&_impl_.level_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.amount_) - + reinterpret_cast(&_impl_.level_)) + sizeof(_impl_.amount_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetExperienceAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetExperienceAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetExperienceAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetExperienceAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetExperienceAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetExperienceAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // optional int32 level = 2 [json_name = "level"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>( + stream, this_._internal_level(), target); + } + + // optional float progress = 3 [json_name = "progress"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 3, this_._internal_progress(), target); + } + + // optional int32 amount = 4 [json_name = "amount"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<4>( + stream, this_._internal_amount(), target); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetExperienceAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetExperienceAction::ByteSizeLong(const MessageLite& base) { + const SetExperienceAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetExperienceAction::ByteSizeLong() const { + const SetExperienceAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetExperienceAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + total_size += static_cast(0x00000004U & cached_has_bits) * 5; + if (BatchCheckHasBit(cached_has_bits, 0x0000000bU)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // optional int32 level = 2 [json_name = "level"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_level()); + } + // optional int32 amount = 4 [json_name = "amount"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_amount()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetExperienceAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetExperienceAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _this->_impl_.level_ = from._impl_.level_; + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + _this->_impl_.progress_ = from._impl_.progress_; + } + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + _this->_impl_.amount_ = from._impl_.amount_; + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetExperienceAction::CopyFrom(const SetExperienceAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetExperienceAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetExperienceAction::InternalSwap(SetExperienceAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_) + + sizeof(SetExperienceAction::_impl_.amount_) + - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_)>( + reinterpret_cast(&_impl_.level_), + reinterpret_cast(&other->_impl_.level_)); +} + +::google::protobuf::Metadata SetExperienceAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SetVelocityAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._has_bits_); +}; + +void SetVelocityAction::clear_velocity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.velocity_ != nullptr) _impl_.velocity_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +SetVelocityAction::SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetVelocityAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SetVelocityAction) +} +PROTOBUF_NDEBUG_INLINE SetVelocityAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SetVelocityAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +SetVelocityAction::SetVelocityAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SetVelocityAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SetVelocityAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SetVelocityAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.velocity_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.velocity_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:df.plugin.SetVelocityAction) +} +PROTOBUF_NDEBUG_INLINE SetVelocityAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void SetVelocityAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.velocity_ = {}; +} +SetVelocityAction::~SetVelocityAction() { + // @@protoc_insertion_point(destructor:df.plugin.SetVelocityAction) + SharedDtor(*this); +} +inline void SetVelocityAction::SharedDtor(MessageLite& self) { + SetVelocityAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.velocity_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SetVelocityAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SetVelocityAction(arena); +} +constexpr auto SetVelocityAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetVelocityAction), + alignof(SetVelocityAction)); +} +constexpr auto SetVelocityAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SetVelocityAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetVelocityAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetVelocityAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SetVelocityAction::ByteSizeLong, + &SetVelocityAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._cached_size_), + false, + }, + &SetVelocityAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SetVelocityAction_class_data_ = + SetVelocityAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SetVelocityAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SetVelocityAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SetVelocityAction_class_data_.tc_table); + return SetVelocityAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 1, 47, 2> +SetVelocityAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + SetVelocityAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SetVelocityAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.velocity_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + {PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.velocity_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + }}, + {{ + "\33\13\0\0\0\0\0\0" + "df.plugin.SetVelocityAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void SetVelocityAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SetVelocityAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.velocity_ != nullptr); + _impl_.velocity_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SetVelocityAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SetVelocityAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SetVelocityAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SetVelocityAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetVelocityAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetVelocityAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.velocity_, this_._impl_.velocity_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetVelocityAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SetVelocityAction::ByteSizeLong(const MessageLite& base) { + const SetVelocityAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SetVelocityAction::ByteSizeLong() const { + const SetVelocityAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetVelocityAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.velocity_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SetVelocityAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetVelocityAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.velocity_ != nullptr); + if (_this->_impl_.velocity_ == nullptr) { + _this->_impl_.velocity_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.velocity_); + } else { + _this->_impl_.velocity_->MergeFrom(*from._impl_.velocity_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SetVelocityAction::CopyFrom(const SetVelocityAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetVelocityAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetVelocityAction::InternalSwap(SetVelocityAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + swap(_impl_.velocity_, other->_impl_.velocity_); +} + +::google::protobuf::Metadata SetVelocityAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class AddEffectAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._has_bits_); +}; + +AddEffectAction::AddEffectAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, AddEffectAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.AddEffectAction) +} +PROTOBUF_NDEBUG_INLINE AddEffectAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::AddEffectAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +AddEffectAction::AddEffectAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const AddEffectAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, AddEffectAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + AddEffectAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, effect_type_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, effect_type_), + offsetof(Impl_, show_particles_) - + offsetof(Impl_, effect_type_) + + sizeof(Impl_::show_particles_)); + + // @@protoc_insertion_point(copy_constructor:df.plugin.AddEffectAction) +} +PROTOBUF_NDEBUG_INLINE AddEffectAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void AddEffectAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, effect_type_), + 0, + offsetof(Impl_, show_particles_) - + offsetof(Impl_, effect_type_) + + sizeof(Impl_::show_particles_)); +} +AddEffectAction::~AddEffectAction() { + // @@protoc_insertion_point(destructor:df.plugin.AddEffectAction) + SharedDtor(*this); +} +inline void AddEffectAction::SharedDtor(MessageLite& self) { + AddEffectAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL AddEffectAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) AddEffectAction(arena); +} +constexpr auto AddEffectAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(AddEffectAction), + alignof(AddEffectAction)); +} +constexpr auto AddEffectAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_AddEffectAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AddEffectAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AddEffectAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &AddEffectAction::ByteSizeLong, + &AddEffectAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._cached_size_), + false, + }, + &AddEffectAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull AddEffectAction_class_data_ = + AddEffectAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +AddEffectAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&AddEffectAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(AddEffectAction_class_data_.tc_table); + return AddEffectAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 0, 45, 2> +AddEffectAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._has_bits_), + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + AddEffectAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::AddEffectAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.player_uuid_)}}, + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AddEffectAction, _impl_.effect_type_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_)}}, + // int32 level = 3 [json_name = "level"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AddEffectAction, _impl_.level_), 2>(), + {24, 2, 0, + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.level_)}}, + // int64 duration_ms = 4 [json_name = "durationMs"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(AddEffectAction, _impl_.duration_ms_), 3>(), + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.duration_ms_)}}, + // bool show_particles = 5 [json_name = "showParticles"]; + {::_pbi::TcParser::SingularVarintNoZag1(), + {40, 4, 0, + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // int32 level = 3 [json_name = "level"]; + {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.level_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // int64 duration_ms = 4 [json_name = "durationMs"]; + {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.duration_ms_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // bool show_particles = 5 [json_name = "showParticles"]; + {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\31\13\0\0\0\0\0\0" + "df.plugin.AddEffectAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void AddEffectAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.AddEffectAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (BatchCheckHasBit(cached_has_bits, 0x0000001eU)) { + ::memset(&_impl_.effect_type_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.show_particles_) - + reinterpret_cast(&_impl_.effect_type_)) + sizeof(_impl_.show_particles_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL AddEffectAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const AddEffectAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL AddEffectAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const AddEffectAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.AddEffectAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.AddEffectAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_effect_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_effect_type(), target); + } + } + + // int32 level = 3 [json_name = "level"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_level() != 0) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>( + stream, this_._internal_level(), target); + } + } + + // int64 duration_ms = 4 [json_name = "durationMs"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_duration_ms() != 0) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>( + stream, this_._internal_duration_ms(), target); + } + } + + // bool show_particles = 5 [json_name = "showParticles"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_show_particles() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_show_particles(), target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.AddEffectAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t AddEffectAction::ByteSizeLong(const MessageLite& base) { + const AddEffectAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t AddEffectAction::ByteSizeLong() const { + const AddEffectAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.AddEffectAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_effect_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_effect_type()); + } + } + // int32 level = 3 [json_name = "level"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_level() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_level()); + } + } + // int64 duration_ms = 4 [json_name = "durationMs"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_duration_ms() != 0) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_duration_ms()); + } + } + // bool show_particles = 5 [json_name = "showParticles"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (this_._internal_show_particles() != 0) { + total_size += 2; + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void AddEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.AddEffectAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (from._internal_effect_type() != 0) { + _this->_impl_.effect_type_ = from._impl_.effect_type_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (from._internal_level() != 0) { + _this->_impl_.level_ = from._impl_.level_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (from._internal_duration_ms() != 0) { + _this->_impl_.duration_ms_ = from._impl_.duration_ms_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + if (from._internal_show_particles() != 0) { + _this->_impl_.show_particles_ = from._impl_.show_particles_; + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void AddEffectAction::CopyFrom(const AddEffectAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.AddEffectAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AddEffectAction::InternalSwap(AddEffectAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_) + + sizeof(AddEffectAction::_impl_.show_particles_) + - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_)>( + reinterpret_cast(&_impl_.effect_type_), + reinterpret_cast(&other->_impl_.effect_type_)); +} + +::google::protobuf::Metadata AddEffectAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class RemoveEffectAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._has_bits_); +}; + +RemoveEffectAction::RemoveEffectAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RemoveEffectAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.RemoveEffectAction) +} +PROTOBUF_NDEBUG_INLINE RemoveEffectAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::RemoveEffectAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +RemoveEffectAction::RemoveEffectAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const RemoveEffectAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, RemoveEffectAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + RemoveEffectAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + _impl_.effect_type_ = from._impl_.effect_type_; + + // @@protoc_insertion_point(copy_constructor:df.plugin.RemoveEffectAction) +} +PROTOBUF_NDEBUG_INLINE RemoveEffectAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena) {} + +inline void RemoveEffectAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.effect_type_ = {}; +} +RemoveEffectAction::~RemoveEffectAction() { + // @@protoc_insertion_point(destructor:df.plugin.RemoveEffectAction) + SharedDtor(*this); +} +inline void RemoveEffectAction::SharedDtor(MessageLite& self) { + RemoveEffectAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL RemoveEffectAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) RemoveEffectAction(arena); +} +constexpr auto RemoveEffectAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemoveEffectAction), + alignof(RemoveEffectAction)); +} +constexpr auto RemoveEffectAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_RemoveEffectAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RemoveEffectAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RemoveEffectAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &RemoveEffectAction::ByteSizeLong, + &RemoveEffectAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._cached_size_), + false, + }, + &RemoveEffectAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull RemoveEffectAction_class_data_ = + RemoveEffectAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +RemoveEffectAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&RemoveEffectAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(RemoveEffectAction_class_data_.tc_table); + return RemoveEffectAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 48, 2> +RemoveEffectAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + RemoveEffectAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::RemoveEffectAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RemoveEffectAction, _impl_.effect_type_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.effect_type_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + {PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.effect_type_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + // no aux_entries + {{ + "\34\13\0\0\0\0\0\0" + "df.plugin.RemoveEffectAction" + "player_uuid" + }}, +}; +PROTOBUF_NOINLINE void RemoveEffectAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.RemoveEffectAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + _impl_.effect_type_ = 0; + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL RemoveEffectAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const RemoveEffectAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL RemoveEffectAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const RemoveEffectAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.RemoveEffectAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.RemoveEffectAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_effect_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_effect_type(), target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.RemoveEffectAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t RemoveEffectAction::ByteSizeLong(const MessageLite& base) { + const RemoveEffectAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t RemoveEffectAction::ByteSizeLong() const { + const RemoveEffectAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.RemoveEffectAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_effect_type() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_effect_type()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void RemoveEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.RemoveEffectAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (from._internal_effect_type() != 0) { + _this->_impl_.effect_type_ = from._impl_.effect_type_; + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void RemoveEffectAction::CopyFrom(const RemoveEffectAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.RemoveEffectAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RemoveEffectAction::InternalSwap(RemoveEffectAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + swap(_impl_.effect_type_, other->_impl_.effect_type_); +} + +::google::protobuf::Metadata RemoveEffectAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SendTitleAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._has_bits_); +}; + +SendTitleAction::SendTitleAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendTitleAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SendTitleAction) +} +PROTOBUF_NDEBUG_INLINE SendTitleAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SendTitleAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_), + title_(arena, from.title_), + subtitle_(arena, from.subtitle_) {} + +SendTitleAction::SendTitleAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SendTitleAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendTitleAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SendTitleAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, fade_in_ms_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, fade_in_ms_), + offsetof(Impl_, fade_out_ms_) - + offsetof(Impl_, fade_in_ms_) + + sizeof(Impl_::fade_out_ms_)); + + // @@protoc_insertion_point(copy_constructor:df.plugin.SendTitleAction) +} +PROTOBUF_NDEBUG_INLINE SendTitleAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena), + title_(arena), + subtitle_(arena) {} + +inline void SendTitleAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, fade_in_ms_), + 0, + offsetof(Impl_, fade_out_ms_) - + offsetof(Impl_, fade_in_ms_) + + sizeof(Impl_::fade_out_ms_)); +} +SendTitleAction::~SendTitleAction() { + // @@protoc_insertion_point(destructor:df.plugin.SendTitleAction) + SharedDtor(*this); +} +inline void SendTitleAction::SharedDtor(MessageLite& self) { + SendTitleAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.title_.Destroy(); + this_._impl_.subtitle_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SendTitleAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SendTitleAction(arena); +} +constexpr auto SendTitleAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendTitleAction), + alignof(SendTitleAction)); +} +constexpr auto SendTitleAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SendTitleAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SendTitleAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SendTitleAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SendTitleAction::ByteSizeLong, + &SendTitleAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._cached_size_), + false, + }, + &SendTitleAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SendTitleAction_class_data_ = + SendTitleAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SendTitleAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SendTitleAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SendTitleAction_class_data_.tc_table); + return SendTitleAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 6, 0, 58, 2> +SendTitleAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._has_bits_), + 0, // no _extensions_ + 6, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967232, // skipmap + offsetof(decltype(_table_), field_entries), + 6, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SendTitleAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SendTitleAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.player_uuid_)}}, + // string title = 2 [json_name = "title"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.title_)}}, + // optional string subtitle = 3 [json_name = "subtitle"]; + {::_pbi::TcParser::FastUS1, + {26, 2, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.subtitle_)}}, + // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.fade_in_ms_), 3>(), + {32, 3, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_)}}, + // optional int64 duration_ms = 5 [json_name = "durationMs"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.duration_ms_), 4>(), + {40, 4, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.duration_ms_)}}, + // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.fade_out_ms_), 5>(), + {48, 5, 0, + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_)}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string title = 2 [json_name = "title"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.title_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional string subtitle = 3 [json_name = "subtitle"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.subtitle_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // optional int64 duration_ms = 5 [json_name = "durationMs"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.duration_ms_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; + {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + }}, + // no aux_entries + {{ + "\31\13\5\10\0\0\0\0" + "df.plugin.SendTitleAction" + "player_uuid" + "title" + "subtitle" + }}, +}; +PROTOBUF_NOINLINE void SendTitleAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SendTitleAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _impl_.title_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + _impl_.subtitle_.ClearNonDefaultToEmpty(); + } + } + if (BatchCheckHasBit(cached_has_bits, 0x00000038U)) { + ::memset(&_impl_.fade_in_ms_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.fade_out_ms_) - + reinterpret_cast(&_impl_.fade_in_ms_)) + sizeof(_impl_.fade_out_ms_)); + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SendTitleAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SendTitleAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SendTitleAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SendTitleAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendTitleAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // string title = 2 [json_name = "title"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_title().empty()) { + const ::std::string& _s = this_._internal_title(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.title"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + } + + // optional string subtitle = 3 [json_name = "subtitle"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + const ::std::string& _s = this_._internal_subtitle(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.subtitle"); + target = stream->WriteStringMaybeAliased(3, _s, target); + } + + // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>( + stream, this_._internal_fade_in_ms(), target); + } + + // optional int64 duration_ms = 5 [json_name = "durationMs"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>( + stream, this_._internal_duration_ms(), target); + } + + // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<6>( + stream, this_._internal_fade_out_ms(), target); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendTitleAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SendTitleAction::ByteSizeLong(const MessageLite& base) { + const SendTitleAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SendTitleAction::ByteSizeLong() const { + const SendTitleAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendTitleAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // string title = 2 [json_name = "title"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_title().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_title()); + } + } + // optional string subtitle = 3 [json_name = "subtitle"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_subtitle()); + } + // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_fade_in_ms()); + } + // optional int64 duration_ms = 5 [json_name = "durationMs"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_duration_ms()); + } + // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( + this_._internal_fade_out_ms()); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SendTitleAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendTitleAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_title().empty()) { + _this->_internal_set_title(from._internal_title()); + } else { + if (_this->_impl_.title_.IsDefault()) { + _this->_internal_set_title(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + _this->_internal_set_subtitle(from._internal_subtitle()); + } + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + _this->_impl_.fade_in_ms_ = from._impl_.fade_in_ms_; + } + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + _this->_impl_.duration_ms_ = from._impl_.duration_ms_; + } + if (CheckHasBit(cached_has_bits, 0x00000020U)) { + _this->_impl_.fade_out_ms_ = from._impl_.fade_out_ms_; + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SendTitleAction::CopyFrom(const SendTitleAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendTitleAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SendTitleAction::InternalSwap(SendTitleAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.title_, &other->_impl_.title_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.subtitle_, &other->_impl_.subtitle_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_) + + sizeof(SendTitleAction::_impl_.fade_out_ms_) + - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_)>( + reinterpret_cast(&_impl_.fade_in_ms_), + reinterpret_cast(&other->_impl_.fade_in_ms_)); +} + +::google::protobuf::Metadata SendTitleAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SendPopupAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._has_bits_); +}; + +SendPopupAction::SendPopupAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendPopupAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SendPopupAction) +} +PROTOBUF_NDEBUG_INLINE SendPopupAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SendPopupAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_), + message_(arena, from.message_) {} + +SendPopupAction::SendPopupAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SendPopupAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendPopupAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SendPopupAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:df.plugin.SendPopupAction) +} +PROTOBUF_NDEBUG_INLINE SendPopupAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena), + message_(arena) {} + +inline void SendPopupAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +SendPopupAction::~SendPopupAction() { + // @@protoc_insertion_point(destructor:df.plugin.SendPopupAction) + SharedDtor(*this); +} +inline void SendPopupAction::SharedDtor(MessageLite& self) { + SendPopupAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.message_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SendPopupAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SendPopupAction(arena); +} +constexpr auto SendPopupAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendPopupAction), + alignof(SendPopupAction)); +} +constexpr auto SendPopupAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SendPopupAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SendPopupAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SendPopupAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SendPopupAction::ByteSizeLong, + &SendPopupAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._cached_size_), + false, + }, + &SendPopupAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SendPopupAction_class_data_ = + SendPopupAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SendPopupAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SendPopupAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SendPopupAction_class_data_.tc_table); + return SendPopupAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 52, 2> +SendPopupAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SendPopupAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SendPopupAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string message = 2 [json_name = "message"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.message_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string message = 2 [json_name = "message"]; + {PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\31\13\7\0\0\0\0\0" + "df.plugin.SendPopupAction" + "player_uuid" + "message" + }}, +}; +PROTOBUF_NOINLINE void SendPopupAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SendPopupAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _impl_.message_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SendPopupAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SendPopupAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SendPopupAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SendPopupAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendPopupAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendPopupAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + const ::std::string& _s = this_._internal_message(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendPopupAction.message"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendPopupAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SendPopupAction::ByteSizeLong(const MessageLite& base) { + const SendPopupAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SendPopupAction::ByteSizeLong() const { + const SendPopupAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendPopupAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_message()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SendPopupAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendPopupAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } else { + if (_this->_impl_.message_.IsDefault()) { + _this->_internal_set_message(""); + } + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SendPopupAction::CopyFrom(const SendPopupAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendPopupAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SendPopupAction::InternalSwap(SendPopupAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); +} + +::google::protobuf::Metadata SendPopupAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class SendTipAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._has_bits_); +}; + +SendTipAction::SendTipAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendTipAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.SendTipAction) +} +PROTOBUF_NDEBUG_INLINE SendTipAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::SendTipAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_), + message_(arena, from.message_) {} + +SendTipAction::SendTipAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const SendTipAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, SendTipAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SendTipAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + + // @@protoc_insertion_point(copy_constructor:df.plugin.SendTipAction) +} +PROTOBUF_NDEBUG_INLINE SendTipAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0}, + player_uuid_(arena), + message_(arena) {} + +inline void SendTipAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +SendTipAction::~SendTipAction() { + // @@protoc_insertion_point(destructor:df.plugin.SendTipAction) + SharedDtor(*this); +} +inline void SendTipAction::SharedDtor(MessageLite& self) { + SendTipAction& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.player_uuid_.Destroy(); + this_._impl_.message_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL SendTipAction::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) SendTipAction(arena); +} +constexpr auto SendTipAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendTipAction), + alignof(SendTipAction)); +} +constexpr auto SendTipAction::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_SendTipAction_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SendTipAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SendTipAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &SendTipAction::ByteSizeLong, + &SendTipAction::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._cached_size_), + false, + }, + &SendTipAction::kDescriptorMethods, + &descriptor_table_actions_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull SendTipAction_class_data_ = + SendTipAction::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +SendTipAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&SendTipAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(SendTipAction_class_data_.tc_table); + return SendTipAction_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 50, 2> +SendTipAction::_table_ = { + { + PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + SendTipAction_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::SendTipAction>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // string message = 2 [json_name = "message"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.message_)}}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {::_pbi::TcParser::FastUS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.player_uuid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string message = 2 [json_name = "message"]; + {PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\27\13\7\0\0\0\0\0" + "df.plugin.SendTipAction" + "player_uuid" + "message" + }}, +}; +PROTOBUF_NOINLINE void SendTipAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.SendTipAction) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.player_uuid_.ClearNonDefaultToEmpty(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + _impl_.message_.ClearNonDefaultToEmpty(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL SendTipAction::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const SendTipAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL SendTipAction::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const SendTipAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendTipAction) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTipAction.player_uuid"); + target = stream->WriteStringMaybeAliased(1, _s, target); + } + } + + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + const ::std::string& _s = this_._internal_message(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTipAction.message"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendTipAction) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t SendTipAction::ByteSizeLong(const MessageLite& base) { + const SendTipAction& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t SendTipAction::ByteSizeLong() const { + const SendTipAction& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendTipAction) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!this_._internal_player_uuid().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_player_uuid()); + } + } + // string message = 2 [json_name = "message"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!this_._internal_message().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_message()); + } + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void SendTipAction::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendTipAction) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); + } + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (!from._internal_message().empty()) { + _this->_internal_set_message(from._internal_message()); + } else { + if (_this->_impl_.message_.IsDefault()) { + _this->_internal_set_message(""); + } + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void SendTipAction::CopyFrom(const SendTipAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendTipAction) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SendTipAction::InternalSwap(SendTipAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); +} + +::google::protobuf::Metadata SendTipAction::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + +class PlaySoundAction::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._has_bits_); +}; + +void PlaySoundAction::clear_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +PlaySoundAction::PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PlaySoundAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.PlaySoundAction) +} +PROTOBUF_NDEBUG_INLINE PlaySoundAction::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::PlaySoundAction& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0}, + player_uuid_(arena, from.player_uuid_) {} + +PlaySoundAction::PlaySoundAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const PlaySoundAction& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, PlaySoundAction_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + PlaySoundAction* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) + : nullptr; + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, sound_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, sound_), + offsetof(Impl_, pitch_) - + offsetof(Impl_, sound_) + + sizeof(Impl_::pitch_)); + + // @@protoc_insertion_point(copy_constructor:df.plugin.PlaySoundAction) +} +PROTOBUF_NDEBUG_INLINE PlaySoundAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - target_uuid_(arena), - message_(arena) {} + player_uuid_(arena) {} -inline void SendChatAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void PlaySoundAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, position_), + 0, + offsetof(Impl_, pitch_) - + offsetof(Impl_, position_) + + sizeof(Impl_::pitch_)); } -SendChatAction::~SendChatAction() { - // @@protoc_insertion_point(destructor:df.plugin.SendChatAction) +PlaySoundAction::~PlaySoundAction() { + // @@protoc_insertion_point(destructor:df.plugin.PlaySoundAction) SharedDtor(*this); } -inline void SendChatAction::SharedDtor(MessageLite& self) { - SendChatAction& this_ = static_cast(self); +inline void PlaySoundAction::SharedDtor(MessageLite& self) { + PlaySoundAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.target_uuid_.Destroy(); - this_._impl_.message_.Destroy(); + this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.position_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SendChatAction::PlacementNew_( +inline void* PROTOBUF_NONNULL PlaySoundAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SendChatAction(arena); + return ::new (mem) PlaySoundAction(arena); } -constexpr auto SendChatAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendChatAction), - alignof(SendChatAction)); +constexpr auto PlaySoundAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PlaySoundAction), + alignof(PlaySoundAction)); } -constexpr auto SendChatAction::InternalGenerateClassData_() { +constexpr auto PlaySoundAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SendChatAction_default_instance_._instance, + &_PlaySoundAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SendChatAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &PlaySoundAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SendChatAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SendChatAction::ByteSizeLong, - &SendChatAction::_InternalSerialize, + &PlaySoundAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &PlaySoundAction::ByteSizeLong, + &PlaySoundAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._cached_size_), false, }, - &SendChatAction::kDescriptorMethods, + &PlaySoundAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SendChatAction_class_data_ = - SendChatAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull PlaySoundAction_class_data_ = + PlaySoundAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SendChatAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SendChatAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SendChatAction_class_data_.tc_table); - return SendChatAction_class_data_.base(); +PlaySoundAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&PlaySoundAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(PlaySoundAction_class_data_.tc_table); + return PlaySoundAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 51, 2> -SendChatAction::_table_ = { +const ::_pbi::TcParseTable<3, 5, 1, 45, 2> +PlaySoundAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._has_bits_), 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask + 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap + 4294967264, // skipmap offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SendChatAction_class_data_.base(), + 5, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + PlaySoundAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SendChatAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::PlaySoundAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string message = 2 [json_name = "message"]; - {::_pbi::TcParser::FastUS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.message_)}}, - // string target_uuid = 1 [json_name = "targetUuid"]; + {::_pbi::TcParser::MiniParse, {}}, + // string player_uuid = 1 [json_name = "playerUuid"]; {::_pbi::TcParser::FastUS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.target_uuid_)}}, + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.player_uuid_)}}, + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PlaySoundAction, _impl_.sound_), 2>(), + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.sound_)}}, + // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {26, 1, 0, + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_)}}, + // optional float volume = 4 [json_name = "volume"]; + {::_pbi::TcParser::FastF32S1, + {37, 3, 0, + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.volume_)}}, + // optional float pitch = 5 [json_name = "pitch"]; + {::_pbi::TcParser::FastF32S1, + {45, 4, 0, + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ - // string target_uuid = 1 [json_name = "targetUuid"]; - {PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.target_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string message = 2 [json_name = "message"]; - {PROTOBUF_FIELD_OFFSET(SendChatAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string player_uuid = 1 [json_name = "playerUuid"]; + {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.sound_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional float volume = 4 [json_name = "volume"]; + {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.volume_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, + // optional float pitch = 5 [json_name = "pitch"]; + {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, }}, - // no aux_entries {{ - "\30\13\7\0\0\0\0\0" - "df.plugin.SendChatAction" - "target_uuid" - "message" + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + }}, + {{ + "\31\13\0\0\0\0\0\0" + "df.plugin.PlaySoundAction" + "player_uuid" }}, }; -PROTOBUF_NOINLINE void SendChatAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SendChatAction) +PROTOBUF_NOINLINE void PlaySoundAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.PlaySoundAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -2608,72 +9281,98 @@ PROTOBUF_NOINLINE void SendChatAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.target_uuid_.ClearNonDefaultToEmpty(); + _impl_.player_uuid_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.message_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); } } + if (BatchCheckHasBit(cached_has_bits, 0x0000001cU)) { + ::memset(&_impl_.sound_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.pitch_) - + reinterpret_cast(&_impl_.sound_)) + sizeof(_impl_.pitch_)); + } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SendChatAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL PlaySoundAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SendChatAction& this_ = static_cast(base); + const PlaySoundAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SendChatAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL PlaySoundAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SendChatAction& this_ = *this; + const PlaySoundAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendChatAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.PlaySoundAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string target_uuid = 1 [json_name = "targetUuid"]; + // string player_uuid = 1 [json_name = "playerUuid"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_target_uuid().empty()) { - const ::std::string& _s = this_._internal_target_uuid(); + if (!this_._internal_player_uuid().empty()) { + const ::std::string& _s = this_._internal_player_uuid(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendChatAction.target_uuid"); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.PlaySoundAction.player_uuid"); target = stream->WriteStringMaybeAliased(1, _s, target); } } - // string message = 2 [json_name = "message"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - const ::std::string& _s = this_._internal_message(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendChatAction.message"); - target = stream->WriteStringMaybeAliased(2, _s, target); + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_sound() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_sound(), target); } } + // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); + } + + // optional float volume = 4 [json_name = "volume"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 4, this_._internal_volume(), target); + } + + // optional float pitch = 5 [json_name = "pitch"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteFloatToArray( + 5, this_._internal_pitch(), target); + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendChatAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.PlaySoundAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SendChatAction::ByteSizeLong(const MessageLite& base) { - const SendChatAction& this_ = static_cast(base); +::size_t PlaySoundAction::ByteSizeLong(const MessageLite& base) { + const PlaySoundAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SendChatAction::ByteSizeLong() const { - const SendChatAction& this_ = *this; +::size_t PlaySoundAction::ByteSizeLong() const { + const PlaySoundAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendChatAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.PlaySoundAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -2682,19 +9381,25 @@ ::size_t SendChatAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string target_uuid = 1 [json_name = "targetUuid"]; + total_size += ::absl::popcount(0x00000018U & cached_has_bits) * 5; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // string player_uuid = 1 [json_name = "playerUuid"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_target_uuid().empty()) { + if (!this_._internal_player_uuid().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_target_uuid()); + this_._internal_player_uuid()); } } - // string message = 2 [json_name = "message"]; + // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_message()); + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + } + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_sound() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_sound()); } } } @@ -2702,274 +9407,252 @@ ::size_t SendChatAction::ByteSizeLong() const { &this_._impl_._cached_size_); } -void SendChatAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void PlaySoundAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendChatAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.PlaySoundAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_target_uuid().empty()) { - _this->_internal_set_target_uuid(from._internal_target_uuid()); - } else { - if (_this->_impl_.target_uuid_.IsDefault()) { - _this->_internal_set_target_uuid(""); + if (!from._internal_player_uuid().empty()) { + _this->_internal_set_player_uuid(from._internal_player_uuid()); + } else { + if (_this->_impl_.player_uuid_.IsDefault()) { + _this->_internal_set_player_uuid(""); } } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_message().empty()) { - _this->_internal_set_message(from._internal_message()); + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); } else { - if (_this->_impl_.message_.IsDefault()) { - _this->_internal_set_message(""); - } + _this->_impl_.position_->MergeFrom(*from._impl_.position_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (from._internal_sound() != 0) { + _this->_impl_.sound_ = from._impl_.sound_; } } + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + _this->_impl_.volume_ = from._impl_.volume_; + } + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + _this->_impl_.pitch_ = from._impl_.pitch_; + } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void SendChatAction::CopyFrom(const SendChatAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendChatAction) +void PlaySoundAction::CopyFrom(const PlaySoundAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.PlaySoundAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SendChatAction::InternalSwap(SendChatAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void PlaySoundAction::InternalSwap(PlaySoundAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.target_uuid_, &other->_impl_.target_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_) + + sizeof(PlaySoundAction::_impl_.pitch_) + - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_)>( + reinterpret_cast(&_impl_.position_), + reinterpret_cast(&other->_impl_.position_)); } -::google::protobuf::Metadata SendChatAction::GetMetadata() const { +::google::protobuf::Metadata PlaySoundAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class TeleportAction::_Internal { +class ExecuteCommandAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._has_bits_); }; -void TeleportAction::clear_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ != nullptr) _impl_.position_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); -} -void TeleportAction::clear_rotation() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.rotation_ != nullptr) _impl_.rotation_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); -} -TeleportAction::TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +ExecuteCommandAction::ExecuteCommandAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, TeleportAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ExecuteCommandAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.TeleportAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.ExecuteCommandAction) } -PROTOBUF_NDEBUG_INLINE TeleportAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ExecuteCommandAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::TeleportAction& from_msg) + [[maybe_unused]] const ::df::plugin::ExecuteCommandAction& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + player_uuid_(arena, from.player_uuid_), + command_(arena, from.command_) {} -TeleportAction::TeleportAction( +ExecuteCommandAction::ExecuteCommandAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const TeleportAction& from) + const ExecuteCommandAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, TeleportAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ExecuteCommandAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - TeleportAction* const _this = this; + ExecuteCommandAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) - : nullptr; - _impl_.rotation_ = (CheckHasBit(cached_has_bits, 0x00000004U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.rotation_) - : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.TeleportAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.ExecuteCommandAction) } -PROTOBUF_NDEBUG_INLINE TeleportAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ExecuteCommandAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena) {} + player_uuid_(arena), + command_(arena) {} -inline void TeleportAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void ExecuteCommandAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, position_), - 0, - offsetof(Impl_, rotation_) - - offsetof(Impl_, position_) + - sizeof(Impl_::rotation_)); } -TeleportAction::~TeleportAction() { - // @@protoc_insertion_point(destructor:df.plugin.TeleportAction) +ExecuteCommandAction::~ExecuteCommandAction() { + // @@protoc_insertion_point(destructor:df.plugin.ExecuteCommandAction) SharedDtor(*this); } -inline void TeleportAction::SharedDtor(MessageLite& self) { - TeleportAction& this_ = static_cast(self); +inline void ExecuteCommandAction::SharedDtor(MessageLite& self) { + ExecuteCommandAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); this_._impl_.player_uuid_.Destroy(); - delete this_._impl_.position_; - delete this_._impl_.rotation_; + this_._impl_.command_.Destroy(); this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL TeleportAction::PlacementNew_( +inline void* PROTOBUF_NONNULL ExecuteCommandAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) TeleportAction(arena); + return ::new (mem) ExecuteCommandAction(arena); } -constexpr auto TeleportAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TeleportAction), - alignof(TeleportAction)); +constexpr auto ExecuteCommandAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExecuteCommandAction), + alignof(ExecuteCommandAction)); } -constexpr auto TeleportAction::InternalGenerateClassData_() { +constexpr auto ExecuteCommandAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_TeleportAction_default_instance_._instance, + &_ExecuteCommandAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &TeleportAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &ExecuteCommandAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &TeleportAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &TeleportAction::ByteSizeLong, - &TeleportAction::_InternalSerialize, + &ExecuteCommandAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ExecuteCommandAction::ByteSizeLong, + &ExecuteCommandAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._cached_size_), false, }, - &TeleportAction::kDescriptorMethods, + &ExecuteCommandAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull TeleportAction_class_data_ = - TeleportAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull ExecuteCommandAction_class_data_ = + ExecuteCommandAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -TeleportAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&TeleportAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(TeleportAction_class_data_.tc_table); - return TeleportAction_class_data_.base(); +ExecuteCommandAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ExecuteCommandAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ExecuteCommandAction_class_data_.tc_table); + return ExecuteCommandAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 2, 44, 2> -TeleportAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 0, 57, 2> +ExecuteCommandAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._has_bits_), 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 3, // num_field_entries - 2, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - TeleportAction_class_data_.base(), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ExecuteCommandAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::TeleportAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::ExecuteCommandAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - {::_pbi::TcParser::MiniParse, {}}, + // string command = 2 [json_name = "command"]; + {::_pbi::TcParser::FastUS1, + {18, 1, 0, + PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.command_)}}, // string player_uuid = 1 [json_name = "playerUuid"]; {::_pbi::TcParser::FastUS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.player_uuid_)}}, - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {::_pbi::TcParser::FastMtS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_)}}, - // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; - {::_pbi::TcParser::FastMtS1, - {26, 2, 1, - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_)}}, + PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.player_uuid_)}}, }}, {{ 65535, 65535 }}, {{ // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; - {PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, - {{ - {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, - {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string command = 2 [json_name = "command"]; + {PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.command_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, + // no aux_entries {{ - "\30\13\0\0\0\0\0\0" - "df.plugin.TeleportAction" + "\36\13\7\0\0\0\0\0" + "df.plugin.ExecuteCommandAction" "player_uuid" + "command" }}, }; -PROTOBUF_NOINLINE void TeleportAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.TeleportAction) +PROTOBUF_NOINLINE void ExecuteCommandAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.ExecuteCommandAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { _impl_.player_uuid_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.position_ != nullptr); - _impl_.position_->Clear(); - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(_impl_.rotation_ != nullptr); - _impl_.rotation_->Clear(); + _impl_.command_.ClearNonDefaultToEmpty(); } } _impl_._has_bits_.Clear(); @@ -2977,20 +9660,20 @@ PROTOBUF_NOINLINE void TeleportAction::Clear() { } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ExecuteCommandAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const TeleportAction& this_ = static_cast(base); + const ExecuteCommandAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ExecuteCommandAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const TeleportAction& this_ = *this; + const ExecuteCommandAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.TeleportAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ExecuteCommandAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -3000,23 +9683,19 @@ ::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( if (!this_._internal_player_uuid().empty()) { const ::std::string& _s = this_._internal_player_uuid(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.TeleportAction.player_uuid"); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ExecuteCommandAction.player_uuid"); target = stream->WriteStringMaybeAliased(1, _s, target); } } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; + // string command = 2 [json_name = "command"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, - stream); - } - - // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, *this_._impl_.rotation_, this_._impl_.rotation_->GetCachedSize(), target, - stream); + if (!this_._internal_command().empty()) { + const ::std::string& _s = this_._internal_command(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ExecuteCommandAction.command"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -3024,18 +9703,18 @@ ::uint8_t* PROTOBUF_NONNULL TeleportAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.TeleportAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ExecuteCommandAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t TeleportAction::ByteSizeLong(const MessageLite& base) { - const TeleportAction& this_ = static_cast(base); +::size_t ExecuteCommandAction::ByteSizeLong(const MessageLite& base) { + const ExecuteCommandAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t TeleportAction::ByteSizeLong() const { - const TeleportAction& this_ = *this; +::size_t ExecuteCommandAction::ByteSizeLong() const { + const ExecuteCommandAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.TeleportAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.ExecuteCommandAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -3044,7 +9723,7 @@ ::size_t TeleportAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { // string player_uuid = 1 [json_name = "playerUuid"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (!this_._internal_player_uuid().empty()) { @@ -3052,37 +9731,33 @@ ::size_t TeleportAction::ByteSizeLong() const { this_._internal_player_uuid()); } } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; + // string command = 2 [json_name = "command"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); - } - // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.rotation_); + if (!this_._internal_command().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_command()); + } } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void TeleportAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void ExecuteCommandAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.TeleportAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ExecuteCommandAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { if (!from._internal_player_uuid().empty()) { _this->_internal_set_player_uuid(from._internal_player_uuid()); @@ -3093,19 +9768,12 @@ void TeleportAction::MergeImpl(::google::protobuf::MessageLite& to_msg, } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.position_ != nullptr); - if (_this->_impl_.position_ == nullptr) { - _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); - } else { - _this->_impl_.position_->MergeFrom(*from._impl_.position_); - } - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(from._impl_.rotation_ != nullptr); - if (_this->_impl_.rotation_ == nullptr) { - _this->_impl_.rotation_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.rotation_); + if (!from._internal_command().empty()) { + _this->_internal_set_command(from._internal_command()); } else { - _this->_impl_.rotation_->MergeFrom(*from._impl_.rotation_); + if (_this->_impl_.command_.IsDefault()) { + _this->_internal_set_command(""); + } } } } @@ -3114,244 +9782,242 @@ void TeleportAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void TeleportAction::CopyFrom(const TeleportAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.TeleportAction) +void ExecuteCommandAction::CopyFrom(const ExecuteCommandAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ExecuteCommandAction) if (&from == this) return; Clear(); MergeFrom(from); } -void TeleportAction::InternalSwap(TeleportAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void ExecuteCommandAction::InternalSwap(ExecuteCommandAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.rotation_) - + sizeof(TeleportAction::_impl_.rotation_) - - PROTOBUF_FIELD_OFFSET(TeleportAction, _impl_.position_)>( - reinterpret_cast(&_impl_.position_), - reinterpret_cast(&other->_impl_.position_)); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.command_, &other->_impl_.command_, arena); } -::google::protobuf::Metadata TeleportAction::GetMetadata() const { +::google::protobuf::Metadata ExecuteCommandAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class KickAction::_Internal { +class WorldSetDefaultGameModeAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(KickAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_._has_bits_); }; -KickAction::KickAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldSetDefaultGameModeAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +WorldSetDefaultGameModeAction::WorldSetDefaultGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, KickAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetDefaultGameModeAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.KickAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldSetDefaultGameModeAction) } -PROTOBUF_NDEBUG_INLINE KickAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetDefaultGameModeAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::KickAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldSetDefaultGameModeAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_), - reason_(arena, from.reason_) {} + _cached_size_{0} {} -KickAction::KickAction( +WorldSetDefaultGameModeAction::WorldSetDefaultGameModeAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const KickAction& from) + const WorldSetDefaultGameModeAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, KickAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetDefaultGameModeAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - KickAction* const _this = this; + WorldSetDefaultGameModeAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.game_mode_ = from._impl_.game_mode_; - // @@protoc_insertion_point(copy_constructor:df.plugin.KickAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldSetDefaultGameModeAction) } -PROTOBUF_NDEBUG_INLINE KickAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetDefaultGameModeAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena), - reason_(arena) {} + : _cached_size_{0} {} -inline void KickAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldSetDefaultGameModeAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, game_mode_) - + offsetof(Impl_, world_) + + sizeof(Impl_::game_mode_)); } -KickAction::~KickAction() { - // @@protoc_insertion_point(destructor:df.plugin.KickAction) +WorldSetDefaultGameModeAction::~WorldSetDefaultGameModeAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldSetDefaultGameModeAction) SharedDtor(*this); } -inline void KickAction::SharedDtor(MessageLite& self) { - KickAction& this_ = static_cast(self); +inline void WorldSetDefaultGameModeAction::SharedDtor(MessageLite& self) { + WorldSetDefaultGameModeAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - this_._impl_.reason_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL KickAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldSetDefaultGameModeAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) KickAction(arena); + return ::new (mem) WorldSetDefaultGameModeAction(arena); } -constexpr auto KickAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(KickAction), - alignof(KickAction)); +constexpr auto WorldSetDefaultGameModeAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldSetDefaultGameModeAction), + alignof(WorldSetDefaultGameModeAction)); } -constexpr auto KickAction::InternalGenerateClassData_() { +constexpr auto WorldSetDefaultGameModeAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_KickAction_default_instance_._instance, + &_WorldSetDefaultGameModeAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &KickAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldSetDefaultGameModeAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &KickAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &KickAction::ByteSizeLong, - &KickAction::_InternalSerialize, + &WorldSetDefaultGameModeAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldSetDefaultGameModeAction::ByteSizeLong, + &WorldSetDefaultGameModeAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(KickAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_._cached_size_), false, }, - &KickAction::kDescriptorMethods, + &WorldSetDefaultGameModeAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull KickAction_class_data_ = - KickAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldSetDefaultGameModeAction_class_data_ = + WorldSetDefaultGameModeAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -KickAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&KickAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(KickAction_class_data_.tc_table); - return KickAction_class_data_.base(); +WorldSetDefaultGameModeAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldSetDefaultGameModeAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldSetDefaultGameModeAction_class_data_.tc_table); + return WorldSetDefaultGameModeAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 46, 2> -KickAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> +WorldSetDefaultGameModeAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(KickAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - KickAction_class_data_.base(), + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldSetDefaultGameModeAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::KickAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldSetDefaultGameModeAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string reason = 2 [json_name = "reason"]; - {::_pbi::TcParser::FastUS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(KickAction, _impl_.reason_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldSetDefaultGameModeAction, _impl_.game_mode_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.game_mode_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(KickAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(KickAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string reason = 2 [json_name = "reason"]; - {PROTOBUF_FIELD_OFFSET(KickAction, _impl_.reason_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + {PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.game_mode_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, }}, - // no aux_entries {{ - "\24\13\6\0\0\0\0\0" - "df.plugin.KickAction" - "player_uuid" - "reason" }}, }; -PROTOBUF_NOINLINE void KickAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.KickAction) +PROTOBUF_NOINLINE void WorldSetDefaultGameModeAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldSetDefaultGameModeAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.reason_.ClearNonDefaultToEmpty(); - } + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } + _impl_.game_mode_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL KickAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetDefaultGameModeAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const KickAction& this_ = static_cast(base); + const WorldSetDefaultGameModeAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL KickAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetDefaultGameModeAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const KickAction& this_ = *this; + const WorldSetDefaultGameModeAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.KickAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldSetDefaultGameModeAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.KickAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // string reason = 2 [json_name = "reason"]; + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_reason().empty()) { - const ::std::string& _s = this_._internal_reason(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.KickAction.reason"); - target = stream->WriteStringMaybeAliased(2, _s, target); + if (this_._internal_game_mode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_game_mode(), target); } } @@ -3360,18 +10026,18 @@ ::uint8_t* PROTOBUF_NONNULL KickAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.KickAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldSetDefaultGameModeAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t KickAction::ByteSizeLong(const MessageLite& base) { - const KickAction& this_ = static_cast(base); +::size_t WorldSetDefaultGameModeAction::ByteSizeLong(const MessageLite& base) { + const WorldSetDefaultGameModeAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t KickAction::ByteSizeLong() const { - const KickAction& this_ = *this; +::size_t WorldSetDefaultGameModeAction::ByteSizeLong() const { + const WorldSetDefaultGameModeAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.KickAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldSetDefaultGameModeAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -3381,18 +10047,16 @@ ::size_t KickAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // string reason = 2 [json_name = "reason"]; + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_reason().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_reason()); + if (this_._internal_game_mode() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_game_mode()); } } } @@ -3400,15 +10064,16 @@ ::size_t KickAction::ByteSizeLong() const { &this_._impl_._cached_size_); } -void KickAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldSetDefaultGameModeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.KickAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldSetDefaultGameModeAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -3416,21 +10081,16 @@ void KickAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_reason().empty()) { - _this->_internal_set_reason(from._internal_reason()); - } else { - if (_this->_impl_.reason_.IsDefault()) { - _this->_internal_set_reason(""); - } + if (from._internal_game_mode() != 0) { + _this->_impl_.game_mode_ = from._impl_.game_mode_; } } } @@ -3439,183 +10099,197 @@ void KickAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void KickAction::CopyFrom(const KickAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.KickAction) +void WorldSetDefaultGameModeAction::CopyFrom(const WorldSetDefaultGameModeAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldSetDefaultGameModeAction) if (&from == this) return; Clear(); MergeFrom(from); } -void KickAction::InternalSwap(KickAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldSetDefaultGameModeAction::InternalSwap(WorldSetDefaultGameModeAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.reason_, &other->_impl_.reason_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.game_mode_) + + sizeof(WorldSetDefaultGameModeAction::_impl_.game_mode_) + - PROTOBUF_FIELD_OFFSET(WorldSetDefaultGameModeAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata KickAction::GetMetadata() const { +::google::protobuf::Metadata WorldSetDefaultGameModeAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetGameModeAction::_Internal { +class WorldSetDifficultyAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_._has_bits_); }; -SetGameModeAction::SetGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldSetDifficultyAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +WorldSetDifficultyAction::WorldSetDifficultyAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetGameModeAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetDifficultyAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetGameModeAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldSetDifficultyAction) } -PROTOBUF_NDEBUG_INLINE SetGameModeAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetDifficultyAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetGameModeAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldSetDifficultyAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetGameModeAction::SetGameModeAction( +WorldSetDifficultyAction::WorldSetDifficultyAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetGameModeAction& from) + const WorldSetDifficultyAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetGameModeAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetDifficultyAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetGameModeAction* const _this = this; + WorldSetDifficultyAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - _impl_.game_mode_ = from._impl_.game_mode_; + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.difficulty_ = from._impl_.difficulty_; - // @@protoc_insertion_point(copy_constructor:df.plugin.SetGameModeAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldSetDifficultyAction) } -PROTOBUF_NDEBUG_INLINE SetGameModeAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetDifficultyAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetGameModeAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldSetDifficultyAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.game_mode_ = {}; + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, difficulty_) - + offsetof(Impl_, world_) + + sizeof(Impl_::difficulty_)); } -SetGameModeAction::~SetGameModeAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetGameModeAction) +WorldSetDifficultyAction::~WorldSetDifficultyAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldSetDifficultyAction) SharedDtor(*this); } -inline void SetGameModeAction::SharedDtor(MessageLite& self) { - SetGameModeAction& this_ = static_cast(self); +inline void WorldSetDifficultyAction::SharedDtor(MessageLite& self) { + WorldSetDifficultyAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetGameModeAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldSetDifficultyAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetGameModeAction(arena); + return ::new (mem) WorldSetDifficultyAction(arena); } -constexpr auto SetGameModeAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetGameModeAction), - alignof(SetGameModeAction)); +constexpr auto WorldSetDifficultyAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldSetDifficultyAction), + alignof(WorldSetDifficultyAction)); } -constexpr auto SetGameModeAction::InternalGenerateClassData_() { +constexpr auto WorldSetDifficultyAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetGameModeAction_default_instance_._instance, + &_WorldSetDifficultyAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetGameModeAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldSetDifficultyAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetGameModeAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetGameModeAction::ByteSizeLong, - &SetGameModeAction::_InternalSerialize, + &WorldSetDifficultyAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldSetDifficultyAction::ByteSizeLong, + &WorldSetDifficultyAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_._cached_size_), false, }, - &SetGameModeAction::kDescriptorMethods, + &WorldSetDifficultyAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetGameModeAction_class_data_ = - SetGameModeAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldSetDifficultyAction_class_data_ = + WorldSetDifficultyAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetGameModeAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetGameModeAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetGameModeAction_class_data_.tc_table); - return SetGameModeAction_class_data_.base(); +WorldSetDifficultyAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldSetDifficultyAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldSetDifficultyAction_class_data_.tc_table); + return WorldSetDifficultyAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 47, 2> -SetGameModeAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> +WorldSetDifficultyAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SetGameModeAction_class_data_.base(), + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldSetDifficultyAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetGameModeAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldSetDifficultyAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetGameModeAction, _impl_.game_mode_), 1>(), + // .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldSetDifficultyAction, _impl_.difficulty_), 1>(), {16, 1, 0, - PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.game_mode_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.difficulty_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; - {PROTOBUF_FIELD_OFFSET(SetGameModeAction, _impl_.game_mode_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + {PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.difficulty_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, }}, - // no aux_entries {{ - "\33\13\0\0\0\0\0\0" - "df.plugin.SetGameModeAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetGameModeAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetGameModeAction) +PROTOBUF_NOINLINE void WorldSetDifficultyAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldSetDifficultyAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -3623,48 +10297,46 @@ PROTOBUF_NOINLINE void SetGameModeAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } - _impl_.game_mode_ = 0; + _impl_.difficulty_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetGameModeAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetDifficultyAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetGameModeAction& this_ = static_cast(base); + const WorldSetDifficultyAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetGameModeAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetDifficultyAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetGameModeAction& this_ = *this; + const WorldSetDifficultyAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetGameModeAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldSetDifficultyAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetGameModeAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + // .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_game_mode() != 0) { + if (this_._internal_difficulty() != 0) { target = stream->EnsureSpace(target); target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this_._internal_game_mode(), target); + 2, this_._internal_difficulty(), target); } } @@ -3673,18 +10345,18 @@ ::uint8_t* PROTOBUF_NONNULL SetGameModeAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetGameModeAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldSetDifficultyAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetGameModeAction::ByteSizeLong(const MessageLite& base) { - const SetGameModeAction& this_ = static_cast(base); +::size_t WorldSetDifficultyAction::ByteSizeLong(const MessageLite& base) { + const WorldSetDifficultyAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetGameModeAction::ByteSizeLong() const { - const SetGameModeAction& this_ = *this; +::size_t WorldSetDifficultyAction::ByteSizeLong() const { + const WorldSetDifficultyAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetGameModeAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldSetDifficultyAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -3694,18 +10366,16 @@ ::size_t SetGameModeAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + // .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_game_mode() != 0) { + if (this_._internal_difficulty() != 0) { total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_game_mode()); + ::_pbi::WireFormatLite::EnumSize(this_._internal_difficulty()); } } } @@ -3713,15 +10383,16 @@ ::size_t SetGameModeAction::ByteSizeLong() const { &this_._impl_._cached_size_); } -void SetGameModeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldSetDifficultyAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetGameModeAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldSetDifficultyAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -3729,17 +10400,16 @@ void SetGameModeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_game_mode() != 0) { - _this->_impl_.game_mode_ = from._impl_.game_mode_; + if (from._internal_difficulty() != 0) { + _this->_impl_.difficulty_ = from._impl_.difficulty_; } } } @@ -3748,153 +10418,158 @@ void SetGameModeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetGameModeAction::CopyFrom(const SetGameModeAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetGameModeAction) +void WorldSetDifficultyAction::CopyFrom(const WorldSetDifficultyAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldSetDifficultyAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetGameModeAction::InternalSwap(SetGameModeAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldSetDifficultyAction::InternalSwap(WorldSetDifficultyAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - swap(_impl_.game_mode_, other->_impl_.game_mode_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.difficulty_) + + sizeof(WorldSetDifficultyAction::_impl_.difficulty_) + - PROTOBUF_FIELD_OFFSET(WorldSetDifficultyAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata SetGameModeAction::GetMetadata() const { +::google::protobuf::Metadata WorldSetDifficultyAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class GiveItemAction::_Internal { +class WorldSetTickRangeAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_._has_bits_); }; -void GiveItemAction::clear_item() { +void WorldSetTickRangeAction::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.item_ != nullptr) _impl_.item_->Clear(); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + 0x00000001U); } -GiveItemAction::GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldSetTickRangeAction::WorldSetTickRangeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, GiveItemAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetTickRangeAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.GiveItemAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldSetTickRangeAction) } -PROTOBUF_NDEBUG_INLINE GiveItemAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetTickRangeAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::GiveItemAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldSetTickRangeAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -GiveItemAction::GiveItemAction( +WorldSetTickRangeAction::WorldSetTickRangeAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const GiveItemAction& from) + const WorldSetTickRangeAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, GiveItemAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetTickRangeAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - GiveItemAction* const _this = this; + WorldSetTickRangeAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.item_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.item_) + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) : nullptr; + _impl_.tick_range_ = from._impl_.tick_range_; - // @@protoc_insertion_point(copy_constructor:df.plugin.GiveItemAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldSetTickRangeAction) } -PROTOBUF_NDEBUG_INLINE GiveItemAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetTickRangeAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void GiveItemAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldSetTickRangeAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.item_ = {}; + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, tick_range_) - + offsetof(Impl_, world_) + + sizeof(Impl_::tick_range_)); } -GiveItemAction::~GiveItemAction() { - // @@protoc_insertion_point(destructor:df.plugin.GiveItemAction) +WorldSetTickRangeAction::~WorldSetTickRangeAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldSetTickRangeAction) SharedDtor(*this); } -inline void GiveItemAction::SharedDtor(MessageLite& self) { - GiveItemAction& this_ = static_cast(self); +inline void WorldSetTickRangeAction::SharedDtor(MessageLite& self) { + WorldSetTickRangeAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - delete this_._impl_.item_; + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL GiveItemAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldSetTickRangeAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) GiveItemAction(arena); + return ::new (mem) WorldSetTickRangeAction(arena); } -constexpr auto GiveItemAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(GiveItemAction), - alignof(GiveItemAction)); +constexpr auto WorldSetTickRangeAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldSetTickRangeAction), + alignof(WorldSetTickRangeAction)); } -constexpr auto GiveItemAction::InternalGenerateClassData_() { +constexpr auto WorldSetTickRangeAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_GiveItemAction_default_instance_._instance, + &_WorldSetTickRangeAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &GiveItemAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldSetTickRangeAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &GiveItemAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &GiveItemAction::ByteSizeLong, - &GiveItemAction::_InternalSerialize, + &WorldSetTickRangeAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldSetTickRangeAction::ByteSizeLong, + &WorldSetTickRangeAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_._cached_size_), false, }, - &GiveItemAction::kDescriptorMethods, + &WorldSetTickRangeAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull GiveItemAction_class_data_ = - GiveItemAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldSetTickRangeAction_class_data_ = + WorldSetTickRangeAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -GiveItemAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&GiveItemAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(GiveItemAction_class_data_.tc_table); - return GiveItemAction_class_data_.base(); +WorldSetTickRangeAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldSetTickRangeAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldSetTickRangeAction_class_data_.tc_table); + return WorldSetTickRangeAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 1, 44, 2> -GiveItemAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 1, 0, 2> +WorldSetTickRangeAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), @@ -3903,93 +10578,85 @@ GiveItemAction::_table_ = { 2, // num_field_entries 1, // num_aux_entries offsetof(decltype(_table_), aux_entries), - GiveItemAction_class_data_.base(), + WorldSetTickRangeAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::GiveItemAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldSetTickRangeAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // .df.plugin.ItemStack item = 2 [json_name = "item"]; + // int32 tick_range = 2 [json_name = "tickRange"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldSetTickRangeAction, _impl_.tick_range_), 1>(), + {16, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.tick_range_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.item_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.ItemStack item = 2 [json_name = "item"]; - {PROTOBUF_FIELD_OFFSET(GiveItemAction, _impl_.item_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // int32 tick_range = 2 [json_name = "tickRange"]; + {PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.tick_range_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, }}, {{ - {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, }}, {{ - "\30\13\0\0\0\0\0\0" - "df.plugin.GiveItemAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void GiveItemAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.GiveItemAction) +PROTOBUF_NOINLINE void WorldSetTickRangeAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldSetTickRangeAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.item_ != nullptr); - _impl_.item_->Clear(); - } + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } + _impl_.tick_range_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL GiveItemAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetTickRangeAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const GiveItemAction& this_ = static_cast(base); + const WorldSetTickRangeAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL GiveItemAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetTickRangeAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const GiveItemAction& this_ = *this; + const WorldSetTickRangeAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.GiveItemAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldSetTickRangeAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.GiveItemAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // .df.plugin.ItemStack item = 2 [json_name = "item"]; + // int32 tick_range = 2 [json_name = "tickRange"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.item_, this_._impl_.item_->GetCachedSize(), target, - stream); + if (this_._internal_tick_range() != 0) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>( + stream, this_._internal_tick_range(), target); + } } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -3997,18 +10664,18 @@ ::uint8_t* PROTOBUF_NONNULL GiveItemAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.GiveItemAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldSetTickRangeAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t GiveItemAction::ByteSizeLong(const MessageLite& base) { - const GiveItemAction& this_ = static_cast(base); +::size_t WorldSetTickRangeAction::ByteSizeLong(const MessageLite& base) { + const WorldSetTickRangeAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t GiveItemAction::ByteSizeLong() const { - const GiveItemAction& this_ = *this; +::size_t WorldSetTickRangeAction::ByteSizeLong() const { + const WorldSetTickRangeAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.GiveItemAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldSetTickRangeAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -4018,33 +10685,33 @@ ::size_t GiveItemAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.ItemStack item = 2 [json_name = "item"]; + // int32 tick_range = 2 [json_name = "tickRange"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.item_); + if (this_._internal_tick_range() != 0) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_tick_range()); + } } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void GiveItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldSetTickRangeAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.GiveItemAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldSetTickRangeAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -4052,20 +10719,16 @@ void GiveItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.item_ != nullptr); - if (_this->_impl_.item_ == nullptr) { - _this->_impl_.item_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.item_); - } else { - _this->_impl_.item_->MergeFrom(*from._impl_.item_); + if (from._internal_tick_range() != 0) { + _this->_impl_.tick_range_ = from._impl_.tick_range_; } } } @@ -4074,215 +10737,287 @@ void GiveItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void GiveItemAction::CopyFrom(const GiveItemAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.GiveItemAction) +void WorldSetTickRangeAction::CopyFrom(const WorldSetTickRangeAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldSetTickRangeAction) if (&from == this) return; Clear(); MergeFrom(from); } -void GiveItemAction::InternalSwap(GiveItemAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldSetTickRangeAction::InternalSwap(WorldSetTickRangeAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - swap(_impl_.item_, other->_impl_.item_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.tick_range_) + + sizeof(WorldSetTickRangeAction::_impl_.tick_range_) + - PROTOBUF_FIELD_OFFSET(WorldSetTickRangeAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata GiveItemAction::GetMetadata() const { +::google::protobuf::Metadata WorldSetTickRangeAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class ClearInventoryAction::_Internal { +class WorldSetBlockAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_._has_bits_); }; -ClearInventoryAction::ClearInventoryAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldSetBlockAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +void WorldSetBlockAction::clear_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldSetBlockAction::clear_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.block_ != nullptr) _impl_.block_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +WorldSetBlockAction::WorldSetBlockAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ClearInventoryAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetBlockAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.ClearInventoryAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldSetBlockAction) } -PROTOBUF_NDEBUG_INLINE ClearInventoryAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetBlockAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::ClearInventoryAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldSetBlockAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -ClearInventoryAction::ClearInventoryAction( +WorldSetBlockAction::WorldSetBlockAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const ClearInventoryAction& from) + const WorldSetBlockAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ClearInventoryAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldSetBlockAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - ClearInventoryAction* const _this = this; + WorldSetBlockAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) + : nullptr; + _impl_.block_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.block_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.ClearInventoryAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldSetBlockAction) } -PROTOBUF_NDEBUG_INLINE ClearInventoryAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldSetBlockAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void ClearInventoryAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldSetBlockAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, block_) - + offsetof(Impl_, world_) + + sizeof(Impl_::block_)); } -ClearInventoryAction::~ClearInventoryAction() { - // @@protoc_insertion_point(destructor:df.plugin.ClearInventoryAction) +WorldSetBlockAction::~WorldSetBlockAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldSetBlockAction) SharedDtor(*this); } -inline void ClearInventoryAction::SharedDtor(MessageLite& self) { - ClearInventoryAction& this_ = static_cast(self); +inline void WorldSetBlockAction::SharedDtor(MessageLite& self) { + WorldSetBlockAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; + delete this_._impl_.position_; + delete this_._impl_.block_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL ClearInventoryAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldSetBlockAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) ClearInventoryAction(arena); + return ::new (mem) WorldSetBlockAction(arena); } -constexpr auto ClearInventoryAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ClearInventoryAction), - alignof(ClearInventoryAction)); +constexpr auto WorldSetBlockAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldSetBlockAction), + alignof(WorldSetBlockAction)); } -constexpr auto ClearInventoryAction::InternalGenerateClassData_() { +constexpr auto WorldSetBlockAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_ClearInventoryAction_default_instance_._instance, + &_WorldSetBlockAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &ClearInventoryAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldSetBlockAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &ClearInventoryAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &ClearInventoryAction::ByteSizeLong, - &ClearInventoryAction::_InternalSerialize, + &WorldSetBlockAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldSetBlockAction::ByteSizeLong, + &WorldSetBlockAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_._cached_size_), false, }, - &ClearInventoryAction::kDescriptorMethods, + &WorldSetBlockAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull ClearInventoryAction_class_data_ = - ClearInventoryAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldSetBlockAction_class_data_ = + WorldSetBlockAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -ClearInventoryAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&ClearInventoryAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(ClearInventoryAction_class_data_.tc_table); - return ClearInventoryAction_class_data_.base(); +WorldSetBlockAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldSetBlockAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldSetBlockAction_class_data_.tc_table); + return WorldSetBlockAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 50, 2> -ClearInventoryAction::_table_ = { +const ::_pbi::TcParseTable<2, 3, 3, 0, 2> +WorldSetBlockAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_._has_bits_), 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask + 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap + 4294967288, // skipmap offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - ClearInventoryAction_class_data_.base(), + 3, // num_field_entries + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldSetBlockAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::ClearInventoryAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldSetBlockAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + {::_pbi::TcParser::MiniParse, {}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.world_)}}, + // .df.plugin.BlockPos position = 2 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.position_)}}, + // optional .df.plugin.BlockState block = 3 [json_name = "block"]; + {::_pbi::TcParser::FastMtS1, + {26, 2, 2, + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.block_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(ClearInventoryAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.BlockPos position = 2 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional .df.plugin.BlockState block = 3 [json_name = "block"]; + {PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.block_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BlockPos>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BlockState>()}, }}, - // no aux_entries {{ - "\36\13\0\0\0\0\0\0" - "df.plugin.ClearInventoryAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void ClearInventoryAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.ClearInventoryAction) +PROTOBUF_NOINLINE void WorldSetBlockAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldSetBlockAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.block_ != nullptr); + _impl_.block_->Clear(); + } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL ClearInventoryAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetBlockAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const ClearInventoryAction& this_ = static_cast(base); + const WorldSetBlockAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL ClearInventoryAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldSetBlockAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const ClearInventoryAction& this_ = *this; + const WorldSetBlockAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ClearInventoryAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldSetBlockAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ClearInventoryAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); + } + + // .df.plugin.BlockPos position = 2 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); + } + + // optional .df.plugin.BlockState block = 3 [json_name = "block"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.block_, this_._impl_.block_->GetCachedSize(), target, + stream); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -4290,58 +11025,85 @@ ::uint8_t* PROTOBUF_NONNULL ClearInventoryAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ClearInventoryAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldSetBlockAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t ClearInventoryAction::ByteSizeLong(const MessageLite& base) { - const ClearInventoryAction& this_ = static_cast(base); +::size_t WorldSetBlockAction::ByteSizeLong(const MessageLite& base) { + const WorldSetBlockAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t ClearInventoryAction::ByteSizeLong() const { - const ClearInventoryAction& this_ = *this; +::size_t WorldSetBlockAction::ByteSizeLong() const { + const WorldSetBlockAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.ClearInventoryAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldSetBlockAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - { - // string player_uuid = 1 [json_name = "playerUuid"]; - cached_has_bits = this_._impl_._has_bits_[0]; + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); + } + // .df.plugin.BlockPos position = 2 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + } + // optional .df.plugin.BlockState block = 3 [json_name = "block"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.block_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void ClearInventoryAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldSetBlockAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ClearInventoryAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldSetBlockAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); + } else { + _this->_impl_.world_->MergeFrom(*from._impl_.world_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); + } else { + _this->_impl_.position_->MergeFrom(*from._impl_.position_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(from._impl_.block_ != nullptr); + if (_this->_impl_.block_ == nullptr) { + _this->_impl_.block_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.block_); + } else { + _this->_impl_.block_->MergeFrom(*from._impl_.block_); } } } @@ -4350,167 +11112,168 @@ void ClearInventoryAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void ClearInventoryAction::CopyFrom(const ClearInventoryAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ClearInventoryAction) +void WorldSetBlockAction::CopyFrom(const WorldSetBlockAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldSetBlockAction) if (&from == this) return; Clear(); MergeFrom(from); } -void ClearInventoryAction::InternalSwap(ClearInventoryAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldSetBlockAction::InternalSwap(WorldSetBlockAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.block_) + + sizeof(WorldSetBlockAction::_impl_.block_) + - PROTOBUF_FIELD_OFFSET(WorldSetBlockAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata ClearInventoryAction::GetMetadata() const { +::google::protobuf::Metadata WorldSetBlockAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetHeldItemAction::_Internal { +class WorldPlaySoundAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_._has_bits_); }; -void SetHeldItemAction::clear_main() { +void WorldPlaySoundAction::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.main_ != nullptr) _impl_.main_->Clear(); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + 0x00000001U); } -void SetHeldItemAction::clear_offhand() { +void WorldPlaySoundAction::clear_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.offhand_ != nullptr) _impl_.offhand_->Clear(); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); + 0x00000002U); } -SetHeldItemAction::SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldPlaySoundAction::WorldPlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetHeldItemAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlaySoundAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldPlaySoundAction) } -PROTOBUF_NDEBUG_INLINE SetHeldItemAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlaySoundAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetHeldItemAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldPlaySoundAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetHeldItemAction::SetHeldItemAction( +WorldPlaySoundAction::WorldPlaySoundAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetHeldItemAction& from) + const WorldPlaySoundAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetHeldItemAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlaySoundAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetHeldItemAction* const _this = this; + WorldPlaySoundAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.main_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.main_) + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) : nullptr; - _impl_.offhand_ = (CheckHasBit(cached_has_bits, 0x00000004U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.offhand_) + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) : nullptr; + _impl_.sound_ = from._impl_.sound_; - // @@protoc_insertion_point(copy_constructor:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldPlaySoundAction) } -PROTOBUF_NDEBUG_INLINE SetHeldItemAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlaySoundAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetHeldItemAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldPlaySoundAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, main_), + offsetof(Impl_, world_), 0, - offsetof(Impl_, offhand_) - - offsetof(Impl_, main_) + - sizeof(Impl_::offhand_)); + offsetof(Impl_, sound_) - + offsetof(Impl_, world_) + + sizeof(Impl_::sound_)); } -SetHeldItemAction::~SetHeldItemAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetHeldItemAction) +WorldPlaySoundAction::~WorldPlaySoundAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldPlaySoundAction) SharedDtor(*this); } -inline void SetHeldItemAction::SharedDtor(MessageLite& self) { - SetHeldItemAction& this_ = static_cast(self); +inline void WorldPlaySoundAction::SharedDtor(MessageLite& self) { + WorldPlaySoundAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - delete this_._impl_.main_; - delete this_._impl_.offhand_; + delete this_._impl_.world_; + delete this_._impl_.position_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetHeldItemAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldPlaySoundAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetHeldItemAction(arena); + return ::new (mem) WorldPlaySoundAction(arena); } -constexpr auto SetHeldItemAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetHeldItemAction), - alignof(SetHeldItemAction)); +constexpr auto WorldPlaySoundAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldPlaySoundAction), + alignof(WorldPlaySoundAction)); } -constexpr auto SetHeldItemAction::InternalGenerateClassData_() { +constexpr auto WorldPlaySoundAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetHeldItemAction_default_instance_._instance, + &_WorldPlaySoundAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetHeldItemAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldPlaySoundAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetHeldItemAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetHeldItemAction::ByteSizeLong, - &SetHeldItemAction::_InternalSerialize, + &WorldPlaySoundAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldPlaySoundAction::ByteSizeLong, + &WorldPlaySoundAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_._cached_size_), false, }, - &SetHeldItemAction::kDescriptorMethods, + &WorldPlaySoundAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetHeldItemAction_class_data_ = - SetHeldItemAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldPlaySoundAction_class_data_ = + WorldPlaySoundAction::InternalGenerateClassData_(); -PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetHeldItemAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetHeldItemAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetHeldItemAction_class_data_.tc_table); - return SetHeldItemAction_class_data_.base(); +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +WorldPlaySoundAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldPlaySoundAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldPlaySoundAction_class_data_.tc_table); + return WorldPlaySoundAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 2, 47, 2> -SetHeldItemAction::_table_ = { +const ::_pbi::TcParseTable<2, 3, 2, 0, 2> +WorldPlaySoundAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_._has_bits_), 0, // no _extensions_ 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), @@ -4519,111 +11282,105 @@ SetHeldItemAction::_table_ = { 3, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), - SetHeldItemAction_class_data_.base(), + WorldPlaySoundAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetHeldItemAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldPlaySoundAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.player_uuid_)}}, - // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_)}}, - // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.world_)}}, + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldPlaySoundAction, _impl_.sound_), 2>(), + {16, 2, 0, + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.sound_)}}, + // .df.plugin.Vec3 position = 3 [json_name = "position"]; {::_pbi::TcParser::FastMtS1, - {26, 2, 1, - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_)}}, + {26, 1, 1, + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.position_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; - {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; - {PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + {PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.sound_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // .df.plugin.Vec3 position = 3 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ - {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, - {::_pbi::TcParser::GetTable<::df::plugin::ItemStack>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, }}, {{ - "\33\13\0\0\0\0\0\0" - "df.plugin.SetHeldItemAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetHeldItemAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetHeldItemAction) +PROTOBUF_NOINLINE void WorldPlaySoundAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldPlaySoundAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.main_ != nullptr); - _impl_.main_->Clear(); - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(_impl_.offhand_ != nullptr); - _impl_.offhand_->Clear(); + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); } } + _impl_.sound_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetHeldItemAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlaySoundAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetHeldItemAction& this_ = static_cast(base); + const WorldPlaySoundAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetHeldItemAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlaySoundAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetHeldItemAction& this_ = *this; + const WorldPlaySoundAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldPlaySoundAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetHeldItemAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } - } - - // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.main_, this_._impl_.main_->GetCachedSize(), target, + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, stream); } - // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + // .df.plugin.Sound sound = 2 [json_name = "sound"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { + if (this_._internal_sound() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 2, this_._internal_sound(), target); + } + } + + // .df.plugin.Vec3 position = 3 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, *this_._impl_.offhand_, this_._impl_.offhand_->GetCachedSize(), target, + 3, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, stream); } @@ -4632,18 +11389,18 @@ ::uint8_t* PROTOBUF_NONNULL SetHeldItemAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldPlaySoundAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetHeldItemAction::ByteSizeLong(const MessageLite& base) { - const SetHeldItemAction& this_ = static_cast(base); +::size_t WorldPlaySoundAction::ByteSizeLong(const MessageLite& base) { + const WorldPlaySoundAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetHeldItemAction::ByteSizeLong() const { - const SetHeldItemAction& this_ = *this; +::size_t WorldPlaySoundAction::ByteSizeLong() const { + const WorldPlaySoundAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldPlaySoundAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -4653,38 +11410,38 @@ ::size_t SetHeldItemAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + // .df.plugin.Vec3 position = 3 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.main_); + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); } - // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + // .df.plugin.Sound sound = 2 [json_name = "sound"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.offhand_); + if (this_._internal_sound() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_sound()); + } } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SetHeldItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldPlaySoundAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldPlaySoundAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -4692,28 +11449,24 @@ void SetHeldItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.main_ != nullptr); - if (_this->_impl_.main_ == nullptr) { - _this->_impl_.main_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.main_); + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); } else { - _this->_impl_.main_->MergeFrom(*from._impl_.main_); + _this->_impl_.position_->MergeFrom(*from._impl_.position_); } } if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(from._impl_.offhand_ != nullptr); - if (_this->_impl_.offhand_ == nullptr) { - _this->_impl_.offhand_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.offhand_); - } else { - _this->_impl_.offhand_->MergeFrom(*from._impl_.offhand_); + if (from._internal_sound() != 0) { + _this->_impl_.sound_ = from._impl_.sound_; } } } @@ -4722,267 +11475,329 @@ void SetHeldItemAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetHeldItemAction::CopyFrom(const SetHeldItemAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetHeldItemAction) +void WorldPlaySoundAction::CopyFrom(const WorldPlaySoundAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldPlaySoundAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetHeldItemAction::InternalSwap(SetHeldItemAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldPlaySoundAction::InternalSwap(WorldPlaySoundAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.offhand_) - + sizeof(SetHeldItemAction::_impl_.offhand_) - - PROTOBUF_FIELD_OFFSET(SetHeldItemAction, _impl_.main_)>( - reinterpret_cast(&_impl_.main_), - reinterpret_cast(&other->_impl_.main_)); + PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.sound_) + + sizeof(WorldPlaySoundAction::_impl_.sound_) + - PROTOBUF_FIELD_OFFSET(WorldPlaySoundAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata SetHeldItemAction::GetMetadata() const { +::google::protobuf::Metadata WorldPlaySoundAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetHealthAction::_Internal { +class WorldAddParticleAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_._has_bits_); }; -SetHealthAction::SetHealthAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldAddParticleAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +void WorldAddParticleAction::clear_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldAddParticleAction::clear_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.block_ != nullptr) _impl_.block_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +WorldAddParticleAction::WorldAddParticleAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetHealthAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldAddParticleAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetHealthAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldAddParticleAction) } -PROTOBUF_NDEBUG_INLINE SetHealthAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldAddParticleAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetHealthAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldAddParticleAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetHealthAction::SetHealthAction( +WorldAddParticleAction::WorldAddParticleAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetHealthAction& from) + const WorldAddParticleAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetHealthAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldAddParticleAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetHealthAction* const _this = this; + WorldAddParticleAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) + : nullptr; + _impl_.block_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.block_) + : nullptr; ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, health_), + offsetof(Impl_, particle_), reinterpret_cast(&from._impl_) + - offsetof(Impl_, health_), - offsetof(Impl_, max_health_) - - offsetof(Impl_, health_) + - sizeof(Impl_::max_health_)); + offsetof(Impl_, particle_), + offsetof(Impl_, face_) - + offsetof(Impl_, particle_) + + sizeof(Impl_::face_)); - // @@protoc_insertion_point(copy_constructor:df.plugin.SetHealthAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldAddParticleAction) } -PROTOBUF_NDEBUG_INLINE SetHealthAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldAddParticleAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetHealthAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldAddParticleAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, health_), + offsetof(Impl_, world_), 0, - offsetof(Impl_, max_health_) - - offsetof(Impl_, health_) + - sizeof(Impl_::max_health_)); + offsetof(Impl_, face_) - + offsetof(Impl_, world_) + + sizeof(Impl_::face_)); } -SetHealthAction::~SetHealthAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetHealthAction) +WorldAddParticleAction::~WorldAddParticleAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldAddParticleAction) SharedDtor(*this); } -inline void SetHealthAction::SharedDtor(MessageLite& self) { - SetHealthAction& this_ = static_cast(self); +inline void WorldAddParticleAction::SharedDtor(MessageLite& self) { + WorldAddParticleAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; + delete this_._impl_.position_; + delete this_._impl_.block_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetHealthAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldAddParticleAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetHealthAction(arena); + return ::new (mem) WorldAddParticleAction(arena); } -constexpr auto SetHealthAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetHealthAction), - alignof(SetHealthAction)); +constexpr auto WorldAddParticleAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldAddParticleAction), + alignof(WorldAddParticleAction)); } -constexpr auto SetHealthAction::InternalGenerateClassData_() { +constexpr auto WorldAddParticleAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetHealthAction_default_instance_._instance, + &_WorldAddParticleAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetHealthAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldAddParticleAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetHealthAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetHealthAction::ByteSizeLong, - &SetHealthAction::_InternalSerialize, + &WorldAddParticleAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldAddParticleAction::ByteSizeLong, + &WorldAddParticleAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_._cached_size_), false, }, - &SetHealthAction::kDescriptorMethods, + &WorldAddParticleAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetHealthAction_class_data_ = - SetHealthAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldAddParticleAction_class_data_ = + WorldAddParticleAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetHealthAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetHealthAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetHealthAction_class_data_.tc_table); - return SetHealthAction_class_data_.base(); +WorldAddParticleAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldAddParticleAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldAddParticleAction_class_data_.tc_table); + return WorldAddParticleAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 0, 45, 2> -SetHealthAction::_table_ = { +const ::_pbi::TcParseTable<3, 5, 3, 0, 2> +WorldAddParticleAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_._has_bits_), 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask + 5, 56, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap + 4294967264, // skipmap offsetof(decltype(_table_), field_entries), - 3, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SetHealthAction_class_data_.base(), + 5, // num_field_entries + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldAddParticleAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetHealthAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldAddParticleAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.player_uuid_)}}, - // double health = 2 [json_name = "health"]; - {::_pbi::TcParser::FastF64S1, - {17, 1, 0, - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_)}}, - // optional double max_health = 3 [json_name = "maxHealth"]; - {::_pbi::TcParser::FastF64S1, - {25, 2, 0, - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_)}}, + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.world_)}}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.position_)}}, + // .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldAddParticleAction, _impl_.particle_), 3>(), + {24, 3, 0, + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.particle_)}}, + // optional .df.plugin.BlockState block = 4 [json_name = "block"]; + {::_pbi::TcParser::FastMtS1, + {34, 2, 2, + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.block_)}}, + // optional int32 face = 5 [json_name = "face"]; + {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(WorldAddParticleAction, _impl_.face_), 4>(), + {40, 4, 0, + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.face_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // double health = 2 [json_name = "health"]; - {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, - // optional double max_health = 3 [json_name = "maxHealth"]; - {PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kDouble)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + {PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.particle_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // optional .df.plugin.BlockState block = 4 [json_name = "block"]; + {PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.block_), _Internal::kHasBitsOffset + 2, 2, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // optional int32 face = 5 [json_name = "face"]; + {PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.face_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BlockState>()}, }}, - // no aux_entries {{ - "\31\13\0\0\0\0\0\0" - "df.plugin.SetHealthAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetHealthAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetHealthAction) +PROTOBUF_NOINLINE void WorldAddParticleAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldAddParticleAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.block_ != nullptr); + _impl_.block_->Clear(); + } } - if (BatchCheckHasBit(cached_has_bits, 0x00000006U)) { - ::memset(&_impl_.health_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.max_health_) - - reinterpret_cast(&_impl_.health_)) + sizeof(_impl_.max_health_)); + if (BatchCheckHasBit(cached_has_bits, 0x00000018U)) { + ::memset(&_impl_.particle_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.face_) - + reinterpret_cast(&_impl_.particle_)) + sizeof(_impl_.face_)); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetHealthAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldAddParticleAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetHealthAction& this_ = static_cast(base); + const WorldAddParticleAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetHealthAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldAddParticleAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetHealthAction& this_ = *this; + const WorldAddParticleAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetHealthAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldAddParticleAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetHealthAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // double health = 2 [json_name = "health"]; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (::absl::bit_cast<::uint64_t>(this_._internal_health()) != 0) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); + } + + // .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_particle() != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray( - 2, this_._internal_health(), target); + target = ::_pbi::WireFormatLite::WriteEnumToArray( + 3, this_._internal_particle(), target); } } - // optional double max_health = 3 [json_name = "maxHealth"]; + // optional .df.plugin.BlockState block = 4 [json_name = "block"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteDoubleToArray( - 3, this_._internal_max_health(), target); + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.block_, this_._impl_.block_->GetCachedSize(), target, + stream); + } + + // optional int32 face = 5 [json_name = "face"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + target = + ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<5>( + stream, this_._internal_face(), target); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -4990,18 +11805,18 @@ ::uint8_t* PROTOBUF_NONNULL SetHealthAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetHealthAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldAddParticleAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetHealthAction::ByteSizeLong(const MessageLite& base) { - const SetHealthAction& this_ = static_cast(base); +::size_t WorldAddParticleAction::ByteSizeLong(const MessageLite& base) { + const WorldAddParticleAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetHealthAction::ByteSizeLong() const { - const SetHealthAction& this_ = *this; +::size_t WorldAddParticleAction::ByteSizeLong() const { + const WorldAddParticleAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetHealthAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldAddParticleAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -5010,57 +11825,86 @@ ::size_t SetHealthAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - total_size += static_cast(0x00000004U & cached_has_bits) * 9; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // double health = 2 [json_name = "health"]; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (::absl::bit_cast<::uint64_t>(this_._internal_health()) != 0) { - total_size += 9; + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + } + // optional .df.plugin.BlockState block = 4 [json_name = "block"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.block_); + } + // .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (this_._internal_particle() != 0) { + total_size += 1 + + ::_pbi::WireFormatLite::EnumSize(this_._internal_particle()); } } + // optional int32 face = 5 [json_name = "face"]; + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( + this_._internal_face()); + } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SetHealthAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldAddParticleAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetHealthAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldAddParticleAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (::absl::bit_cast<::uint64_t>(from._internal_health()) != 0) { - _this->_impl_.health_ = from._impl_.health_; + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); + } else { + _this->_impl_.position_->MergeFrom(*from._impl_.position_); } } if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _this->_impl_.max_health_ = from._impl_.max_health_; + ABSL_DCHECK(from._impl_.block_ != nullptr); + if (_this->_impl_.block_ == nullptr) { + _this->_impl_.block_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.block_); + } else { + _this->_impl_.block_->MergeFrom(*from._impl_.block_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000008U)) { + if (from._internal_particle() != 0) { + _this->_impl_.particle_ = from._impl_.particle_; + } + } + if (CheckHasBit(cached_has_bits, 0x00000010U)) { + _this->_impl_.face_ = from._impl_.face_; } } _this->_impl_._has_bits_[0] |= cached_has_bits; @@ -5068,188 +11912,185 @@ void SetHealthAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetHealthAction::CopyFrom(const SetHealthAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetHealthAction) +void WorldAddParticleAction::CopyFrom(const WorldAddParticleAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldAddParticleAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetHealthAction::InternalSwap(SetHealthAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldAddParticleAction::InternalSwap(WorldAddParticleAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.max_health_) - + sizeof(SetHealthAction::_impl_.max_health_) - - PROTOBUF_FIELD_OFFSET(SetHealthAction, _impl_.health_)>( - reinterpret_cast(&_impl_.health_), - reinterpret_cast(&other->_impl_.health_)); + PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.face_) + + sizeof(WorldAddParticleAction::_impl_.face_) + - PROTOBUF_FIELD_OFFSET(WorldAddParticleAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata SetHealthAction::GetMetadata() const { +::google::protobuf::Metadata WorldAddParticleAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetFoodAction::_Internal { +class WorldQueryEntitiesAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesAction, _impl_._has_bits_); }; -SetFoodAction::SetFoodAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldQueryEntitiesAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +WorldQueryEntitiesAction::WorldQueryEntitiesAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetFoodAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryEntitiesAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetFoodAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldQueryEntitiesAction) } -PROTOBUF_NDEBUG_INLINE SetFoodAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryEntitiesAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetFoodAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldQueryEntitiesAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetFoodAction::SetFoodAction( +WorldQueryEntitiesAction::WorldQueryEntitiesAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetFoodAction& from) + const WorldQueryEntitiesAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetFoodAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryEntitiesAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetFoodAction* const _this = this; + WorldQueryEntitiesAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - _impl_.food_ = from._impl_.food_; + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SetFoodAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldQueryEntitiesAction) } -PROTOBUF_NDEBUG_INLINE SetFoodAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryEntitiesAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetFoodAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldQueryEntitiesAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.food_ = {}; + _impl_.world_ = {}; } -SetFoodAction::~SetFoodAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetFoodAction) +WorldQueryEntitiesAction::~WorldQueryEntitiesAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldQueryEntitiesAction) SharedDtor(*this); } -inline void SetFoodAction::SharedDtor(MessageLite& self) { - SetFoodAction& this_ = static_cast(self); +inline void WorldQueryEntitiesAction::SharedDtor(MessageLite& self) { + WorldQueryEntitiesAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetFoodAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldQueryEntitiesAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetFoodAction(arena); + return ::new (mem) WorldQueryEntitiesAction(arena); } -constexpr auto SetFoodAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetFoodAction), - alignof(SetFoodAction)); +constexpr auto WorldQueryEntitiesAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldQueryEntitiesAction), + alignof(WorldQueryEntitiesAction)); } -constexpr auto SetFoodAction::InternalGenerateClassData_() { +constexpr auto WorldQueryEntitiesAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetFoodAction_default_instance_._instance, + &_WorldQueryEntitiesAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetFoodAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldQueryEntitiesAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetFoodAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetFoodAction::ByteSizeLong, - &SetFoodAction::_InternalSerialize, + &WorldQueryEntitiesAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldQueryEntitiesAction::ByteSizeLong, + &WorldQueryEntitiesAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesAction, _impl_._cached_size_), false, }, - &SetFoodAction::kDescriptorMethods, + &WorldQueryEntitiesAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetFoodAction_class_data_ = - SetFoodAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesAction_class_data_ = + WorldQueryEntitiesAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetFoodAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetFoodAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetFoodAction_class_data_.tc_table); - return SetFoodAction_class_data_.base(); +WorldQueryEntitiesAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldQueryEntitiesAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldQueryEntitiesAction_class_data_.tc_table); + return WorldQueryEntitiesAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 43, 2> -SetFoodAction::_table_ = { +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +WorldQueryEntitiesAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesAction, _impl_._has_bits_), 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask + 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap + 4294967294, // skipmap offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SetFoodAction_class_data_.base(), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldQueryEntitiesAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetFoodAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // int32 food = 2 [json_name = "food"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetFoodAction, _impl_.food_), 1>(), - {16, 1, 0, - PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.food_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // int32 food = 2 [json_name = "food"]; - {PROTOBUF_FIELD_OFFSET(SetFoodAction, _impl_.food_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, }}, - // no aux_entries {{ - "\27\13\0\0\0\0\0\0" - "df.plugin.SetFoodAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetFoodAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetFoodAction) +PROTOBUF_NOINLINE void WorldQueryEntitiesAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldQueryEntitiesAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -5257,49 +12098,37 @@ PROTOBUF_NOINLINE void SetFoodAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } - _impl_.food_ = 0; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetFoodAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryEntitiesAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetFoodAction& this_ = static_cast(base); + const WorldQueryEntitiesAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetFoodAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryEntitiesAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetFoodAction& this_ = *this; + const WorldQueryEntitiesAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetFoodAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldQueryEntitiesAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetFoodAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } - } - - // int32 food = 2 [json_name = "food"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_food() != 0) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>( - stream, this_._internal_food(), target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -5307,74 +12136,57 @@ ::uint8_t* PROTOBUF_NONNULL SetFoodAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetFoodAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldQueryEntitiesAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetFoodAction::ByteSizeLong(const MessageLite& base) { - const SetFoodAction& this_ = static_cast(base); +::size_t WorldQueryEntitiesAction::ByteSizeLong(const MessageLite& base) { + const WorldQueryEntitiesAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetFoodAction::ByteSizeLong() const { - const SetFoodAction& this_ = *this; +::size_t WorldQueryEntitiesAction::ByteSizeLong() const { + const WorldQueryEntitiesAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetFoodAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldQueryEntitiesAction) ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } - } - // int32 food = 2 [json_name = "food"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_food() != 0) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this_._internal_food()); - } + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + cached_has_bits = this_._impl_._has_bits_[0]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SetFoodAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldQueryEntitiesAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetFoodAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldQueryEntitiesAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } - } - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_food() != 0) { - _this->_impl_.food_ = from._impl_.food_; - } + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); + } else { + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; @@ -5382,206 +12194,180 @@ void SetFoodAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetFoodAction::CopyFrom(const SetFoodAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetFoodAction) +void WorldQueryEntitiesAction::CopyFrom(const WorldQueryEntitiesAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldQueryEntitiesAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetFoodAction::InternalSwap(SetFoodAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldQueryEntitiesAction::InternalSwap(WorldQueryEntitiesAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - swap(_impl_.food_, other->_impl_.food_); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata SetFoodAction::GetMetadata() const { +::google::protobuf::Metadata WorldQueryEntitiesAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetExperienceAction::_Internal { +class WorldQueryPlayersAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldQueryPlayersAction, _impl_._has_bits_); }; -SetExperienceAction::SetExperienceAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldQueryPlayersAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +WorldQueryPlayersAction::WorldQueryPlayersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetExperienceAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryPlayersAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetExperienceAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldQueryPlayersAction) } -PROTOBUF_NDEBUG_INLINE SetExperienceAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryPlayersAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetExperienceAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldQueryPlayersAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetExperienceAction::SetExperienceAction( +WorldQueryPlayersAction::WorldQueryPlayersAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetExperienceAction& from) + const WorldQueryPlayersAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetExperienceAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryPlayersAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetExperienceAction* const _this = this; + WorldQueryPlayersAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, level_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, level_), - offsetof(Impl_, amount_) - - offsetof(Impl_, level_) + - sizeof(Impl_::amount_)); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SetExperienceAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldQueryPlayersAction) } -PROTOBUF_NDEBUG_INLINE SetExperienceAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryPlayersAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetExperienceAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldQueryPlayersAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, level_), - 0, - offsetof(Impl_, amount_) - - offsetof(Impl_, level_) + - sizeof(Impl_::amount_)); + _impl_.world_ = {}; } -SetExperienceAction::~SetExperienceAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetExperienceAction) +WorldQueryPlayersAction::~WorldQueryPlayersAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldQueryPlayersAction) SharedDtor(*this); } -inline void SetExperienceAction::SharedDtor(MessageLite& self) { - SetExperienceAction& this_ = static_cast(self); +inline void WorldQueryPlayersAction::SharedDtor(MessageLite& self) { + WorldQueryPlayersAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetExperienceAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldQueryPlayersAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetExperienceAction(arena); + return ::new (mem) WorldQueryPlayersAction(arena); } -constexpr auto SetExperienceAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetExperienceAction), - alignof(SetExperienceAction)); +constexpr auto WorldQueryPlayersAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldQueryPlayersAction), + alignof(WorldQueryPlayersAction)); } -constexpr auto SetExperienceAction::InternalGenerateClassData_() { +constexpr auto WorldQueryPlayersAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetExperienceAction_default_instance_._instance, + &_WorldQueryPlayersAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetExperienceAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldQueryPlayersAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetExperienceAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetExperienceAction::ByteSizeLong, - &SetExperienceAction::_InternalSerialize, + &WorldQueryPlayersAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldQueryPlayersAction::ByteSizeLong, + &WorldQueryPlayersAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldQueryPlayersAction, _impl_._cached_size_), false, }, - &SetExperienceAction::kDescriptorMethods, + &WorldQueryPlayersAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetExperienceAction_class_data_ = - SetExperienceAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldQueryPlayersAction_class_data_ = + WorldQueryPlayersAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetExperienceAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetExperienceAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetExperienceAction_class_data_.tc_table); - return SetExperienceAction_class_data_.base(); +WorldQueryPlayersAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldQueryPlayersAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldQueryPlayersAction_class_data_.tc_table); + return WorldQueryPlayersAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 4, 0, 49, 2> -SetExperienceAction::_table_ = { +const ::_pbi::TcParseTable<0, 1, 1, 0, 2> +WorldQueryPlayersAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldQueryPlayersAction, _impl_._has_bits_), 0, // no _extensions_ - 4, 24, // max_field_number, fast_idx_mask + 1, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967280, // skipmap + 4294967294, // skipmap offsetof(decltype(_table_), field_entries), - 4, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SetExperienceAction_class_data_.base(), + 1, // num_field_entries + 1, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldQueryPlayersAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetExperienceAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldQueryPlayersAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // optional int32 amount = 4 [json_name = "amount"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetExperienceAction, _impl_.amount_), 3>(), - {32, 3, 0, - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.player_uuid_)}}, - // optional int32 level = 2 [json_name = "level"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(SetExperienceAction, _impl_.level_), 1>(), - {16, 1, 0, - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_)}}, - // optional float progress = 3 [json_name = "progress"]; - {::_pbi::TcParser::FastF32S1, - {29, 2, 0, - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.progress_)}}, + PROTOBUF_FIELD_OFFSET(WorldQueryPlayersAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // optional int32 level = 2 [json_name = "level"]; - {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, - // optional float progress = 3 [json_name = "progress"]; - {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.progress_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, - // optional int32 amount = 4 [json_name = "amount"]; - {PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryPlayersAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, }}, - // no aux_entries {{ - "\35\13\0\0\0\0\0\0" - "df.plugin.SetExperienceAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetExperienceAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetExperienceAction) +PROTOBUF_NOINLINE void WorldQueryPlayersAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldQueryPlayersAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -5589,65 +12375,37 @@ PROTOBUF_NOINLINE void SetExperienceAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); - } - if (BatchCheckHasBit(cached_has_bits, 0x0000000eU)) { - ::memset(&_impl_.level_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.amount_) - - reinterpret_cast(&_impl_.level_)) + sizeof(_impl_.amount_)); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetExperienceAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryPlayersAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetExperienceAction& this_ = static_cast(base); + const WorldQueryPlayersAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetExperienceAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryPlayersAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetExperienceAction& this_ = *this; + const WorldQueryPlayersAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetExperienceAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldQueryPlayersAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetExperienceAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } - } - - // optional int32 level = 2 [json_name = "level"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<2>( - stream, this_._internal_level(), target); - } - - // optional float progress = 3 [json_name = "progress"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray( - 3, this_._internal_progress(), target); - } - - // optional int32 amount = 4 [json_name = "amount"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<4>( - stream, this_._internal_amount(), target); + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -5655,82 +12413,57 @@ ::uint8_t* PROTOBUF_NONNULL SetExperienceAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetExperienceAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldQueryPlayersAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetExperienceAction::ByteSizeLong(const MessageLite& base) { - const SetExperienceAction& this_ = static_cast(base); +::size_t WorldQueryPlayersAction::ByteSizeLong(const MessageLite& base) { + const WorldQueryPlayersAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetExperienceAction::ByteSizeLong() const { - const SetExperienceAction& this_ = *this; +::size_t WorldQueryPlayersAction::ByteSizeLong() const { + const WorldQueryPlayersAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetExperienceAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldQueryPlayersAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void)cached_has_bits; - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - cached_has_bits = this_._impl_._has_bits_[0]; - total_size += static_cast(0x00000004U & cached_has_bits) * 5; - if (BatchCheckHasBit(cached_has_bits, 0x0000000bU)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + { + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + cached_has_bits = this_._impl_._has_bits_[0]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } - } - // optional int32 level = 2 [json_name = "level"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this_._internal_level()); - } - // optional int32 amount = 4 [json_name = "amount"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this_._internal_amount()); + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SetExperienceAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldQueryPlayersAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetExperienceAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldQueryPlayersAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000000fU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } - } - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _this->_impl_.level_ = from._impl_.level_; - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _this->_impl_.progress_ = from._impl_.progress_; - } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - _this->_impl_.amount_ = from._impl_.amount_; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); + } else { + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } _this->_impl_._has_bits_[0] |= cached_has_bits; @@ -5738,200 +12471,202 @@ void SetExperienceAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetExperienceAction::CopyFrom(const SetExperienceAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetExperienceAction) +void WorldQueryPlayersAction::CopyFrom(const WorldQueryPlayersAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldQueryPlayersAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetExperienceAction::InternalSwap(SetExperienceAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldQueryPlayersAction::InternalSwap(WorldQueryPlayersAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.amount_) - + sizeof(SetExperienceAction::_impl_.amount_) - - PROTOBUF_FIELD_OFFSET(SetExperienceAction, _impl_.level_)>( - reinterpret_cast(&_impl_.level_), - reinterpret_cast(&other->_impl_.level_)); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata SetExperienceAction::GetMetadata() const { +::google::protobuf::Metadata WorldQueryPlayersAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SetVelocityAction::_Internal { +class WorldQueryEntitiesWithinAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_._has_bits_); }; -void SetVelocityAction::clear_velocity() { +void WorldQueryEntitiesWithinAction::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.velocity_ != nullptr) _impl_.velocity_->Clear(); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +void WorldQueryEntitiesWithinAction::clear_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.box_ != nullptr) _impl_.box_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -SetVelocityAction::SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldQueryEntitiesWithinAction::WorldQueryEntitiesWithinAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetVelocityAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryEntitiesWithinAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldQueryEntitiesWithinAction) } -PROTOBUF_NDEBUG_INLINE SetVelocityAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryEntitiesWithinAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SetVelocityAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldQueryEntitiesWithinAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -SetVelocityAction::SetVelocityAction( +WorldQueryEntitiesWithinAction::WorldQueryEntitiesWithinAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SetVelocityAction& from) + const WorldQueryEntitiesWithinAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SetVelocityAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryEntitiesWithinAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SetVelocityAction* const _this = this; + WorldQueryEntitiesWithinAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.velocity_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.velocity_) + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.box_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_) : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldQueryEntitiesWithinAction) } -PROTOBUF_NDEBUG_INLINE SetVelocityAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryEntitiesWithinAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void SetVelocityAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldQueryEntitiesWithinAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.velocity_ = {}; + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, box_) - + offsetof(Impl_, world_) + + sizeof(Impl_::box_)); } -SetVelocityAction::~SetVelocityAction() { - // @@protoc_insertion_point(destructor:df.plugin.SetVelocityAction) +WorldQueryEntitiesWithinAction::~WorldQueryEntitiesWithinAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldQueryEntitiesWithinAction) SharedDtor(*this); } -inline void SetVelocityAction::SharedDtor(MessageLite& self) { - SetVelocityAction& this_ = static_cast(self); +inline void WorldQueryEntitiesWithinAction::SharedDtor(MessageLite& self) { + WorldQueryEntitiesWithinAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - delete this_._impl_.velocity_; + delete this_._impl_.world_; + delete this_._impl_.box_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SetVelocityAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SetVelocityAction(arena); + return ::new (mem) WorldQueryEntitiesWithinAction(arena); } -constexpr auto SetVelocityAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SetVelocityAction), - alignof(SetVelocityAction)); +constexpr auto WorldQueryEntitiesWithinAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldQueryEntitiesWithinAction), + alignof(WorldQueryEntitiesWithinAction)); } -constexpr auto SetVelocityAction::InternalGenerateClassData_() { +constexpr auto WorldQueryEntitiesWithinAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SetVelocityAction_default_instance_._instance, + &_WorldQueryEntitiesWithinAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SetVelocityAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldQueryEntitiesWithinAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SetVelocityAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SetVelocityAction::ByteSizeLong, - &SetVelocityAction::_InternalSerialize, + &WorldQueryEntitiesWithinAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldQueryEntitiesWithinAction::ByteSizeLong, + &WorldQueryEntitiesWithinAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_._cached_size_), false, }, - &SetVelocityAction::kDescriptorMethods, + &WorldQueryEntitiesWithinAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SetVelocityAction_class_data_ = - SetVelocityAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesWithinAction_class_data_ = + WorldQueryEntitiesWithinAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SetVelocityAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SetVelocityAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SetVelocityAction_class_data_.tc_table); - return SetVelocityAction_class_data_.base(); +WorldQueryEntitiesWithinAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldQueryEntitiesWithinAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldQueryEntitiesWithinAction_class_data_.tc_table); + return WorldQueryEntitiesWithinAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 1, 47, 2> -SetVelocityAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldQueryEntitiesWithinAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries - 1, // num_aux_entries + 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), - SetVelocityAction_class_data_.base(), + WorldQueryEntitiesWithinAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SetVelocityAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesWithinAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + // .df.plugin.BBox box = 2 [json_name = "box"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.box_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.velocity_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; - {PROTOBUF_FIELD_OFFSET(SetVelocityAction, _impl_.velocity_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.BBox box = 2 [json_name = "box"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.box_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ - {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BBox>()}, }}, {{ - "\33\13\0\0\0\0\0\0" - "df.plugin.SetVelocityAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void SetVelocityAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SetVelocityAction) +PROTOBUF_NOINLINE void WorldQueryEntitiesWithinAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldQueryEntitiesWithinAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -5940,11 +12675,12 @@ PROTOBUF_NOINLINE void SetVelocityAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.velocity_ != nullptr); - _impl_.velocity_->Clear(); + ABSL_DCHECK(_impl_.box_ != nullptr); + _impl_.box_->Clear(); } } _impl_._has_bits_.Clear(); @@ -5952,38 +12688,35 @@ PROTOBUF_NOINLINE void SetVelocityAction::Clear() { } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SetVelocityAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SetVelocityAction& this_ = static_cast(base); + const WorldQueryEntitiesWithinAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SetVelocityAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SetVelocityAction& this_ = *this; + const WorldQueryEntitiesWithinAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldQueryEntitiesWithinAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SetVelocityAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + // .df.plugin.BBox box = 2 [json_name = "box"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.velocity_, this_._impl_.velocity_->GetCachedSize(), target, + 2, *this_._impl_.box_, this_._impl_.box_->GetCachedSize(), target, stream); } @@ -5992,18 +12725,18 @@ ::uint8_t* PROTOBUF_NONNULL SetVelocityAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldQueryEntitiesWithinAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SetVelocityAction::ByteSizeLong(const MessageLite& base) { - const SetVelocityAction& this_ = static_cast(base); +::size_t WorldQueryEntitiesWithinAction::ByteSizeLong(const MessageLite& base) { + const WorldQueryEntitiesWithinAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SetVelocityAction::ByteSizeLong() const { - const SetVelocityAction& this_ = *this; +::size_t WorldQueryEntitiesWithinAction::ByteSizeLong() const { + const WorldQueryEntitiesWithinAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldQueryEntitiesWithinAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -6013,33 +12746,31 @@ ::size_t SetVelocityAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + // .df.plugin.BBox box = 2 [json_name = "box"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.velocity_); + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.box_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SetVelocityAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldQueryEntitiesWithinAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SetVelocityAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldQueryEntitiesWithinAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -6047,20 +12778,19 @@ void SetVelocityAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.velocity_ != nullptr); - if (_this->_impl_.velocity_ == nullptr) { - _this->_impl_.velocity_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.velocity_); + ABSL_DCHECK(from._impl_.box_ != nullptr); + if (_this->_impl_.box_ == nullptr) { + _this->_impl_.box_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_); } else { - _this->_impl_.velocity_->MergeFrom(*from._impl_.velocity_); + _this->_impl_.box_->MergeFrom(*from._impl_.box_); } } } @@ -6069,296 +12799,258 @@ void SetVelocityAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SetVelocityAction::CopyFrom(const SetVelocityAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SetVelocityAction) +void WorldQueryEntitiesWithinAction::CopyFrom(const WorldQueryEntitiesWithinAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldQueryEntitiesWithinAction) if (&from == this) return; Clear(); MergeFrom(from); } -void SetVelocityAction::InternalSwap(SetVelocityAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldQueryEntitiesWithinAction::InternalSwap(WorldQueryEntitiesWithinAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - swap(_impl_.velocity_, other->_impl_.velocity_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.box_) + + sizeof(WorldQueryEntitiesWithinAction::_impl_.box_) + - PROTOBUF_FIELD_OFFSET(WorldQueryEntitiesWithinAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata SetVelocityAction::GetMetadata() const { +::google::protobuf::Metadata WorldQueryEntitiesWithinAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class AddEffectAction::_Internal { +class WorldQueryViewersAction::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._has_bits_); }; -AddEffectAction::AddEffectAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldQueryViewersAction::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +void WorldQueryViewersAction::clear_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ != nullptr) _impl_.position_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +WorldQueryViewersAction::WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, AddEffectAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryViewersAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.AddEffectAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldQueryViewersAction) } -PROTOBUF_NDEBUG_INLINE AddEffectAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryViewersAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::AddEffectAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldQueryViewersAction& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + _cached_size_{0} {} -AddEffectAction::AddEffectAction( +WorldQueryViewersAction::WorldQueryViewersAction( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const AddEffectAction& from) + const WorldQueryViewersAction& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, AddEffectAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldQueryViewersAction_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - AddEffectAction* const _this = this; + WorldQueryViewersAction* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, effect_type_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, effect_type_), - offsetof(Impl_, show_particles_) - - offsetof(Impl_, effect_type_) + - sizeof(Impl_::show_particles_)); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.AddEffectAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldQueryViewersAction) } -PROTOBUF_NDEBUG_INLINE AddEffectAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldQueryViewersAction::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - player_uuid_(arena) {} + : _cached_size_{0} {} -inline void AddEffectAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldQueryViewersAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, effect_type_), + offsetof(Impl_, world_), 0, - offsetof(Impl_, show_particles_) - - offsetof(Impl_, effect_type_) + - sizeof(Impl_::show_particles_)); + offsetof(Impl_, position_) - + offsetof(Impl_, world_) + + sizeof(Impl_::position_)); } -AddEffectAction::~AddEffectAction() { - // @@protoc_insertion_point(destructor:df.plugin.AddEffectAction) +WorldQueryViewersAction::~WorldQueryViewersAction() { + // @@protoc_insertion_point(destructor:df.plugin.WorldQueryViewersAction) SharedDtor(*this); } -inline void AddEffectAction::SharedDtor(MessageLite& self) { - AddEffectAction& this_ = static_cast(self); +inline void WorldQueryViewersAction::SharedDtor(MessageLite& self) { + WorldQueryViewersAction& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; + delete this_._impl_.position_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL AddEffectAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldQueryViewersAction::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) AddEffectAction(arena); + return ::new (mem) WorldQueryViewersAction(arena); } -constexpr auto AddEffectAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(AddEffectAction), - alignof(AddEffectAction)); +constexpr auto WorldQueryViewersAction::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldQueryViewersAction), + alignof(WorldQueryViewersAction)); } -constexpr auto AddEffectAction::InternalGenerateClassData_() { +constexpr auto WorldQueryViewersAction::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_AddEffectAction_default_instance_._instance, + &_WorldQueryViewersAction_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &AddEffectAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldQueryViewersAction::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &AddEffectAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &AddEffectAction::ByteSizeLong, - &AddEffectAction::_InternalSerialize, + &WorldQueryViewersAction::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldQueryViewersAction::ByteSizeLong, + &WorldQueryViewersAction::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._cached_size_), false, }, - &AddEffectAction::kDescriptorMethods, + &WorldQueryViewersAction::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull AddEffectAction_class_data_ = - AddEffectAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_ = + WorldQueryViewersAction::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -AddEffectAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&AddEffectAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(AddEffectAction_class_data_.tc_table); - return AddEffectAction_class_data_.base(); +WorldQueryViewersAction::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldQueryViewersAction_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldQueryViewersAction_class_data_.tc_table); + return WorldQueryViewersAction_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 5, 0, 45, 2> -AddEffectAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldQueryViewersAction::_table_ = { { - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._has_bits_), 0, // no _extensions_ - 5, 56, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967264, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - AddEffectAction_class_data_.base(), + 2, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldQueryViewersAction_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::AddEffectAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldQueryViewersAction>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.player_uuid_)}}, - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AddEffectAction, _impl_.effect_type_), 1>(), - {16, 1, 0, - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_)}}, - // int32 level = 3 [json_name = "level"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(AddEffectAction, _impl_.level_), 2>(), - {24, 2, 0, - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.level_)}}, - // int64 duration_ms = 4 [json_name = "durationMs"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(AddEffectAction, _impl_.duration_ms_), 3>(), - {32, 3, 0, - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.duration_ms_)}}, - // bool show_particles = 5 [json_name = "showParticles"]; - {::_pbi::TcParser::SingularVarintNoZag1(), - {40, 4, 0, - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; - {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, - // int32 level = 3 [json_name = "level"]; - {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.level_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt32)}, - // int64 duration_ms = 4 [json_name = "durationMs"]; - {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.duration_ms_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, - // bool show_particles = 5 [json_name = "showParticles"]; - {PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, }}, - // no aux_entries {{ - "\31\13\0\0\0\0\0\0" - "df.plugin.AddEffectAction" - "player_uuid" }}, }; -PROTOBUF_NOINLINE void AddEffectAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.AddEffectAction) +PROTOBUF_NOINLINE void WorldQueryViewersAction::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldQueryViewersAction) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); - } - if (BatchCheckHasBit(cached_has_bits, 0x0000001eU)) { - ::memset(&_impl_.effect_type_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.show_particles_) - - reinterpret_cast(&_impl_.effect_type_)) + sizeof(_impl_.show_particles_)); + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.position_ != nullptr); + _impl_.position_->Clear(); + } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL AddEffectAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryViewersAction::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const AddEffectAction& this_ = static_cast(base); + const WorldQueryViewersAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL AddEffectAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldQueryViewersAction::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const AddEffectAction& this_ = *this; + const WorldQueryViewersAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.AddEffectAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldQueryViewersAction) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.AddEffectAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_effect_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this_._internal_effect_type(), target); - } - } - - // int32 level = 3 [json_name = "level"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_level() != 0) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt32ToArrayWithField<3>( - stream, this_._internal_level(), target); - } - } - - // int64 duration_ms = 4 [json_name = "durationMs"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (this_._internal_duration_ms() != 0) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>( - stream, this_._internal_duration_ms(), target); - } - } - - // bool show_particles = 5 [json_name = "showParticles"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (this_._internal_show_particles() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 5, this_._internal_show_particles(), target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -6366,18 +13058,18 @@ ::uint8_t* PROTOBUF_NONNULL AddEffectAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.AddEffectAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldQueryViewersAction) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t AddEffectAction::ByteSizeLong(const MessageLite& base) { - const AddEffectAction& this_ = static_cast(base); +::size_t WorldQueryViewersAction::ByteSizeLong(const MessageLite& base) { + const WorldQueryViewersAction& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t AddEffectAction::ByteSizeLong() const { - const AddEffectAction& this_ = *this; +::size_t WorldQueryViewersAction::ByteSizeLong() const { + const WorldQueryViewersAction& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.AddEffectAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldQueryViewersAction) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -6386,88 +13078,52 @@ ::size_t AddEffectAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_effect_type() != 0) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_effect_type()); - } - } - // int32 level = 3 [json_name = "level"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_level() != 0) { - total_size += ::_pbi::WireFormatLite::Int32SizePlusOne( - this_._internal_level()); - } - } - // int64 duration_ms = 4 [json_name = "durationMs"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (this_._internal_duration_ms() != 0) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( - this_._internal_duration_ms()); - } - } - // bool show_particles = 5 [json_name = "showParticles"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (this_._internal_show_particles() != 0) { - total_size += 2; - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void AddEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldQueryViewersAction::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.AddEffectAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldQueryViewersAction) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_effect_type() != 0) { - _this->_impl_.effect_type_ = from._impl_.effect_type_; - } - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (from._internal_level() != 0) { - _this->_impl_.level_ = from._impl_.level_; - } - } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - if (from._internal_duration_ms() != 0) { - _this->_impl_.duration_ms_ = from._impl_.duration_ms_; - } - } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - if (from._internal_show_particles() != 0) { - _this->_impl_.show_particles_ = from._impl_.show_particles_; + ABSL_DCHECK(from._impl_.position_ != nullptr); + if (_this->_impl_.position_ == nullptr) { + _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); + } else { + _this->_impl_.position_->MergeFrom(*from._impl_.position_); } } } @@ -6476,148 +13132,145 @@ void AddEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void AddEffectAction::CopyFrom(const AddEffectAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.AddEffectAction) +void WorldQueryViewersAction::CopyFrom(const WorldQueryViewersAction& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldQueryViewersAction) if (&from == this) return; Clear(); MergeFrom(from); } -void AddEffectAction::InternalSwap(AddEffectAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldQueryViewersAction::InternalSwap(WorldQueryViewersAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.show_particles_) - + sizeof(AddEffectAction::_impl_.show_particles_) - - PROTOBUF_FIELD_OFFSET(AddEffectAction, _impl_.effect_type_)>( - reinterpret_cast(&_impl_.effect_type_), - reinterpret_cast(&other->_impl_.effect_type_)); + PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_) + + sizeof(WorldQueryViewersAction::_impl_.position_) + - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata AddEffectAction::GetMetadata() const { +::google::protobuf::Metadata WorldQueryViewersAction::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class RemoveEffectAction::_Internal { +class ActionStatus::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_); }; -RemoveEffectAction::RemoveEffectAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +ActionStatus::ActionStatus(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, RemoveEffectAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.RemoveEffectAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.ActionStatus) } -PROTOBUF_NDEBUG_INLINE RemoveEffectAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::RemoveEffectAction& from_msg) + [[maybe_unused]] const ::df::plugin::ActionStatus& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + error_(arena, from.error_) {} -RemoveEffectAction::RemoveEffectAction( +ActionStatus::ActionStatus( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const RemoveEffectAction& from) + const ActionStatus& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, RemoveEffectAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - RemoveEffectAction* const _this = this; + ActionStatus* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - _impl_.effect_type_ = from._impl_.effect_type_; + _impl_.ok_ = from._impl_.ok_; - // @@protoc_insertion_point(copy_constructor:df.plugin.RemoveEffectAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.ActionStatus) } -PROTOBUF_NDEBUG_INLINE RemoveEffectAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena) {} + error_(arena) {} -inline void RemoveEffectAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void ActionStatus::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.effect_type_ = {}; + _impl_.ok_ = {}; } -RemoveEffectAction::~RemoveEffectAction() { - // @@protoc_insertion_point(destructor:df.plugin.RemoveEffectAction) +ActionStatus::~ActionStatus() { + // @@protoc_insertion_point(destructor:df.plugin.ActionStatus) SharedDtor(*this); } -inline void RemoveEffectAction::SharedDtor(MessageLite& self) { - RemoveEffectAction& this_ = static_cast(self); +inline void ActionStatus::SharedDtor(MessageLite& self) { + ActionStatus& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + this_._impl_.error_.Destroy(); this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL RemoveEffectAction::PlacementNew_( +inline void* PROTOBUF_NONNULL ActionStatus::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) RemoveEffectAction(arena); + return ::new (mem) ActionStatus(arena); } -constexpr auto RemoveEffectAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(RemoveEffectAction), - alignof(RemoveEffectAction)); +constexpr auto ActionStatus::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ActionStatus), + alignof(ActionStatus)); } -constexpr auto RemoveEffectAction::InternalGenerateClassData_() { +constexpr auto ActionStatus::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_RemoveEffectAction_default_instance_._instance, + &_ActionStatus_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &RemoveEffectAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &ActionStatus::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &RemoveEffectAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &RemoveEffectAction::ByteSizeLong, - &RemoveEffectAction::_InternalSerialize, + &ActionStatus::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ActionStatus::ByteSizeLong, + &ActionStatus::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._cached_size_), false, }, - &RemoveEffectAction::kDescriptorMethods, + &ActionStatus::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull RemoveEffectAction_class_data_ = - RemoveEffectAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_ = + ActionStatus::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -RemoveEffectAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&RemoveEffectAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(RemoveEffectAction_class_data_.tc_table); - return RemoveEffectAction_class_data_.base(); +ActionStatus::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ActionStatus_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ActionStatus_class_data_.tc_table); + return ActionStatus_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 48, 2> -RemoveEffectAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 0, 36, 2> +ActionStatus::_table_ = { { - PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), @@ -6626,38 +13279,38 @@ RemoveEffectAction::_table_ = { 2, // num_field_entries 0, // num_aux_entries offsetof(decltype(_table_), field_names), // no aux_entries - RemoveEffectAction_class_data_.base(), + ActionStatus_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::RemoveEffectAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::ActionStatus>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(RemoveEffectAction, _impl_.effect_type_), 1>(), - {16, 1, 0, - PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.effect_type_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; + // optional string error = 2 [json_name = "error"]; {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.player_uuid_)}}, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_)}}, + // bool ok = 1 [json_name = "ok"]; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; - {PROTOBUF_FIELD_OFFSET(RemoveEffectAction, _impl_.effect_type_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, + // bool ok = 1 [json_name = "ok"]; + {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // optional string error = 2 [json_name = "error"]; + {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, // no aux_entries {{ - "\34\13\0\0\0\0\0\0" - "df.plugin.RemoveEffectAction" - "player_uuid" + "\26\0\5\0\0\0\0\0" + "df.plugin.ActionStatus" + "error" }}, }; -PROTOBUF_NOINLINE void RemoveEffectAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.RemoveEffectAction) +PROTOBUF_NOINLINE void ActionStatus::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.ActionStatus) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -6665,68 +13318,66 @@ PROTOBUF_NOINLINE void RemoveEffectAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + _impl_.error_.ClearNonDefaultToEmpty(); } - _impl_.effect_type_ = 0; + _impl_.ok_ = false; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL RemoveEffectAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const RemoveEffectAction& this_ = static_cast(base); + const ActionStatus& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL RemoveEffectAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const RemoveEffectAction& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.RemoveEffectAction) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.RemoveEffectAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + const ActionStatus& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ActionStatus) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + cached_has_bits = this_._impl_._has_bits_[0]; + // bool ok = 1 [json_name = "ok"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_effect_type() != 0) { + if (this_._internal_ok() != 0) { target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this_._internal_effect_type(), target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this_._internal_ok(), target); } } + // optional string error = 2 [json_name = "error"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + const ::std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ActionStatus.error"); + target = stream->WriteStringMaybeAliased(2, _s, target); + } + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.RemoveEffectAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ActionStatus) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t RemoveEffectAction::ByteSizeLong(const MessageLite& base) { - const RemoveEffectAction& this_ = static_cast(base); +::size_t ActionStatus::ByteSizeLong(const MessageLite& base) { + const ActionStatus& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t RemoveEffectAction::ByteSizeLong() const { - const RemoveEffectAction& this_ = *this; +::size_t ActionStatus::ByteSizeLong() const { + const ActionStatus& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.RemoveEffectAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.ActionStatus) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -6736,18 +13387,15 @@ ::size_t RemoveEffectAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // optional string error = 2 [json_name = "error"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); - } + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); } - // .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; + // bool ok = 1 [json_name = "ok"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_effect_type() != 0) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_effect_type()); + if (this_._internal_ok() != 0) { + total_size += 2; } } } @@ -6755,15 +13403,15 @@ ::size_t RemoveEffectAction::ByteSizeLong() const { &this_._impl_._cached_size_); } -void RemoveEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void ActionStatus::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.RemoveEffectAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ActionStatus) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -6771,17 +13419,11 @@ void RemoveEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } - } + _this->_internal_set_error(from._internal_error()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_effect_type() != 0) { - _this->_impl_.effect_type_ = from._impl_.effect_type_; + if (from._internal_ok() != 0) { + _this->_impl_.ok_ = from._impl_.ok_; } } } @@ -6790,320 +13432,266 @@ void RemoveEffectAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void RemoveEffectAction::CopyFrom(const RemoveEffectAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.RemoveEffectAction) +void ActionStatus::CopyFrom(const ActionStatus& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ActionStatus) if (&from == this) return; Clear(); MergeFrom(from); } -void RemoveEffectAction::InternalSwap(RemoveEffectAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void ActionStatus::InternalSwap(ActionStatus* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - swap(_impl_.effect_type_, other->_impl_.effect_type_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + swap(_impl_.ok_, other->_impl_.ok_); } -::google::protobuf::Metadata RemoveEffectAction::GetMetadata() const { +::google::protobuf::Metadata ActionStatus::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SendTitleAction::_Internal { +class WorldEntitiesResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_); }; -SendTitleAction::SendTitleAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldEntitiesResult::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldEntitiesResult::clear_entities() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.entities_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); +} +WorldEntitiesResult::WorldEntitiesResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendTitleAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SendTitleAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesResult) } -PROTOBUF_NDEBUG_INLINE SendTitleAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SendTitleAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldEntitiesResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_), - title_(arena, from.title_), - subtitle_(arena, from.subtitle_) {} + entities_{visibility, arena, from.entities_} {} -SendTitleAction::SendTitleAction( +WorldEntitiesResult::WorldEntitiesResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SendTitleAction& from) + const WorldEntitiesResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendTitleAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SendTitleAction* const _this = this; + WorldEntitiesResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, fade_in_ms_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, fade_in_ms_), - offsetof(Impl_, fade_out_ms_) - - offsetof(Impl_, fade_in_ms_) + - sizeof(Impl_::fade_out_ms_)); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SendTitleAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesResult) } -PROTOBUF_NDEBUG_INLINE SendTitleAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena), - title_(arena), - subtitle_(arena) {} + entities_{visibility, arena} {} -inline void SendTitleAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldEntitiesResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, fade_in_ms_), - 0, - offsetof(Impl_, fade_out_ms_) - - offsetof(Impl_, fade_in_ms_) + - sizeof(Impl_::fade_out_ms_)); + _impl_.world_ = {}; } -SendTitleAction::~SendTitleAction() { - // @@protoc_insertion_point(destructor:df.plugin.SendTitleAction) +WorldEntitiesResult::~WorldEntitiesResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesResult) SharedDtor(*this); } -inline void SendTitleAction::SharedDtor(MessageLite& self) { - SendTitleAction& this_ = static_cast(self); +inline void WorldEntitiesResult::SharedDtor(MessageLite& self) { + WorldEntitiesResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - this_._impl_.title_.Destroy(); - this_._impl_.subtitle_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SendTitleAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldEntitiesResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SendTitleAction(arena); + return ::new (mem) WorldEntitiesResult(arena); } -constexpr auto SendTitleAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendTitleAction), - alignof(SendTitleAction)); +constexpr auto WorldEntitiesResult::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_) + + decltype(WorldEntitiesResult::_impl_.entities_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(WorldEntitiesResult), alignof(WorldEntitiesResult), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&WorldEntitiesResult::PlacementNew_, + sizeof(WorldEntitiesResult), + alignof(WorldEntitiesResult)); + } } -constexpr auto SendTitleAction::InternalGenerateClassData_() { +constexpr auto WorldEntitiesResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SendTitleAction_default_instance_._instance, + &_WorldEntitiesResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SendTitleAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldEntitiesResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SendTitleAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SendTitleAction::ByteSizeLong, - &SendTitleAction::_InternalSerialize, + &WorldEntitiesResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesResult::ByteSizeLong, + &WorldEntitiesResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._cached_size_), false, }, - &SendTitleAction::kDescriptorMethods, + &WorldEntitiesResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SendTitleAction_class_data_ = - SendTitleAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldEntitiesResult_class_data_ = + WorldEntitiesResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SendTitleAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SendTitleAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SendTitleAction_class_data_.tc_table); - return SendTitleAction_class_data_.base(); +WorldEntitiesResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesResult_class_data_.tc_table); + return WorldEntitiesResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 6, 0, 58, 2> -SendTitleAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldEntitiesResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_), 0, // no _extensions_ - 6, 56, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967232, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 6, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SendTitleAction_class_data_.base(), + 2, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldEntitiesResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SendTitleAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.player_uuid_)}}, - // string title = 2 [json_name = "title"]; - {::_pbi::TcParser::FastUS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.title_)}}, - // optional string subtitle = 3 [json_name = "subtitle"]; - {::_pbi::TcParser::FastUS1, - {26, 2, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.subtitle_)}}, - // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.fade_in_ms_), 3>(), - {32, 3, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_)}}, - // optional int64 duration_ms = 5 [json_name = "durationMs"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.duration_ms_), 4>(), - {40, 4, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.duration_ms_)}}, - // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint64_t, offsetof(SendTitleAction, _impl_.fade_out_ms_), 5>(), - {48, 5, 0, - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_)}}, - {::_pbi::TcParser::MiniParse, {}}, + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + {::_pbi::TcParser::FastMtR1, + {18, 0, 1, + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string title = 2 [json_name = "title"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.title_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // optional string subtitle = 3 [json_name = "subtitle"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.subtitle_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, - // optional int64 duration_ms = 5 [json_name = "durationMs"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.duration_ms_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, - // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; - {PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_), _Internal::kHasBitsOffset + 5, 0, (0 | ::_fl::kFcOptional | ::_fl::kInt64)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, - // no aux_entries {{ - "\31\13\5\10\0\0\0\0" - "df.plugin.SendTitleAction" - "player_uuid" - "title" - "subtitle" }}, }; -PROTOBUF_NOINLINE void SendTitleAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SendTitleAction) +PROTOBUF_NOINLINE void WorldEntitiesResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _impl_.entities_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.title_.ClearNonDefaultToEmpty(); - } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _impl_.subtitle_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } } - if (BatchCheckHasBit(cached_has_bits, 0x00000038U)) { - ::memset(&_impl_.fade_in_ms_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.fade_out_ms_) - - reinterpret_cast(&_impl_.fade_in_ms_)) + sizeof(_impl_.fade_out_ms_)); - } _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SendTitleAction::_InternalSerialize( - const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SendTitleAction& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SendTitleAction::_InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SendTitleAction& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendTitleAction) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } - } - - // string title = 2 [json_name = "title"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_title().empty()) { - const ::std::string& _s = this_._internal_title(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.title"); - target = stream->WriteStringMaybeAliased(2, _s, target); - } - } - - // optional string subtitle = 3 [json_name = "subtitle"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - const ::std::string& _s = this_._internal_subtitle(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTitleAction.subtitle"); - target = stream->WriteStringMaybeAliased(3, _s, target); - } + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} - // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<4>( - stream, this_._internal_fade_in_ms(), target); +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const WorldEntitiesResult& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const WorldEntitiesResult& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesResult) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; - // optional int64 duration_ms = 5 [json_name = "durationMs"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<5>( - stream, this_._internal_duration_ms(), target); + cached_has_bits = this_._impl_._has_bits_[0]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { - target = - ::google::protobuf::internal::WireFormatLite::WriteInt64ToArrayWithField<6>( - stream, this_._internal_fade_out_ms(), target); + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + for (unsigned i = 0, n = static_cast( + this_._internal_entities_size()); + i < n; i++) { + const auto& repfield = this_._internal_entities().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); + } } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -7111,18 +13699,18 @@ ::uint8_t* PROTOBUF_NONNULL SendTitleAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendTitleAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SendTitleAction::ByteSizeLong(const MessageLite& base) { - const SendTitleAction& this_ = static_cast(base); +::size_t WorldEntitiesResult::ByteSizeLong(const MessageLite& base) { + const WorldEntitiesResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SendTitleAction::ByteSizeLong() const { - const SendTitleAction& this_ = *this; +::size_t WorldEntitiesResult::ByteSizeLong() const { + const WorldEntitiesResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendTitleAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -7131,295 +13719,301 @@ ::size_t SendTitleAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) { - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + total_size += 1UL * this_._internal_entities_size(); + for (const auto& msg : this_._internal_entities()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } } - // string title = 2 [json_name = "title"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_title().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_title()); - } - } - // optional string subtitle = 3 [json_name = "subtitle"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_subtitle()); - } - // optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( - this_._internal_fade_in_ms()); - } - // optional int64 duration_ms = 5 [json_name = "durationMs"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( - this_._internal_duration_ms()); - } - // optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; - if (CheckHasBit(cached_has_bits, 0x00000020U)) { - total_size += ::_pbi::WireFormatLite::Int64SizePlusOne( - this_._internal_fade_out_ms()); + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SendTitleAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldEntitiesResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendTitleAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000003fU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } - } + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _this->_internal_mutable_entities()->InternalMergeFromWithArena( + ::google::protobuf::MessageLite::internal_visibility(), arena, + from._internal_entities()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_title().empty()) { - _this->_internal_set_title(from._internal_title()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.title_.IsDefault()) { - _this->_internal_set_title(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - _this->_internal_set_subtitle(from._internal_subtitle()); - } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - _this->_impl_.fade_in_ms_ = from._impl_.fade_in_ms_; - } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - _this->_impl_.duration_ms_ = from._impl_.duration_ms_; - } - if (CheckHasBit(cached_has_bits, 0x00000020U)) { - _this->_impl_.fade_out_ms_ = from._impl_.fade_out_ms_; - } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void SendTitleAction::CopyFrom(const SendTitleAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendTitleAction) +void WorldEntitiesResult::CopyFrom(const WorldEntitiesResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesResult) if (&from == this) return; Clear(); MergeFrom(from); } -void SendTitleAction::InternalSwap(SendTitleAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldEntitiesResult::InternalSwap(WorldEntitiesResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.title_, &other->_impl_.title_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.subtitle_, &other->_impl_.subtitle_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_out_ms_) - + sizeof(SendTitleAction::_impl_.fade_out_ms_) - - PROTOBUF_FIELD_OFFSET(SendTitleAction, _impl_.fade_in_ms_)>( - reinterpret_cast(&_impl_.fade_in_ms_), - reinterpret_cast(&other->_impl_.fade_in_ms_)); + _impl_.entities_.InternalSwap(&other->_impl_.entities_); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata SendTitleAction::GetMetadata() const { +::google::protobuf::Metadata WorldEntitiesResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SendPopupAction::_Internal { +class WorldEntitiesWithinResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_); }; -SendPopupAction::SendPopupAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldEntitiesWithinResult::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldEntitiesWithinResult::clear_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.box_ != nullptr) _impl_.box_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +void WorldEntitiesWithinResult::clear_entities() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.entities_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); +} +WorldEntitiesWithinResult::WorldEntitiesWithinResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendPopupAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SendPopupAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesWithinResult) } -PROTOBUF_NDEBUG_INLINE SendPopupAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SendPopupAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldEntitiesWithinResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_), - message_(arena, from.message_) {} + entities_{visibility, arena, from.entities_} {} -SendPopupAction::SendPopupAction( +WorldEntitiesWithinResult::WorldEntitiesWithinResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SendPopupAction& from) + const WorldEntitiesWithinResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendPopupAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SendPopupAction* const _this = this; + WorldEntitiesWithinResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.box_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SendPopupAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesWithinResult) } -PROTOBUF_NDEBUG_INLINE SendPopupAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena), - message_(arena) {} + entities_{visibility, arena} {} -inline void SendPopupAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldEntitiesWithinResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, box_) - + offsetof(Impl_, world_) + + sizeof(Impl_::box_)); } -SendPopupAction::~SendPopupAction() { - // @@protoc_insertion_point(destructor:df.plugin.SendPopupAction) +WorldEntitiesWithinResult::~WorldEntitiesWithinResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesWithinResult) SharedDtor(*this); } -inline void SendPopupAction::SharedDtor(MessageLite& self) { - SendPopupAction& this_ = static_cast(self); +inline void WorldEntitiesWithinResult::SharedDtor(MessageLite& self) { + WorldEntitiesWithinResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - this_._impl_.message_.Destroy(); + delete this_._impl_.world_; + delete this_._impl_.box_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SendPopupAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldEntitiesWithinResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SendPopupAction(arena); + return ::new (mem) WorldEntitiesWithinResult(arena); } -constexpr auto SendPopupAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendPopupAction), - alignof(SendPopupAction)); +constexpr auto WorldEntitiesWithinResult::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_) + + decltype(WorldEntitiesWithinResult::_impl_.entities_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(WorldEntitiesWithinResult), alignof(WorldEntitiesWithinResult), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&WorldEntitiesWithinResult::PlacementNew_, + sizeof(WorldEntitiesWithinResult), + alignof(WorldEntitiesWithinResult)); + } } -constexpr auto SendPopupAction::InternalGenerateClassData_() { +constexpr auto WorldEntitiesWithinResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SendPopupAction_default_instance_._instance, + &_WorldEntitiesWithinResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SendPopupAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldEntitiesWithinResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SendPopupAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SendPopupAction::ByteSizeLong, - &SendPopupAction::_InternalSerialize, + &WorldEntitiesWithinResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesWithinResult::ByteSizeLong, + &WorldEntitiesWithinResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._cached_size_), false, }, - &SendPopupAction::kDescriptorMethods, + &WorldEntitiesWithinResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SendPopupAction_class_data_ = - SendPopupAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldEntitiesWithinResult_class_data_ = + WorldEntitiesWithinResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SendPopupAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SendPopupAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SendPopupAction_class_data_.tc_table); - return SendPopupAction_class_data_.base(); +WorldEntitiesWithinResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesWithinResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesWithinResult_class_data_.tc_table); + return WorldEntitiesWithinResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 52, 2> -SendPopupAction::_table_ = { +const ::_pbi::TcParseTable<2, 3, 3, 0, 2> +WorldEntitiesWithinResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_), 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask + 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap + 4294967288, // skipmap offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SendPopupAction_class_data_.base(), + 3, // num_field_entries + 3, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldEntitiesWithinResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SendPopupAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesWithinResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string message = 2 [json_name = "message"]; - {::_pbi::TcParser::FastUS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.message_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.player_uuid_)}}, + {::_pbi::TcParser::MiniParse, {}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)}}, + // .df.plugin.BBox box = 2 [json_name = "box"]; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_)}}, + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + {::_pbi::TcParser::FastMtR1, + {26, 0, 2, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string message = 2 [json_name = "message"]; - {PROTOBUF_FIELD_OFFSET(SendPopupAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.BBox box = 2 [json_name = "box"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BBox>()}, + {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, - // no aux_entries {{ - "\31\13\7\0\0\0\0\0" - "df.plugin.SendPopupAction" - "player_uuid" - "message" }}, }; -PROTOBUF_NOINLINE void SendPopupAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SendPopupAction) +PROTOBUF_NOINLINE void WorldEntitiesWithinResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesWithinResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _impl_.entities_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.message_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.box_ != nullptr); + _impl_.box_->Clear(); } } _impl_._has_bits_.Clear(); @@ -7427,41 +14021,48 @@ PROTOBUF_NOINLINE void SendPopupAction::Clear() { } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SendPopupAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SendPopupAction& this_ = static_cast(base); + const WorldEntitiesWithinResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SendPopupAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SendPopupAction& this_ = *this; + const WorldEntitiesWithinResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendPopupAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesWithinResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendPopupAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // string message = 2 [json_name = "message"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - const ::std::string& _s = this_._internal_message(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendPopupAction.message"); - target = stream->WriteStringMaybeAliased(2, _s, target); + // .df.plugin.BBox box = 2 [json_name = "box"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.box_, this_._impl_.box_->GetCachedSize(), target, + stream); + } + + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + for (unsigned i = 0, n = static_cast( + this_._internal_entities_size()); + i < n; i++) { + const auto& repfield = this_._internal_entities().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, repfield, repfield.GetCachedSize(), + target, stream); } } @@ -7470,18 +14071,18 @@ ::uint8_t* PROTOBUF_NONNULL SendPopupAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendPopupAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesWithinResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SendPopupAction::ByteSizeLong(const MessageLite& base) { - const SendPopupAction& this_ = static_cast(base); +::size_t WorldEntitiesWithinResult::ByteSizeLong(const MessageLite& base) { + const WorldEntitiesWithinResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SendPopupAction::ByteSizeLong() const { - const SendPopupAction& this_ = *this; +::size_t WorldEntitiesWithinResult::ByteSizeLong() const { + const WorldEntitiesWithinResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendPopupAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesWithinResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -7490,57 +14091,64 @@ ::size_t SendPopupAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + total_size += 1UL * this_._internal_entities_size(); + for (const auto& msg : this_._internal_entities()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } } - // string message = 2 [json_name = "message"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_message()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); + } + // .df.plugin.BBox box = 2 [json_name = "box"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.box_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SendPopupAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldEntitiesWithinResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendPopupAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesWithinResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _this->_internal_mutable_entities()->InternalMergeFromWithArena( + ::google::protobuf::MessageLite::internal_visibility(), arena, + from._internal_entities()); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_message().empty()) { - _this->_internal_set_message(from._internal_message()); + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(from._impl_.box_ != nullptr); + if (_this->_impl_.box_ == nullptr) { + _this->_impl_.box_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_); } else { - if (_this->_impl_.message_.IsDefault()) { - _this->_internal_set_message(""); - } + _this->_impl_.box_->MergeFrom(*from._impl_.box_); } } } @@ -7549,185 +14157,213 @@ void SendPopupAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SendPopupAction::CopyFrom(const SendPopupAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendPopupAction) +void WorldEntitiesWithinResult::CopyFrom(const WorldEntitiesWithinResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesWithinResult) if (&from == this) return; Clear(); MergeFrom(from); } -void SendPopupAction::InternalSwap(SendPopupAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldEntitiesWithinResult::InternalSwap(WorldEntitiesWithinResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); + _impl_.entities_.InternalSwap(&other->_impl_.entities_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_) + + sizeof(WorldEntitiesWithinResult::_impl_.box_) + - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata SendPopupAction::GetMetadata() const { +::google::protobuf::Metadata WorldEntitiesWithinResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class SendTipAction::_Internal { +class WorldPlayersResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_); }; -SendTipAction::SendTipAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +void WorldPlayersResult::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldPlayersResult::clear_players() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.players_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); +} +WorldPlayersResult::WorldPlayersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendTipAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.SendTipAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldPlayersResult) } -PROTOBUF_NDEBUG_INLINE SendTipAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::SendTipAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldPlayersResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_), - message_(arena, from.message_) {} + players_{visibility, arena, from.players_} {} -SendTipAction::SendTipAction( +WorldPlayersResult::WorldPlayersResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const SendTipAction& from) + const WorldPlayersResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, SendTipAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - SendTipAction* const _this = this; + WorldPlayersResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.SendTipAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldPlayersResult) } -PROTOBUF_NDEBUG_INLINE SendTipAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena), - message_(arena) {} + players_{visibility, arena} {} -inline void SendTipAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldPlayersResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.world_ = {}; } -SendTipAction::~SendTipAction() { - // @@protoc_insertion_point(destructor:df.plugin.SendTipAction) +WorldPlayersResult::~WorldPlayersResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldPlayersResult) SharedDtor(*this); } -inline void SendTipAction::SharedDtor(MessageLite& self) { - SendTipAction& this_ = static_cast(self); +inline void WorldPlayersResult::SharedDtor(MessageLite& self) { + WorldPlayersResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - this_._impl_.message_.Destroy(); + delete this_._impl_.world_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL SendTipAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldPlayersResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) SendTipAction(arena); + return ::new (mem) WorldPlayersResult(arena); } -constexpr auto SendTipAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(SendTipAction), - alignof(SendTipAction)); +constexpr auto WorldPlayersResult::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_) + + decltype(WorldPlayersResult::_impl_.players_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(WorldPlayersResult), alignof(WorldPlayersResult), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&WorldPlayersResult::PlacementNew_, + sizeof(WorldPlayersResult), + alignof(WorldPlayersResult)); + } } -constexpr auto SendTipAction::InternalGenerateClassData_() { +constexpr auto WorldPlayersResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_SendTipAction_default_instance_._instance, + &_WorldPlayersResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &SendTipAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldPlayersResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &SendTipAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &SendTipAction::ByteSizeLong, - &SendTipAction::_InternalSerialize, + &WorldPlayersResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldPlayersResult::ByteSizeLong, + &WorldPlayersResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._cached_size_), false, }, - &SendTipAction::kDescriptorMethods, + &WorldPlayersResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull SendTipAction_class_data_ = - SendTipAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldPlayersResult_class_data_ = + WorldPlayersResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -SendTipAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&SendTipAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(SendTipAction_class_data_.tc_table); - return SendTipAction_class_data_.base(); +WorldPlayersResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldPlayersResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldPlayersResult_class_data_.tc_table); + return WorldPlayersResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 50, 2> -SendTipAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldPlayersResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - SendTipAction_class_data_.base(), + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + WorldPlayersResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::SendTipAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldPlayersResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string message = 2 [json_name = "message"]; - {::_pbi::TcParser::FastUS1, - {18, 1, 0, - PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.message_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.player_uuid_)}}, + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + {::_pbi::TcParser::FastMtR1, + {18, 0, 1, + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_)}}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {::_pbi::TcParser::FastMtS1, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string message = 2 [json_name = "message"]; - {PROTOBUF_FIELD_OFFSET(SendTipAction, _impl_.message_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, - // no aux_entries {{ - "\27\13\7\0\0\0\0\0" - "df.plugin.SendTipAction" - "player_uuid" - "message" }}, }; -PROTOBUF_NOINLINE void SendTipAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.SendTipAction) +PROTOBUF_NOINLINE void WorldPlayersResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldPlayersResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -7735,11 +14371,12 @@ PROTOBUF_NOINLINE void SendTipAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _impl_.players_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.message_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); } } _impl_._has_bits_.Clear(); @@ -7747,41 +14384,41 @@ PROTOBUF_NOINLINE void SendTipAction::Clear() { } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL SendTipAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const SendTipAction& this_ = static_cast(base); + const WorldPlayersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL SendTipAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const SendTipAction& this_ = *this; + const WorldPlayersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.SendTipAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldPlayersResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTipAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, + stream); } - // string message = 2 [json_name = "message"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - const ::std::string& _s = this_._internal_message(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.SendTipAction.message"); - target = stream->WriteStringMaybeAliased(2, _s, target); + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + for (unsigned i = 0, n = static_cast( + this_._internal_players_size()); + i < n; i++) { + const auto& repfield = this_._internal_players().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); } } @@ -7790,18 +14427,18 @@ ::uint8_t* PROTOBUF_NONNULL SendTipAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.SendTipAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldPlayersResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t SendTipAction::ByteSizeLong(const MessageLite& base) { - const SendTipAction& this_ = static_cast(base); +::size_t WorldPlayersResult::ByteSizeLong(const MessageLite& base) { + const WorldPlayersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t SendTipAction::ByteSizeLong() const { - const SendTipAction& this_ = *this; +::size_t WorldPlayersResult::ByteSizeLong() const { + const WorldPlayersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.SendTipAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldPlayersResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -7811,56 +14448,50 @@ ::size_t SendTipAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + total_size += 1UL * this_._internal_players_size(); + for (const auto& msg : this_._internal_players()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } } - // string message = 2 [json_name = "message"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_message().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_message()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void SendTipAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldPlayersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.SendTipAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldPlayersResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); - } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } - } + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _this->_internal_mutable_players()->InternalMergeFromWithArena( + ::google::protobuf::MessageLite::internal_visibility(), arena, + from._internal_players()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_message().empty()) { - _this->_internal_set_message(from._internal_message()); + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.message_.IsDefault()) { - _this->_internal_set_message(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } } @@ -7869,309 +14500,291 @@ void SendTipAction::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void SendTipAction::CopyFrom(const SendTipAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.SendTipAction) +void WorldPlayersResult::CopyFrom(const WorldPlayersResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldPlayersResult) if (&from == this) return; Clear(); MergeFrom(from); } -void SendTipAction::InternalSwap(SendTipAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldPlayersResult::InternalSwap(WorldPlayersResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.message_, &other->_impl_.message_, arena); + _impl_.players_.InternalSwap(&other->_impl_.players_); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata SendTipAction::GetMetadata() const { +::google::protobuf::Metadata WorldPlayersResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class PlaySoundAction::_Internal { +class WorldViewersResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._has_bits_); }; -void PlaySoundAction::clear_position() { +void WorldViewersResult::clear_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ != nullptr) _impl_.world_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +void WorldViewersResult::clear_position() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.position_ != nullptr) _impl_.position_->Clear(); ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + 0x00000004U); } -PlaySoundAction::PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldViewersResult::WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, PlaySoundAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldViewersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldViewersResult) } -PROTOBUF_NDEBUG_INLINE PlaySoundAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldViewersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::PlaySoundAction& from_msg) + [[maybe_unused]] const ::df::plugin::WorldViewersResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_) {} + viewer_uuids_{visibility, arena, from.viewer_uuids_} {} -PlaySoundAction::PlaySoundAction( +WorldViewersResult::WorldViewersResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const PlaySoundAction& from) + const WorldViewersResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, PlaySoundAction_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldViewersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - PlaySoundAction* const _this = this; + WorldViewersResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) + : nullptr; + _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000004U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) : nullptr; - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, sound_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, sound_), - offsetof(Impl_, pitch_) - - offsetof(Impl_, sound_) + - sizeof(Impl_::pitch_)); - // @@protoc_insertion_point(copy_constructor:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldViewersResult) } -PROTOBUF_NDEBUG_INLINE PlaySoundAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldViewersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena) {} + viewer_uuids_{visibility, arena} {} -inline void PlaySoundAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldViewersResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, position_), + offsetof(Impl_, world_), 0, - offsetof(Impl_, pitch_) - - offsetof(Impl_, position_) + - sizeof(Impl_::pitch_)); + offsetof(Impl_, position_) - + offsetof(Impl_, world_) + + sizeof(Impl_::position_)); } -PlaySoundAction::~PlaySoundAction() { - // @@protoc_insertion_point(destructor:df.plugin.PlaySoundAction) +WorldViewersResult::~WorldViewersResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldViewersResult) SharedDtor(*this); } -inline void PlaySoundAction::SharedDtor(MessageLite& self) { - PlaySoundAction& this_ = static_cast(self); +inline void WorldViewersResult::SharedDtor(MessageLite& self) { + WorldViewersResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); + delete this_._impl_.world_; delete this_._impl_.position_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL PlaySoundAction::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldViewersResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) PlaySoundAction(arena); + return ::new (mem) WorldViewersResult(arena); } -constexpr auto PlaySoundAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(PlaySoundAction), - alignof(PlaySoundAction)); +constexpr auto WorldViewersResult::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_) + + decltype(WorldViewersResult::_impl_.viewer_uuids_):: + InternalGetArenaOffset( + ::google::protobuf::Message::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::ZeroInit( + sizeof(WorldViewersResult), alignof(WorldViewersResult), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&WorldViewersResult::PlacementNew_, + sizeof(WorldViewersResult), + alignof(WorldViewersResult)); + } } -constexpr auto PlaySoundAction::InternalGenerateClassData_() { +constexpr auto WorldViewersResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_PlaySoundAction_default_instance_._instance, + &_WorldViewersResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &PlaySoundAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldViewersResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &PlaySoundAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &PlaySoundAction::ByteSizeLong, - &PlaySoundAction::_InternalSerialize, + &WorldViewersResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldViewersResult::ByteSizeLong, + &WorldViewersResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._cached_size_), false, }, - &PlaySoundAction::kDescriptorMethods, + &WorldViewersResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull PlaySoundAction_class_data_ = - PlaySoundAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_ = + WorldViewersResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -PlaySoundAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&PlaySoundAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(PlaySoundAction_class_data_.tc_table); - return PlaySoundAction_class_data_.base(); +WorldViewersResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldViewersResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldViewersResult_class_data_.tc_table); + return WorldViewersResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 5, 1, 45, 2> -PlaySoundAction::_table_ = { +const ::_pbi::TcParseTable<2, 3, 2, 49, 2> +WorldViewersResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._has_bits_), 0, // no _extensions_ - 5, 56, // max_field_number, fast_idx_mask + 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967264, // skipmap + 4294967288, // skipmap offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 1, // num_aux_entries + 3, // num_field_entries + 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), - PlaySoundAction_class_data_.base(), + WorldViewersResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::PlaySoundAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldViewersResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ {::_pbi::TcParser::MiniParse, {}}, - // string player_uuid = 1 [json_name = "playerUuid"]; - {::_pbi::TcParser::FastUS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.player_uuid_)}}, - // .df.plugin.Sound sound = 2 [json_name = "sound"]; - {::_pbi::TcParser::SingularVarintNoZag1<::uint32_t, offsetof(PlaySoundAction, _impl_.sound_), 2>(), - {16, 2, 0, - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.sound_)}}, - // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, - {26, 1, 0, - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_)}}, - // optional float volume = 4 [json_name = "volume"]; - {::_pbi::TcParser::FastF32S1, - {37, 3, 0, - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.volume_)}}, - // optional float pitch = 5 [json_name = "pitch"]; - {::_pbi::TcParser::FastF32S1, - {45, 4, 0, - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, + {10, 1, 0, + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_)}}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_)}}, + // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + {::_pbi::TcParser::FastUR1, + {26, 0, 0, + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // .df.plugin.Sound sound = 2 [json_name = "sound"]; - {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.sound_), _Internal::kHasBitsOffset + 2, 0, (0 | ::_fl::kFcOptional | ::_fl::kOpenEnum)}, - // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; - {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // optional float volume = 4 [json_name = "volume"]; - {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.volume_), _Internal::kHasBitsOffset + 3, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, - // optional float pitch = 5 [json_name = "pitch"]; - {PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_), _Internal::kHasBitsOffset + 4, 0, (0 | ::_fl::kFcOptional | ::_fl::kFloat)}, + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, }}, {{ + {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, }}, {{ - "\31\13\0\0\0\0\0\0" - "df.plugin.PlaySoundAction" - "player_uuid" + "\34\0\0\14\0\0\0\0" + "df.plugin.WorldViewersResult" + "viewer_uuids" }}, }; -PROTOBUF_NOINLINE void PlaySoundAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.PlaySoundAction) +PROTOBUF_NOINLINE void WorldViewersResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldViewersResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _impl_.viewer_uuids_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.world_ != nullptr); + _impl_.world_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { ABSL_DCHECK(_impl_.position_ != nullptr); _impl_.position_->Clear(); } } - if (BatchCheckHasBit(cached_has_bits, 0x0000001cU)) { - ::memset(&_impl_.sound_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.pitch_) - - reinterpret_cast(&_impl_.sound_)) + sizeof(_impl_.pitch_)); - } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL PlaySoundAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const PlaySoundAction& this_ = static_cast(base); + const WorldViewersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL PlaySoundAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const PlaySoundAction& this_ = *this; + const WorldViewersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldViewersResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.PlaySoundAction.player_uuid"); - target = stream->WriteStringMaybeAliased(1, _s, target); - } - } - - // .df.plugin.Sound sound = 2 [json_name = "sound"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_sound() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteEnumToArray( - 2, this_._internal_sound(), target); - } - } - - // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, stream); } - // optional float volume = 4 [json_name = "volume"]; - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray( - 4, this_._internal_volume(), target); + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, + stream); } - // optional float pitch = 5 [json_name = "pitch"]; - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteFloatToArray( - 5, this_._internal_pitch(), target); + // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + for (int i = 0, n = this_._internal_viewer_uuids_size(); i < n; ++i) { + const auto& s = this_._internal_viewer_uuids().Get(i); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.WorldViewersResult.viewer_uuids"); + target = stream->WriteString(3, s, target); + } } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -8179,18 +14792,18 @@ ::uint8_t* PROTOBUF_NONNULL PlaySoundAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldViewersResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t PlaySoundAction::ByteSizeLong(const MessageLite& base) { - const PlaySoundAction& this_ = static_cast(base); +::size_t WorldViewersResult::ByteSizeLong(const MessageLite& base) { + const WorldViewersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t PlaySoundAction::ByteSizeLong() const { - const PlaySoundAction& this_ = *this; +::size_t WorldViewersResult::ByteSizeLong() const { + const WorldViewersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldViewersResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -8199,58 +14812,61 @@ ::size_t PlaySoundAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - total_size += ::absl::popcount(0x00000018U & cached_has_bits) * 5; if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); + // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + total_size += + 1 * ::google::protobuf::internal::FromIntSize(this_._internal_viewer_uuids().size()); + for (int i = 0, n = this_._internal_viewer_uuids().size(); i < n; ++i) { + total_size += ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_viewer_uuids().Get(i)); } } - // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.Sound sound = 2 [json_name = "sound"]; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (this_._internal_sound() != 0) { - total_size += 1 + - ::_pbi::WireFormatLite::EnumSize(this_._internal_sound()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void PlaySoundAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldViewersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldViewersResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x0000001fU)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { + _this->_internal_mutable_viewer_uuids()->InternalMergeFromWithArena( + ::google::protobuf::MessageLite::internal_visibility(), arena, + from._internal_viewer_uuids()); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.world_ != nullptr); + if (_this->_impl_.world_ == nullptr) { + _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); - } + _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (CheckHasBit(cached_has_bits, 0x00000004U)) { ABSL_DCHECK(from._impl_.position_ != nullptr); if (_this->_impl_.position_ == nullptr) { _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); @@ -8258,207 +14874,331 @@ void PlaySoundAction::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.position_->MergeFrom(*from._impl_.position_); } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - if (from._internal_sound() != 0) { - _this->_impl_.sound_ = from._impl_.sound_; - } - } - if (CheckHasBit(cached_has_bits, 0x00000008U)) { - _this->_impl_.volume_ = from._impl_.volume_; - } - if (CheckHasBit(cached_has_bits, 0x00000010U)) { - _this->_impl_.pitch_ = from._impl_.pitch_; - } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void PlaySoundAction::CopyFrom(const PlaySoundAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.PlaySoundAction) +void WorldViewersResult::CopyFrom(const WorldViewersResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldViewersResult) if (&from == this) return; Clear(); MergeFrom(from); } -void PlaySoundAction::InternalSwap(PlaySoundAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldViewersResult::InternalSwap(WorldViewersResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); + _impl_.viewer_uuids_.InternalSwap(&other->_impl_.viewer_uuids_); ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.pitch_) - + sizeof(PlaySoundAction::_impl_.pitch_) - - PROTOBUF_FIELD_OFFSET(PlaySoundAction, _impl_.position_)>( - reinterpret_cast(&_impl_.position_), - reinterpret_cast(&other->_impl_.position_)); + PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_) + + sizeof(WorldViewersResult::_impl_.position_) + - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata PlaySoundAction::GetMetadata() const { +::google::protobuf::Metadata WorldViewersResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } -// =================================================================== - -class ExecuteCommandAction::_Internal { - public: - using HasBits = - decltype(::std::declval()._impl_._has_bits_); - static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._has_bits_); -}; - -ExecuteCommandAction::ExecuteCommandAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +// =================================================================== + +class ActionResult::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(ActionResult, _impl_._has_bits_); + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_._oneof_case_); +}; + +void ActionResult::set_allocated_world_entities(::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE world_entities) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_result(); + if (world_entities) { + ::google::protobuf::Arena* submessage_arena = world_entities->GetArena(); + if (message_arena != submessage_arena) { + world_entities = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_entities, submessage_arena); + } + set_has_world_entities(); + _impl_.result_.world_entities_ = world_entities; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_entities) +} +void ActionResult::set_allocated_world_players(::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE world_players) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_result(); + if (world_players) { + ::google::protobuf::Arena* submessage_arena = world_players->GetArena(); + if (message_arena != submessage_arena) { + world_players = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_players, submessage_arena); + } + set_has_world_players(); + _impl_.result_.world_players_ = world_players; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_players) +} +void ActionResult::set_allocated_world_entities_within(::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE world_entities_within) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_result(); + if (world_entities_within) { + ::google::protobuf::Arena* submessage_arena = world_entities_within->GetArena(); + if (message_arena != submessage_arena) { + world_entities_within = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_entities_within, submessage_arena); + } + set_has_world_entities_within(); + _impl_.result_.world_entities_within_ = world_entities_within; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_entities_within) +} +void ActionResult::set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE world_viewers) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_result(); + if (world_viewers) { + ::google::protobuf::Arena* submessage_arena = world_viewers->GetArena(); + if (message_arena != submessage_arena) { + world_viewers = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_viewers, submessage_arena); + } + set_has_world_viewers(); + _impl_.result_.world_viewers_ = world_viewers; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_viewers) +} +ActionResult::ActionResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ExecuteCommandAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.ExecuteCommandAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.ActionResult) } -PROTOBUF_NDEBUG_INLINE ExecuteCommandAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::ExecuteCommandAction& from_msg) + [[maybe_unused]] const ::df::plugin::ActionResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - player_uuid_(arena, from.player_uuid_), - command_(arena, from.command_) {} + correlation_id_(arena, from.correlation_id_), + result_{}, + _oneof_case_{from._oneof_case_[0]} {} -ExecuteCommandAction::ExecuteCommandAction( +ActionResult::ActionResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const ExecuteCommandAction& from) + const ActionResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ExecuteCommandAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - ExecuteCommandAction* const _this = this; + ActionResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.status_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.status_) + : nullptr; + switch (result_case()) { + case RESULT_NOT_SET: + break; + case kWorldEntities: + _impl_.result_.world_entities_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_entities_); + break; + case kWorldPlayers: + _impl_.result_.world_players_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_players_); + break; + case kWorldEntitiesWithin: + _impl_.result_.world_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_entities_within_); + break; + case kWorldViewers: + _impl_.result_.world_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_viewers_); + break; + } - // @@protoc_insertion_point(copy_constructor:df.plugin.ExecuteCommandAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.ActionResult) } -PROTOBUF_NDEBUG_INLINE ExecuteCommandAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - player_uuid_(arena), - command_(arena) {} + correlation_id_(arena), + result_{}, + _oneof_case_{} {} -inline void ExecuteCommandAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void ActionResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.status_ = {}; } -ExecuteCommandAction::~ExecuteCommandAction() { - // @@protoc_insertion_point(destructor:df.plugin.ExecuteCommandAction) +ActionResult::~ActionResult() { + // @@protoc_insertion_point(destructor:df.plugin.ActionResult) SharedDtor(*this); } -inline void ExecuteCommandAction::SharedDtor(MessageLite& self) { - ExecuteCommandAction& this_ = static_cast(self); +inline void ActionResult::SharedDtor(MessageLite& self) { + ActionResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.player_uuid_.Destroy(); - this_._impl_.command_.Destroy(); + this_._impl_.correlation_id_.Destroy(); + delete this_._impl_.status_; + if (this_.has_result()) { + this_.clear_result(); + } this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL ExecuteCommandAction::PlacementNew_( +void ActionResult::clear_result() { +// @@protoc_insertion_point(one_of_clear_start:df.plugin.ActionResult) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (result_case()) { + case kWorldEntities: { + if (GetArena() == nullptr) { + delete _impl_.result_.world_entities_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_entities_); + } + break; + } + case kWorldPlayers: { + if (GetArena() == nullptr) { + delete _impl_.result_.world_players_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_players_); + } + break; + } + case kWorldEntitiesWithin: { + if (GetArena() == nullptr) { + delete _impl_.result_.world_entities_within_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_entities_within_); + } + break; + } + case kWorldViewers: { + if (GetArena() == nullptr) { + delete _impl_.result_.world_viewers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_viewers_); + } + break; + } + case RESULT_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = RESULT_NOT_SET; +} + + +inline void* PROTOBUF_NONNULL ActionResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) ExecuteCommandAction(arena); + return ::new (mem) ActionResult(arena); } -constexpr auto ExecuteCommandAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ExecuteCommandAction), - alignof(ExecuteCommandAction)); +constexpr auto ActionResult::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ActionResult), + alignof(ActionResult)); } -constexpr auto ExecuteCommandAction::InternalGenerateClassData_() { +constexpr auto ActionResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_ExecuteCommandAction_default_instance_._instance, + &_ActionResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &ExecuteCommandAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &ActionResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &ExecuteCommandAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &ExecuteCommandAction::ByteSizeLong, - &ExecuteCommandAction::_InternalSerialize, + &ActionResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ActionResult::ByteSizeLong, + &ActionResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(ActionResult, _impl_._cached_size_), false, }, - &ExecuteCommandAction::kDescriptorMethods, + &ActionResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull ExecuteCommandAction_class_data_ = - ExecuteCommandAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull ActionResult_class_data_ = + ActionResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -ExecuteCommandAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&ExecuteCommandAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(ExecuteCommandAction_class_data_.tc_table); - return ExecuteCommandAction_class_data_.base(); +ActionResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ActionResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ActionResult_class_data_.tc_table); + return ActionResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 57, 2> -ExecuteCommandAction::_table_ = { +const ::_pbi::TcParseTable<1, 6, 5, 45, 2> +ActionResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(ActionResult, _impl_._has_bits_), 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask + 13, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap + 4294959612, // skipmap offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - ExecuteCommandAction_class_data_.base(), + 6, // num_field_entries + 5, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + ActionResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::ExecuteCommandAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::ActionResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // string command = 2 [json_name = "command"]; - {::_pbi::TcParser::FastUS1, + // optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + {::_pbi::TcParser::FastMtS1, {18, 1, 0, - PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.command_)}}, - // string player_uuid = 1 [json_name = "playerUuid"]; + PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.status_)}}, + // string correlation_id = 1 [json_name = "correlationId"]; {::_pbi::TcParser::FastUS1, {10, 0, 0, - PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.player_uuid_)}}, + PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.correlation_id_)}}, }}, {{ 65535, 65535 }}, {{ - // string player_uuid = 1 [json_name = "playerUuid"]; - {PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.player_uuid_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string command = 2 [json_name = "command"]; - {PROTOBUF_FIELD_OFFSET(ExecuteCommandAction, _impl_.command_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string correlation_id = 1 [json_name = "correlationId"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.correlation_id_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.status_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_entities_), _Internal::kOneofCaseOffset + 0, 1, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_players_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_entities_within_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; + {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_viewers_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, }}, - // no aux_entries {{ - "\36\13\7\0\0\0\0\0" - "df.plugin.ExecuteCommandAction" - "player_uuid" - "command" + {::_pbi::TcParser::GetTable<::df::plugin::ActionStatus>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesResult>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldPlayersResult>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesWithinResult>()}, + {::_pbi::TcParser::GetTable<::df::plugin::WorldViewersResult>()}, + }}, + {{ + "\26\16\0\0\0\0\0\0" + "df.plugin.ActionResult" + "correlation_id" }}, }; -PROTOBUF_NOINLINE void ExecuteCommandAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.ExecuteCommandAction) +PROTOBUF_NOINLINE void ActionResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.ActionResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused @@ -8467,72 +15207,99 @@ PROTOBUF_NOINLINE void ExecuteCommandAction::Clear() { cached_has_bits = _impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.player_uuid_.ClearNonDefaultToEmpty(); + _impl_.correlation_id_.ClearNonDefaultToEmpty(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - _impl_.command_.ClearNonDefaultToEmpty(); + ABSL_DCHECK(_impl_.status_ != nullptr); + _impl_.status_->Clear(); } } + clear_result(); _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL ExecuteCommandAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const ExecuteCommandAction& this_ = static_cast(base); + const ActionResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL ExecuteCommandAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const ExecuteCommandAction& this_ = *this; + const ActionResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ExecuteCommandAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ActionResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // string player_uuid = 1 [json_name = "playerUuid"]; + // string correlation_id = 1 [json_name = "correlationId"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { - const ::std::string& _s = this_._internal_player_uuid(); + if (!this_._internal_correlation_id().empty()) { + const ::std::string& _s = this_._internal_correlation_id(); ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ExecuteCommandAction.player_uuid"); + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ActionResult.correlation_id"); target = stream->WriteStringMaybeAliased(1, _s, target); } } - // string command = 2 [json_name = "command"]; + // optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_command().empty()) { - const ::std::string& _s = this_._internal_command(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ExecuteCommandAction.command"); - target = stream->WriteStringMaybeAliased(2, _s, target); - } + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.status_, this_._impl_.status_->GetCachedSize(), target, + stream); } + switch (this_.result_case()) { + case kWorldEntities: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 10, *this_._impl_.result_.world_entities_, this_._impl_.result_.world_entities_->GetCachedSize(), target, + stream); + break; + } + case kWorldPlayers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 11, *this_._impl_.result_.world_players_, this_._impl_.result_.world_players_->GetCachedSize(), target, + stream); + break; + } + case kWorldEntitiesWithin: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 12, *this_._impl_.result_.world_entities_within_, this_._impl_.result_.world_entities_within_->GetCachedSize(), target, + stream); + break; + } + case kWorldViewers: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 13, *this_._impl_.result_.world_viewers_, this_._impl_.result_.world_viewers_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ExecuteCommandAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ActionResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t ExecuteCommandAction::ByteSizeLong(const MessageLite& base) { - const ExecuteCommandAction& this_ = static_cast(base); +::size_t ActionResult::ByteSizeLong(const MessageLite& base) { + const ActionResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t ExecuteCommandAction::ByteSizeLong() const { - const ExecuteCommandAction& this_ = *this; +::size_t ActionResult::ByteSizeLong() const { + const ActionResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.ExecuteCommandAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.ActionResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -8542,34 +15309,62 @@ ::size_t ExecuteCommandAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // string player_uuid = 1 [json_name = "playerUuid"]; + // string correlation_id = 1 [json_name = "correlationId"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!this_._internal_player_uuid().empty()) { + if (!this_._internal_correlation_id().empty()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_player_uuid()); + this_._internal_correlation_id()); } } - // string command = 2 [json_name = "command"]; + // optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!this_._internal_command().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_command()); - } + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.status_); + } + } + switch (this_.result_case()) { + // .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; + case kWorldEntities: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_entities_); + break; + } + // .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; + case kWorldPlayers: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_players_); + break; + } + // .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; + case kWorldEntitiesWithin: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_entities_within_); + break; + } + // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; + case kWorldViewers: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_viewers_); + break; + } + case RESULT_NOT_SET: { + break; } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void ExecuteCommandAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void ActionResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ExecuteCommandAction) + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ActionResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -8577,48 +15372,97 @@ void ExecuteCommandAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - if (!from._internal_player_uuid().empty()) { - _this->_internal_set_player_uuid(from._internal_player_uuid()); + if (!from._internal_correlation_id().empty()) { + _this->_internal_set_correlation_id(from._internal_correlation_id()); } else { - if (_this->_impl_.player_uuid_.IsDefault()) { - _this->_internal_set_player_uuid(""); + if (_this->_impl_.correlation_id_.IsDefault()) { + _this->_internal_set_correlation_id(""); } } } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (!from._internal_command().empty()) { - _this->_internal_set_command(from._internal_command()); + ABSL_DCHECK(from._impl_.status_ != nullptr); + if (_this->_impl_.status_ == nullptr) { + _this->_impl_.status_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.status_); } else { - if (_this->_impl_.command_.IsDefault()) { - _this->_internal_set_command(""); - } + _this->_impl_.status_->MergeFrom(*from._impl_.status_); } } } _this->_impl_._has_bits_[0] |= cached_has_bits; + if (const uint32_t oneof_from_case = + from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_result(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kWorldEntities: { + if (oneof_needs_init) { + _this->_impl_.result_.world_entities_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_entities_); + } else { + _this->_impl_.result_.world_entities_->MergeFrom(*from._impl_.result_.world_entities_); + } + break; + } + case kWorldPlayers: { + if (oneof_needs_init) { + _this->_impl_.result_.world_players_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_players_); + } else { + _this->_impl_.result_.world_players_->MergeFrom(*from._impl_.result_.world_players_); + } + break; + } + case kWorldEntitiesWithin: { + if (oneof_needs_init) { + _this->_impl_.result_.world_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_entities_within_); + } else { + _this->_impl_.result_.world_entities_within_->MergeFrom(*from._impl_.result_.world_entities_within_); + } + break; + } + case kWorldViewers: { + if (oneof_needs_init) { + _this->_impl_.result_.world_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_viewers_); + } else { + _this->_impl_.result_.world_viewers_->MergeFrom(*from._impl_.result_.world_viewers_); + } + break; + } + case RESULT_NOT_SET: + break; + } + } _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void ExecuteCommandAction::CopyFrom(const ExecuteCommandAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ExecuteCommandAction) +void ActionResult::CopyFrom(const ActionResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ActionResult) if (&from == this) return; Clear(); MergeFrom(from); } -void ExecuteCommandAction::InternalSwap(ExecuteCommandAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void ActionResult::InternalSwap(ActionResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; auto* arena = GetArena(); ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.player_uuid_, &other->_impl_.player_uuid_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.command_, &other->_impl_.command_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.correlation_id_, &other->_impl_.correlation_id_, arena); + swap(_impl_.status_, other->_impl_.status_); + swap(_impl_.result_, other->_impl_.result_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); } -::google::protobuf::Metadata ExecuteCommandAction::GetMetadata() const { +::google::protobuf::Metadata ActionResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // @@protoc_insertion_point(namespace_scope) diff --git a/packages/cpp/src/generated/actions.pb.h b/packages/cpp/src/generated/actions.pb.h index c546397..5a581e5 100644 --- a/packages/cpp/src/generated/actions.pb.h +++ b/packages/cpp/src/generated/actions.pb.h @@ -28,6 +28,7 @@ #include "google/protobuf/message_lite.h" #include "google/protobuf/repeated_field.h" // IWYU pragma: export #include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "google/protobuf/generated_enum_reflection.h" #include "google/protobuf/unknown_field_set.h" #include "common.pb.h" // @@protoc_insertion_point(includes) @@ -55,6 +56,8 @@ extern const ::google::protobuf::internal::DescriptorTable descriptor_table_acti } // extern "C" namespace df { namespace plugin { +enum ParticleType : int; +extern const uint32_t ParticleType_internal_data_[]; class Action; struct ActionDefaultTypeInternal; extern ActionDefaultTypeInternal _Action_default_instance_; @@ -63,6 +66,14 @@ class ActionBatch; struct ActionBatchDefaultTypeInternal; extern ActionBatchDefaultTypeInternal _ActionBatch_default_instance_; extern const ::google::protobuf::internal::ClassDataFull ActionBatch_class_data_; +class ActionResult; +struct ActionResultDefaultTypeInternal; +extern ActionResultDefaultTypeInternal _ActionResult_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ActionResult_class_data_; +class ActionStatus; +struct ActionStatusDefaultTypeInternal; +extern ActionStatusDefaultTypeInternal _ActionStatus_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_; class AddEffectAction; struct AddEffectActionDefaultTypeInternal; extern AddEffectActionDefaultTypeInternal _AddEffectAction_default_instance_; @@ -135,15 +146,127 @@ class TeleportAction; struct TeleportActionDefaultTypeInternal; extern TeleportActionDefaultTypeInternal _TeleportAction_default_instance_; extern const ::google::protobuf::internal::ClassDataFull TeleportAction_class_data_; +class WorldAddParticleAction; +struct WorldAddParticleActionDefaultTypeInternal; +extern WorldAddParticleActionDefaultTypeInternal _WorldAddParticleAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldAddParticleAction_class_data_; +class WorldEntitiesResult; +struct WorldEntitiesResultDefaultTypeInternal; +extern WorldEntitiesResultDefaultTypeInternal _WorldEntitiesResult_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldEntitiesResult_class_data_; +class WorldEntitiesWithinResult; +struct WorldEntitiesWithinResultDefaultTypeInternal; +extern WorldEntitiesWithinResultDefaultTypeInternal _WorldEntitiesWithinResult_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldEntitiesWithinResult_class_data_; +class WorldPlaySoundAction; +struct WorldPlaySoundActionDefaultTypeInternal; +extern WorldPlaySoundActionDefaultTypeInternal _WorldPlaySoundAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldPlaySoundAction_class_data_; +class WorldPlayersResult; +struct WorldPlayersResultDefaultTypeInternal; +extern WorldPlayersResultDefaultTypeInternal _WorldPlayersResult_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldPlayersResult_class_data_; +class WorldQueryEntitiesAction; +struct WorldQueryEntitiesActionDefaultTypeInternal; +extern WorldQueryEntitiesActionDefaultTypeInternal _WorldQueryEntitiesAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesAction_class_data_; +class WorldQueryEntitiesWithinAction; +struct WorldQueryEntitiesWithinActionDefaultTypeInternal; +extern WorldQueryEntitiesWithinActionDefaultTypeInternal _WorldQueryEntitiesWithinAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesWithinAction_class_data_; +class WorldQueryPlayersAction; +struct WorldQueryPlayersActionDefaultTypeInternal; +extern WorldQueryPlayersActionDefaultTypeInternal _WorldQueryPlayersAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldQueryPlayersAction_class_data_; +class WorldQueryViewersAction; +struct WorldQueryViewersActionDefaultTypeInternal; +extern WorldQueryViewersActionDefaultTypeInternal _WorldQueryViewersAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_; +class WorldSetBlockAction; +struct WorldSetBlockActionDefaultTypeInternal; +extern WorldSetBlockActionDefaultTypeInternal _WorldSetBlockAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetBlockAction_class_data_; +class WorldSetDefaultGameModeAction; +struct WorldSetDefaultGameModeActionDefaultTypeInternal; +extern WorldSetDefaultGameModeActionDefaultTypeInternal _WorldSetDefaultGameModeAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetDefaultGameModeAction_class_data_; +class WorldSetDifficultyAction; +struct WorldSetDifficultyActionDefaultTypeInternal; +extern WorldSetDifficultyActionDefaultTypeInternal _WorldSetDifficultyAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetDifficultyAction_class_data_; +class WorldSetTickRangeAction; +struct WorldSetTickRangeActionDefaultTypeInternal; +extern WorldSetTickRangeActionDefaultTypeInternal _WorldSetTickRangeAction_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetTickRangeAction_class_data_; +class WorldViewersResult; +struct WorldViewersResultDefaultTypeInternal; +extern WorldViewersResultDefaultTypeInternal _WorldViewersResult_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_; } // namespace plugin } // namespace df namespace google { namespace protobuf { +template <> +internal::EnumTraitsT<::df::plugin::ParticleType_internal_data_> + internal::EnumTraitsImpl::value<::df::plugin::ParticleType>; } // namespace protobuf } // namespace google namespace df { namespace plugin { +enum ParticleType : int { + PARTICLE_TYPE_UNSPECIFIED = 0, + PARTICLE_HUGE_EXPLOSION = 1, + PARTICLE_ENDERMAN_TELEPORT = 2, + PARTICLE_SNOWBALL_POOF = 3, + PARTICLE_EGG_SMASH = 4, + PARTICLE_SPLASH = 5, + PARTICLE_EFFECT = 6, + PARTICLE_ENTITY_FLAME = 7, + PARTICLE_FLAME = 8, + PARTICLE_DUST = 9, + PARTICLE_BLOCK_FORCE_FIELD = 10, + PARTICLE_BONE_MEAL = 11, + PARTICLE_EVAPORATE = 12, + PARTICLE_WATER_DRIP = 13, + PARTICLE_LAVA_DRIP = 14, + PARTICLE_LAVA = 15, + PARTICLE_DUST_PLUME = 16, + PARTICLE_BLOCK_BREAK = 17, + PARTICLE_PUNCH_BLOCK = 18, + ParticleType_INT_MIN_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::min(), + ParticleType_INT_MAX_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::max(), +}; + +extern const uint32_t ParticleType_internal_data_[]; +inline constexpr ParticleType ParticleType_MIN = + static_cast(0); +inline constexpr ParticleType ParticleType_MAX = + static_cast(18); +inline bool ParticleType_IsValid(int value) { + return 0 <= value && value <= 18; +} +inline constexpr int ParticleType_ARRAYSIZE = 18 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ParticleType_descriptor(); +template +const ::std::string& ParticleType_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to ParticleType_Name()."); + return ParticleType_Name(static_cast(value)); +} +template <> +inline const ::std::string& ParticleType_Name(ParticleType value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool ParticleType_Parse( + ::absl::string_view name, ParticleType* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(ParticleType_descriptor(), name, + value); +} // =================================================================== @@ -2992,30 +3115,30 @@ class AddEffectAction final : public ::google::protobuf::Message extern const ::google::protobuf::internal::ClassDataFull AddEffectAction_class_data_; // ------------------------------------------------------------------- -class TeleportAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.TeleportAction) */ { +class ActionStatus final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.ActionStatus) */ { public: - inline TeleportAction() : TeleportAction(nullptr) {} - ~TeleportAction() PROTOBUF_FINAL; + inline ActionStatus() : ActionStatus(nullptr) {} + ~ActionStatus() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(TeleportAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(ActionStatus* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(TeleportAction)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ActionStatus)); } #endif template - explicit PROTOBUF_CONSTEXPR TeleportAction(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR ActionStatus(::google::protobuf::internal::ConstantInitialized); - inline TeleportAction(const TeleportAction& from) : TeleportAction(nullptr, from) {} - inline TeleportAction(TeleportAction&& from) noexcept - : TeleportAction(nullptr, ::std::move(from)) {} - inline TeleportAction& operator=(const TeleportAction& from) { + inline ActionStatus(const ActionStatus& from) : ActionStatus(nullptr, from) {} + inline ActionStatus(ActionStatus&& from) noexcept + : ActionStatus(nullptr, ::std::move(from)) {} + inline ActionStatus& operator=(const ActionStatus& from) { CopyFrom(from); return *this; } - inline TeleportAction& operator=(TeleportAction&& from) noexcept { + inline ActionStatus& operator=(ActionStatus&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -3043,13 +3166,13 @@ class TeleportAction final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const TeleportAction& default_instance() { - return *reinterpret_cast( - &_TeleportAction_default_instance_); + static const ActionStatus& default_instance() { + return *reinterpret_cast( + &_ActionStatus_default_instance_); } - static constexpr int kIndexInFileMessages = 3; - friend void swap(TeleportAction& a, TeleportAction& b) { a.Swap(&b); } - inline void Swap(TeleportAction* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 30; + friend void swap(ActionStatus& a, ActionStatus& b) { a.Swap(&b); } + inline void Swap(ActionStatus* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -3057,7 +3180,7 @@ class TeleportAction final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(TeleportAction* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(ActionStatus* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3065,13 +3188,13 @@ class TeleportAction final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - TeleportAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + ActionStatus* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const TeleportAction& from); + void CopyFrom(const ActionStatus& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const TeleportAction& from) { TeleportAction::MergeImpl(*this, from); } + void MergeFrom(const ActionStatus& from) { ActionStatus::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -3107,17 +3230,17 @@ class TeleportAction final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(TeleportAction* PROTOBUF_NONNULL other); + void InternalSwap(ActionStatus* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.TeleportAction"; } + static ::absl::string_view FullMessageName() { return "df.plugin.ActionStatus"; } - explicit TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TeleportAction& from); - TeleportAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TeleportAction&& from) noexcept - : TeleportAction(arena) { + explicit ActionStatus(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ActionStatus(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ActionStatus& from); + ActionStatus( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ActionStatus&& from) noexcept + : ActionStatus(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -3134,61 +3257,41 @@ class TeleportAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPlayerUuidFieldNumber = 1, - kPositionFieldNumber = 2, - kRotationFieldNumber = 3, + kErrorFieldNumber = 2, + kOkFieldNumber = 1, }; - // string player_uuid = 1 [json_name = "playerUuid"]; - void clear_player_uuid() ; - const ::std::string& player_uuid() const; + // optional string error = 2 [json_name = "error"]; + bool has_error() const; + void clear_error() ; + const ::std::string& error() const; template - void set_player_uuid(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); - void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_player_uuid() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); - - public: - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - bool has_position() const; - void clear_position() ; - const ::df::plugin::Vec3& position() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); - void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + void set_error(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_error(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_error(); + void set_allocated_error(::std::string* PROTOBUF_NULLABLE value); private: - const ::df::plugin::Vec3& _internal_position() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + const ::std::string& _internal_error() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_error(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_error(); public: - // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; - bool has_rotation() const; - void clear_rotation() ; - const ::df::plugin::Vec3& rotation() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_rotation(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_rotation(); - void set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_rotation(); + // bool ok = 1 [json_name = "ok"]; + void clear_ok() ; + bool ok() const; + void set_ok(bool value); private: - const ::df::plugin::Vec3& _internal_rotation() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_rotation(); + bool _internal_ok() const; + void _internal_set_ok(bool value); public: - // @@protoc_insertion_point(class_scope:df.plugin.TeleportAction) + // @@protoc_insertion_point(class_scope:df.plugin.ActionStatus) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<2, 3, - 2, 44, + static const ::google::protobuf::internal::TcParseTable<1, 2, + 0, 36, 2> _table_; @@ -3206,45 +3309,44 @@ class TeleportAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const TeleportAction& from_msg); + const ActionStatus& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr player_uuid_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE rotation_; + ::google::protobuf::internal::ArenaStringPtr error_; + bool ok_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull TeleportAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_; // ------------------------------------------------------------------- -class SetVelocityAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.SetVelocityAction) */ { +class WorldViewersResult final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldViewersResult) */ { public: - inline SetVelocityAction() : SetVelocityAction(nullptr) {} - ~SetVelocityAction() PROTOBUF_FINAL; + inline WorldViewersResult() : WorldViewersResult(nullptr) {} + ~WorldViewersResult() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SetVelocityAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldViewersResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SetVelocityAction)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldViewersResult)); } #endif template - explicit PROTOBUF_CONSTEXPR SetVelocityAction(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldViewersResult(::google::protobuf::internal::ConstantInitialized); - inline SetVelocityAction(const SetVelocityAction& from) : SetVelocityAction(nullptr, from) {} - inline SetVelocityAction(SetVelocityAction&& from) noexcept - : SetVelocityAction(nullptr, ::std::move(from)) {} - inline SetVelocityAction& operator=(const SetVelocityAction& from) { + inline WorldViewersResult(const WorldViewersResult& from) : WorldViewersResult(nullptr, from) {} + inline WorldViewersResult(WorldViewersResult&& from) noexcept + : WorldViewersResult(nullptr, ::std::move(from)) {} + inline WorldViewersResult& operator=(const WorldViewersResult& from) { CopyFrom(from); return *this; } - inline SetVelocityAction& operator=(SetVelocityAction&& from) noexcept { + inline WorldViewersResult& operator=(WorldViewersResult&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -3272,13 +3374,13 @@ class SetVelocityAction final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const SetVelocityAction& default_instance() { - return *reinterpret_cast( - &_SetVelocityAction_default_instance_); + static const WorldViewersResult& default_instance() { + return *reinterpret_cast( + &_WorldViewersResult_default_instance_); } - static constexpr int kIndexInFileMessages = 12; - friend void swap(SetVelocityAction& a, SetVelocityAction& b) { a.Swap(&b); } - inline void Swap(SetVelocityAction* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 34; + friend void swap(WorldViewersResult& a, WorldViewersResult& b) { a.Swap(&b); } + inline void Swap(WorldViewersResult* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -3286,7 +3388,7 @@ class SetVelocityAction final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(SetVelocityAction* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldViewersResult* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3294,13 +3396,13 @@ class SetVelocityAction final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - SetVelocityAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldViewersResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const SetVelocityAction& from); + void CopyFrom(const WorldViewersResult& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const SetVelocityAction& from) { SetVelocityAction::MergeImpl(*this, from); } + void MergeFrom(const WorldViewersResult& from) { WorldViewersResult::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -3336,17 +3438,17 @@ class SetVelocityAction final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(SetVelocityAction* PROTOBUF_NONNULL other); + void InternalSwap(WorldViewersResult* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.SetVelocityAction"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldViewersResult"; } - explicit SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SetVelocityAction& from); - SetVelocityAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SetVelocityAction&& from) noexcept - : SetVelocityAction(arena) { + explicit WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldViewersResult& from); + WorldViewersResult( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldViewersResult&& from) noexcept + : WorldViewersResult(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -3363,45 +3465,68 @@ class SetVelocityAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPlayerUuidFieldNumber = 1, - kVelocityFieldNumber = 2, + kViewerUuidsFieldNumber = 3, + kWorldFieldNumber = 1, + kPositionFieldNumber = 2, }; - // string player_uuid = 1 [json_name = "playerUuid"]; - void clear_player_uuid() ; - const ::std::string& player_uuid() const; + // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + int viewer_uuids_size() const; + private: + int _internal_viewer_uuids_size() const; + + public: + void clear_viewer_uuids() ; + const ::std::string& viewer_uuids(int index) const; + ::std::string* PROTOBUF_NONNULL mutable_viewer_uuids(int index); template - void set_player_uuid(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); - void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + void set_viewer_uuids(int index, Arg_&& value, Args_... args); + ::std::string* PROTOBUF_NONNULL add_viewer_uuids(); + template + void add_viewer_uuids(Arg_&& value, Args_... args); + const ::google::protobuf::RepeatedPtrField<::std::string>& viewer_uuids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_viewer_uuids(); private: - const ::std::string& _internal_player_uuid() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_viewer_uuids() const; + ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_viewer_uuids(); public: - // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; - bool has_velocity() const; - void clear_velocity() ; - const ::df::plugin::Vec3& velocity() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_velocity(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_velocity(); - void set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_velocity(); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::df::plugin::Vec3& _internal_velocity() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_velocity(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // @@protoc_insertion_point(class_scope:df.plugin.SetVelocityAction) + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldViewersResult) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<1, 2, - 1, 47, + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 49, 2> _table_; @@ -3419,44 +3544,45 @@ class SetVelocityAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const SetVelocityAction& from_msg); + const WorldViewersResult& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr player_uuid_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE velocity_; + ::google::protobuf::RepeatedPtrField<::std::string> viewer_uuids_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull SetVelocityAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_; // ------------------------------------------------------------------- -class SetHeldItemAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.SetHeldItemAction) */ { +class WorldSetTickRangeAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldSetTickRangeAction) */ { public: - inline SetHeldItemAction() : SetHeldItemAction(nullptr) {} - ~SetHeldItemAction() PROTOBUF_FINAL; + inline WorldSetTickRangeAction() : WorldSetTickRangeAction(nullptr) {} + ~WorldSetTickRangeAction() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SetHeldItemAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldSetTickRangeAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SetHeldItemAction)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldSetTickRangeAction)); } #endif template - explicit PROTOBUF_CONSTEXPR SetHeldItemAction(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldSetTickRangeAction(::google::protobuf::internal::ConstantInitialized); - inline SetHeldItemAction(const SetHeldItemAction& from) : SetHeldItemAction(nullptr, from) {} - inline SetHeldItemAction(SetHeldItemAction&& from) noexcept - : SetHeldItemAction(nullptr, ::std::move(from)) {} - inline SetHeldItemAction& operator=(const SetHeldItemAction& from) { + inline WorldSetTickRangeAction(const WorldSetTickRangeAction& from) : WorldSetTickRangeAction(nullptr, from) {} + inline WorldSetTickRangeAction(WorldSetTickRangeAction&& from) noexcept + : WorldSetTickRangeAction(nullptr, ::std::move(from)) {} + inline WorldSetTickRangeAction& operator=(const WorldSetTickRangeAction& from) { CopyFrom(from); return *this; } - inline SetHeldItemAction& operator=(SetHeldItemAction&& from) noexcept { + inline WorldSetTickRangeAction& operator=(WorldSetTickRangeAction&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -3484,13 +3610,13 @@ class SetHeldItemAction final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const SetHeldItemAction& default_instance() { - return *reinterpret_cast( - &_SetHeldItemAction_default_instance_); + static const WorldSetTickRangeAction& default_instance() { + return *reinterpret_cast( + &_WorldSetTickRangeAction_default_instance_); } - static constexpr int kIndexInFileMessages = 8; - friend void swap(SetHeldItemAction& a, SetHeldItemAction& b) { a.Swap(&b); } - inline void Swap(SetHeldItemAction* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 22; + friend void swap(WorldSetTickRangeAction& a, WorldSetTickRangeAction& b) { a.Swap(&b); } + inline void Swap(WorldSetTickRangeAction* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -3498,7 +3624,7 @@ class SetHeldItemAction final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(SetHeldItemAction* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldSetTickRangeAction* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3506,13 +3632,13 @@ class SetHeldItemAction final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - SetHeldItemAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldSetTickRangeAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const SetHeldItemAction& from); + void CopyFrom(const WorldSetTickRangeAction& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const SetHeldItemAction& from) { SetHeldItemAction::MergeImpl(*this, from); } + void MergeFrom(const WorldSetTickRangeAction& from) { WorldSetTickRangeAction::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -3548,17 +3674,17 @@ class SetHeldItemAction final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(SetHeldItemAction* PROTOBUF_NONNULL other); + void InternalSwap(WorldSetTickRangeAction* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.SetHeldItemAction"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldSetTickRangeAction"; } - explicit SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SetHeldItemAction& from); - SetHeldItemAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SetHeldItemAction&& from) noexcept - : SetHeldItemAction(arena) { + explicit WorldSetTickRangeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldSetTickRangeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldSetTickRangeAction& from); + WorldSetTickRangeAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetTickRangeAction&& from) noexcept + : WorldSetTickRangeAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -3575,61 +3701,40 @@ class SetHeldItemAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPlayerUuidFieldNumber = 1, - kMainFieldNumber = 2, - kOffhandFieldNumber = 3, + kWorldFieldNumber = 1, + kTickRangeFieldNumber = 2, }; - // string player_uuid = 1 [json_name = "playerUuid"]; - void clear_player_uuid() ; - const ::std::string& player_uuid() const; - template - void set_player_uuid(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); - void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_player_uuid() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); - - public: - // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; - bool has_main() const; - void clear_main() ; - const ::df::plugin::ItemStack& main() const; - [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_main(); - ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_main(); - void set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_main(); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::df::plugin::ItemStack& _internal_main() const; - ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_main(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; - bool has_offhand() const; - void clear_offhand() ; - const ::df::plugin::ItemStack& offhand() const; - [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_offhand(); - ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_offhand(); - void set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_offhand(); + // int32 tick_range = 2 [json_name = "tickRange"]; + void clear_tick_range() ; + ::int32_t tick_range() const; + void set_tick_range(::int32_t value); private: - const ::df::plugin::ItemStack& _internal_offhand() const; - ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_offhand(); + ::int32_t _internal_tick_range() const; + void _internal_set_tick_range(::int32_t value); public: - // @@protoc_insertion_point(class_scope:df.plugin.SetHeldItemAction) + // @@protoc_insertion_point(class_scope:df.plugin.WorldSetTickRangeAction) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<2, 3, - 2, 47, + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 0, 2> _table_; @@ -3647,45 +3752,44 @@ class SetHeldItemAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const SetHeldItemAction& from_msg); + const WorldSetTickRangeAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr player_uuid_; - ::df::plugin::ItemStack* PROTOBUF_NULLABLE main_; - ::df::plugin::ItemStack* PROTOBUF_NULLABLE offhand_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::int32_t tick_range_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull SetHeldItemAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetTickRangeAction_class_data_; // ------------------------------------------------------------------- -class PlaySoundAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.PlaySoundAction) */ { +class WorldSetDifficultyAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldSetDifficultyAction) */ { public: - inline PlaySoundAction() : PlaySoundAction(nullptr) {} - ~PlaySoundAction() PROTOBUF_FINAL; + inline WorldSetDifficultyAction() : WorldSetDifficultyAction(nullptr) {} + ~WorldSetDifficultyAction() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PlaySoundAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldSetDifficultyAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PlaySoundAction)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldSetDifficultyAction)); } #endif template - explicit PROTOBUF_CONSTEXPR PlaySoundAction(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldSetDifficultyAction(::google::protobuf::internal::ConstantInitialized); - inline PlaySoundAction(const PlaySoundAction& from) : PlaySoundAction(nullptr, from) {} - inline PlaySoundAction(PlaySoundAction&& from) noexcept - : PlaySoundAction(nullptr, ::std::move(from)) {} - inline PlaySoundAction& operator=(const PlaySoundAction& from) { + inline WorldSetDifficultyAction(const WorldSetDifficultyAction& from) : WorldSetDifficultyAction(nullptr, from) {} + inline WorldSetDifficultyAction(WorldSetDifficultyAction&& from) noexcept + : WorldSetDifficultyAction(nullptr, ::std::move(from)) {} + inline WorldSetDifficultyAction& operator=(const WorldSetDifficultyAction& from) { CopyFrom(from); return *this; } - inline PlaySoundAction& operator=(PlaySoundAction&& from) noexcept { + inline WorldSetDifficultyAction& operator=(WorldSetDifficultyAction&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -3713,13 +3817,13 @@ class PlaySoundAction final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const PlaySoundAction& default_instance() { - return *reinterpret_cast( - &_PlaySoundAction_default_instance_); + static const WorldSetDifficultyAction& default_instance() { + return *reinterpret_cast( + &_WorldSetDifficultyAction_default_instance_); } - static constexpr int kIndexInFileMessages = 18; - friend void swap(PlaySoundAction& a, PlaySoundAction& b) { a.Swap(&b); } - inline void Swap(PlaySoundAction* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 21; + friend void swap(WorldSetDifficultyAction& a, WorldSetDifficultyAction& b) { a.Swap(&b); } + inline void Swap(WorldSetDifficultyAction* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -3727,7 +3831,7 @@ class PlaySoundAction final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PlaySoundAction* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldSetDifficultyAction* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3735,13 +3839,13 @@ class PlaySoundAction final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - PlaySoundAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldSetDifficultyAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const PlaySoundAction& from); + void CopyFrom(const WorldSetDifficultyAction& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const PlaySoundAction& from) { PlaySoundAction::MergeImpl(*this, from); } + void MergeFrom(const WorldSetDifficultyAction& from) { WorldSetDifficultyAction::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -3777,17 +3881,17 @@ class PlaySoundAction final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(PlaySoundAction* PROTOBUF_NONNULL other); + void InternalSwap(WorldSetDifficultyAction* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.PlaySoundAction"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldSetDifficultyAction"; } - explicit PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PlaySoundAction& from); - PlaySoundAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PlaySoundAction&& from) noexcept - : PlaySoundAction(arena) { + explicit WorldSetDifficultyAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldSetDifficultyAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldSetDifficultyAction& from); + WorldSetDifficultyAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetDifficultyAction&& from) noexcept + : WorldSetDifficultyAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -3804,80 +3908,40 @@ class PlaySoundAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPlayerUuidFieldNumber = 1, - kPositionFieldNumber = 3, - kSoundFieldNumber = 2, - kVolumeFieldNumber = 4, - kPitchFieldNumber = 5, + kWorldFieldNumber = 1, + kDifficultyFieldNumber = 2, }; - // string player_uuid = 1 [json_name = "playerUuid"]; - void clear_player_uuid() ; - const ::std::string& player_uuid() const; - template - void set_player_uuid(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); - void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); - - private: - const ::std::string& _internal_player_uuid() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); - - public: - // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; - bool has_position() const; - void clear_position() ; - const ::df::plugin::Vec3& position() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); - void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); - - private: - const ::df::plugin::Vec3& _internal_position() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); - - public: - // .df.plugin.Sound sound = 2 [json_name = "sound"]; - void clear_sound() ; - ::df::plugin::Sound sound() const; - void set_sound(::df::plugin::Sound value); - - private: - ::df::plugin::Sound _internal_sound() const; - void _internal_set_sound(::df::plugin::Sound value); - - public: - // optional float volume = 4 [json_name = "volume"]; - bool has_volume() const; - void clear_volume() ; - float volume() const; - void set_volume(float value); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - float _internal_volume() const; - void _internal_set_volume(float value); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // optional float pitch = 5 [json_name = "pitch"]; - bool has_pitch() const; - void clear_pitch() ; - float pitch() const; - void set_pitch(float value); + // .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + void clear_difficulty() ; + ::df::plugin::Difficulty difficulty() const; + void set_difficulty(::df::plugin::Difficulty value); private: - float _internal_pitch() const; - void _internal_set_pitch(float value); + ::df::plugin::Difficulty _internal_difficulty() const; + void _internal_set_difficulty(::df::plugin::Difficulty value); public: - // @@protoc_insertion_point(class_scope:df.plugin.PlaySoundAction) + // @@protoc_insertion_point(class_scope:df.plugin.WorldSetDifficultyAction) private: class _Internal; friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<3, 5, - 1, 45, + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 0, 2> _table_; @@ -3895,47 +3959,44 @@ class PlaySoundAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const PlaySoundAction& from_msg); + const WorldSetDifficultyAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr player_uuid_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; - int sound_; - float volume_; - float pitch_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + int difficulty_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull PlaySoundAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetDifficultyAction_class_data_; // ------------------------------------------------------------------- -class GiveItemAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.GiveItemAction) */ { +class WorldSetDefaultGameModeAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldSetDefaultGameModeAction) */ { public: - inline GiveItemAction() : GiveItemAction(nullptr) {} - ~GiveItemAction() PROTOBUF_FINAL; + inline WorldSetDefaultGameModeAction() : WorldSetDefaultGameModeAction(nullptr) {} + ~WorldSetDefaultGameModeAction() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(GiveItemAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldSetDefaultGameModeAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(GiveItemAction)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldSetDefaultGameModeAction)); } #endif template - explicit PROTOBUF_CONSTEXPR GiveItemAction(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldSetDefaultGameModeAction(::google::protobuf::internal::ConstantInitialized); - inline GiveItemAction(const GiveItemAction& from) : GiveItemAction(nullptr, from) {} - inline GiveItemAction(GiveItemAction&& from) noexcept - : GiveItemAction(nullptr, ::std::move(from)) {} - inline GiveItemAction& operator=(const GiveItemAction& from) { + inline WorldSetDefaultGameModeAction(const WorldSetDefaultGameModeAction& from) : WorldSetDefaultGameModeAction(nullptr, from) {} + inline WorldSetDefaultGameModeAction(WorldSetDefaultGameModeAction&& from) noexcept + : WorldSetDefaultGameModeAction(nullptr, ::std::move(from)) {} + inline WorldSetDefaultGameModeAction& operator=(const WorldSetDefaultGameModeAction& from) { CopyFrom(from); return *this; } - inline GiveItemAction& operator=(GiveItemAction&& from) noexcept { + inline WorldSetDefaultGameModeAction& operator=(WorldSetDefaultGameModeAction&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -3963,13 +4024,13 @@ class GiveItemAction final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const GiveItemAction& default_instance() { - return *reinterpret_cast( - &_GiveItemAction_default_instance_); + static const WorldSetDefaultGameModeAction& default_instance() { + return *reinterpret_cast( + &_WorldSetDefaultGameModeAction_default_instance_); } - static constexpr int kIndexInFileMessages = 6; - friend void swap(GiveItemAction& a, GiveItemAction& b) { a.Swap(&b); } - inline void Swap(GiveItemAction* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 20; + friend void swap(WorldSetDefaultGameModeAction& a, WorldSetDefaultGameModeAction& b) { a.Swap(&b); } + inline void Swap(WorldSetDefaultGameModeAction* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -3977,7 +4038,7 @@ class GiveItemAction final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(GiveItemAction* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldSetDefaultGameModeAction* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -3985,13 +4046,13 @@ class GiveItemAction final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - GiveItemAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldSetDefaultGameModeAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const GiveItemAction& from); + void CopyFrom(const WorldSetDefaultGameModeAction& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const GiveItemAction& from) { GiveItemAction::MergeImpl(*this, from); } + void MergeFrom(const WorldSetDefaultGameModeAction& from) { WorldSetDefaultGameModeAction::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -4027,17 +4088,17 @@ class GiveItemAction final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(GiveItemAction* PROTOBUF_NONNULL other); + void InternalSwap(WorldSetDefaultGameModeAction* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.GiveItemAction"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldSetDefaultGameModeAction"; } - explicit GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GiveItemAction& from); - GiveItemAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GiveItemAction&& from) noexcept - : GiveItemAction(arena) { + explicit WorldSetDefaultGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldSetDefaultGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldSetDefaultGameModeAction& from); + WorldSetDefaultGameModeAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetDefaultGameModeAction&& from) noexcept + : WorldSetDefaultGameModeAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -4054,45 +4115,40 @@ class GiveItemAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPlayerUuidFieldNumber = 1, - kItemFieldNumber = 2, + kWorldFieldNumber = 1, + kGameModeFieldNumber = 2, }; - // string player_uuid = 1 [json_name = "playerUuid"]; - void clear_player_uuid() ; - const ::std::string& player_uuid() const; - template - void set_player_uuid(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); - void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::std::string& _internal_player_uuid() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // .df.plugin.ItemStack item = 2 [json_name = "item"]; - bool has_item() const; - void clear_item() ; - const ::df::plugin::ItemStack& item() const; - [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_item(); - ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_item(); - void set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); - ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_item(); + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + void clear_game_mode() ; + ::df::plugin::GameMode game_mode() const; + void set_game_mode(::df::plugin::GameMode value); private: - const ::df::plugin::ItemStack& _internal_item() const; - ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_item(); + ::df::plugin::GameMode _internal_game_mode() const; + void _internal_set_game_mode(::df::plugin::GameMode value); public: - // @@protoc_insertion_point(class_scope:df.plugin.GiveItemAction) + // @@protoc_insertion_point(class_scope:df.plugin.WorldSetDefaultGameModeAction) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable<1, 2, - 1, 44, + 1, 0, 2> _table_; @@ -4110,44 +4166,44 @@ class GiveItemAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const GiveItemAction& from_msg); + const WorldSetDefaultGameModeAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr player_uuid_; - ::df::plugin::ItemStack* PROTOBUF_NULLABLE item_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + int game_mode_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull GiveItemAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetDefaultGameModeAction_class_data_; // ------------------------------------------------------------------- -class Action final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.Action) */ { +class WorldQueryViewersAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldQueryViewersAction) */ { public: - inline Action() : Action(nullptr) {} - ~Action() PROTOBUF_FINAL; + inline WorldQueryViewersAction() : WorldQueryViewersAction(nullptr) {} + ~WorldQueryViewersAction() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Action* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldQueryViewersAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Action)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldQueryViewersAction)); } #endif template - explicit PROTOBUF_CONSTEXPR Action(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldQueryViewersAction(::google::protobuf::internal::ConstantInitialized); - inline Action(const Action& from) : Action(nullptr, from) {} - inline Action(Action&& from) noexcept - : Action(nullptr, ::std::move(from)) {} - inline Action& operator=(const Action& from) { + inline WorldQueryViewersAction(const WorldQueryViewersAction& from) : WorldQueryViewersAction(nullptr, from) {} + inline WorldQueryViewersAction(WorldQueryViewersAction&& from) noexcept + : WorldQueryViewersAction(nullptr, ::std::move(from)) {} + inline WorldQueryViewersAction& operator=(const WorldQueryViewersAction& from) { CopyFrom(from); return *this; } - inline Action& operator=(Action&& from) noexcept { + inline WorldQueryViewersAction& operator=(WorldQueryViewersAction&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -4175,34 +4231,13 @@ class Action final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const Action& default_instance() { - return *reinterpret_cast( - &_Action_default_instance_); + static const WorldQueryViewersAction& default_instance() { + return *reinterpret_cast( + &_WorldQueryViewersAction_default_instance_); } - enum KindCase { - kSendChat = 10, - kTeleport = 11, - kKick = 12, - kSetGameMode = 13, - kGiveItem = 14, - kClearInventory = 15, - kSetHeldItem = 16, - kSetHealth = 20, - kSetFood = 21, - kSetExperience = 22, - kSetVelocity = 23, - kAddEffect = 30, - kRemoveEffect = 31, - kSendTitle = 40, - kSendPopup = 41, - kSendTip = 42, - kPlaySound = 43, - kExecuteCommand = 50, - KIND_NOT_SET = 0, - }; - static constexpr int kIndexInFileMessages = 1; - friend void swap(Action& a, Action& b) { a.Swap(&b); } - inline void Swap(Action* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 29; + friend void swap(WorldQueryViewersAction& a, WorldQueryViewersAction& b) { a.Swap(&b); } + inline void Swap(WorldQueryViewersAction* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -4210,7 +4245,7 @@ class Action final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(Action* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldQueryViewersAction* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4218,13 +4253,13 @@ class Action final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - Action* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldQueryViewersAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const Action& from); + void CopyFrom(const WorldQueryViewersAction& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const Action& from) { Action::MergeImpl(*this, from); } + void MergeFrom(const WorldQueryViewersAction& from) { WorldQueryViewersAction::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -4260,17 +4295,17 @@ class Action final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(Action* PROTOBUF_NONNULL other); + void InternalSwap(WorldQueryViewersAction* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.Action"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldQueryViewersAction"; } - explicit Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Action& from); - Action( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Action&& from) noexcept - : Action(arena) { + explicit WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldQueryViewersAction& from); + WorldQueryViewersAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldQueryViewersAction&& from) noexcept + : WorldQueryViewersAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -4287,414 +4322,243 @@ class Action final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kCorrelationIdFieldNumber = 1, - kSendChatFieldNumber = 10, - kTeleportFieldNumber = 11, - kKickFieldNumber = 12, - kSetGameModeFieldNumber = 13, - kGiveItemFieldNumber = 14, - kClearInventoryFieldNumber = 15, - kSetHeldItemFieldNumber = 16, - kSetHealthFieldNumber = 20, - kSetFoodFieldNumber = 21, - kSetExperienceFieldNumber = 22, - kSetVelocityFieldNumber = 23, - kAddEffectFieldNumber = 30, - kRemoveEffectFieldNumber = 31, - kSendTitleFieldNumber = 40, - kSendPopupFieldNumber = 41, - kSendTipFieldNumber = 42, - kPlaySoundFieldNumber = 43, - kExecuteCommandFieldNumber = 50, + kWorldFieldNumber = 1, + kPositionFieldNumber = 2, }; - // optional string correlation_id = 1 [json_name = "correlationId"]; - bool has_correlation_id() const; - void clear_correlation_id() ; - const ::std::string& correlation_id() const; - template - void set_correlation_id(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_correlation_id(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_correlation_id(); - void set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::std::string& _internal_correlation_id() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_correlation_id(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_correlation_id(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // .df.plugin.SendChatAction send_chat = 10 [json_name = "sendChat"]; - bool has_send_chat() const; + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + private: - bool _internal_has_send_chat() const; - - public: - void clear_send_chat() ; - const ::df::plugin::SendChatAction& send_chat() const; - [[nodiscard]] ::df::plugin::SendChatAction* PROTOBUF_NULLABLE release_send_chat(); - ::df::plugin::SendChatAction* PROTOBUF_NONNULL mutable_send_chat(); - void set_allocated_send_chat(::df::plugin::SendChatAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_send_chat(::df::plugin::SendChatAction* PROTOBUF_NULLABLE value); - ::df::plugin::SendChatAction* PROTOBUF_NULLABLE unsafe_arena_release_send_chat(); - - private: - const ::df::plugin::SendChatAction& _internal_send_chat() const; - ::df::plugin::SendChatAction* PROTOBUF_NONNULL _internal_mutable_send_chat(); + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); public: - // .df.plugin.TeleportAction teleport = 11 [json_name = "teleport"]; - bool has_teleport() const; - private: - bool _internal_has_teleport() const; + // @@protoc_insertion_point(class_scope:df.plugin.WorldQueryViewersAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; - public: - void clear_teleport() ; - const ::df::plugin::TeleportAction& teleport() const; - [[nodiscard]] ::df::plugin::TeleportAction* PROTOBUF_NULLABLE release_teleport(); - ::df::plugin::TeleportAction* PROTOBUF_NONNULL mutable_teleport(); - void set_allocated_teleport(::df::plugin::TeleportAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_teleport(::df::plugin::TeleportAction* PROTOBUF_NULLABLE value); - ::df::plugin::TeleportAction* PROTOBUF_NULLABLE unsafe_arena_release_teleport(); + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldQueryViewersAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; - private: - const ::df::plugin::TeleportAction& _internal_teleport() const; - ::df::plugin::TeleportAction* PROTOBUF_NONNULL _internal_mutable_teleport(); +extern const ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_; +// ------------------------------------------------------------------- - public: - // .df.plugin.KickAction kick = 12 [json_name = "kick"]; - bool has_kick() const; - private: - bool _internal_has_kick() const; +class WorldQueryPlayersAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldQueryPlayersAction) */ { + public: + inline WorldQueryPlayersAction() : WorldQueryPlayersAction(nullptr) {} + ~WorldQueryPlayersAction() PROTOBUF_FINAL; - public: - void clear_kick() ; - const ::df::plugin::KickAction& kick() const; - [[nodiscard]] ::df::plugin::KickAction* PROTOBUF_NULLABLE release_kick(); - ::df::plugin::KickAction* PROTOBUF_NONNULL mutable_kick(); - void set_allocated_kick(::df::plugin::KickAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_kick(::df::plugin::KickAction* PROTOBUF_NULLABLE value); - ::df::plugin::KickAction* PROTOBUF_NULLABLE unsafe_arena_release_kick(); +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldQueryPlayersAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldQueryPlayersAction)); + } +#endif - private: - const ::df::plugin::KickAction& _internal_kick() const; - ::df::plugin::KickAction* PROTOBUF_NONNULL _internal_mutable_kick(); + template + explicit PROTOBUF_CONSTEXPR WorldQueryPlayersAction(::google::protobuf::internal::ConstantInitialized); - public: - // .df.plugin.SetGameModeAction set_game_mode = 13 [json_name = "setGameMode"]; - bool has_set_game_mode() const; - private: - bool _internal_has_set_game_mode() const; + inline WorldQueryPlayersAction(const WorldQueryPlayersAction& from) : WorldQueryPlayersAction(nullptr, from) {} + inline WorldQueryPlayersAction(WorldQueryPlayersAction&& from) noexcept + : WorldQueryPlayersAction(nullptr, ::std::move(from)) {} + inline WorldQueryPlayersAction& operator=(const WorldQueryPlayersAction& from) { + CopyFrom(from); + return *this; + } + inline WorldQueryPlayersAction& operator=(WorldQueryPlayersAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } - public: - void clear_set_game_mode() ; - const ::df::plugin::SetGameModeAction& set_game_mode() const; - [[nodiscard]] ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE release_set_game_mode(); - ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL mutable_set_game_mode(); - void set_allocated_set_game_mode(::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_game_mode(::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE unsafe_arena_release_set_game_mode(); + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } - private: - const ::df::plugin::SetGameModeAction& _internal_set_game_mode() const; - ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL _internal_mutable_set_game_mode(); + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldQueryPlayersAction& default_instance() { + return *reinterpret_cast( + &_WorldQueryPlayersAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 27; + friend void swap(WorldQueryPlayersAction& a, WorldQueryPlayersAction& b) { a.Swap(&b); } + inline void Swap(WorldQueryPlayersAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldQueryPlayersAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } - public: - // .df.plugin.GiveItemAction give_item = 14 [json_name = "giveItem"]; - bool has_give_item() const; - private: - bool _internal_has_give_item() const; + // implements Message ---------------------------------------------- - public: - void clear_give_item() ; - const ::df::plugin::GiveItemAction& give_item() const; - [[nodiscard]] ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE release_give_item(); - ::df::plugin::GiveItemAction* PROTOBUF_NONNULL mutable_give_item(); - void set_allocated_give_item(::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_give_item(::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value); - ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE unsafe_arena_release_give_item(); + WorldQueryPlayersAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldQueryPlayersAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldQueryPlayersAction& from) { WorldQueryPlayersAction::MergeImpl(*this, from); } private: - const ::df::plugin::GiveItemAction& _internal_give_item() const; - ::df::plugin::GiveItemAction* PROTOBUF_NONNULL _internal_mutable_give_item(); + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); public: - // .df.plugin.ClearInventoryAction clear_inventory = 15 [json_name = "clearInventory"]; - bool has_clear_inventory() const; + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) private: - bool _internal_has_clear_inventory() const; + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); public: - void clear_clear_inventory() ; - const ::df::plugin::ClearInventoryAction& clear_inventory() const; - [[nodiscard]] ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE release_clear_inventory(); - ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL mutable_clear_inventory(); - void set_allocated_clear_inventory(::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_clear_inventory(::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value); - ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE unsafe_arena_release_clear_inventory(); - - private: - const ::df::plugin::ClearInventoryAction& _internal_clear_inventory() const; - ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL _internal_mutable_clear_inventory(); + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } - public: - // .df.plugin.SetHeldItemAction set_held_item = 16 [json_name = "setHeldItem"]; - bool has_set_held_item() const; private: - bool _internal_has_set_held_item() const; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldQueryPlayersAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldQueryPlayersAction"; } - public: - void clear_set_held_item() ; - const ::df::plugin::SetHeldItemAction& set_held_item() const; - [[nodiscard]] ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE release_set_held_item(); - ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL mutable_set_held_item(); - void set_allocated_set_held_item(::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_held_item(::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE unsafe_arena_release_set_held_item(); + explicit WorldQueryPlayersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldQueryPlayersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldQueryPlayersAction& from); + WorldQueryPlayersAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldQueryPlayersAction&& from) noexcept + : WorldQueryPlayersAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - private: - const ::df::plugin::SetHeldItemAction& _internal_set_held_item() const; - ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL _internal_mutable_set_held_item(); + public: + static constexpr auto InternalGenerateClassData_(); - public: - // .df.plugin.SetHealthAction set_health = 20 [json_name = "setHealth"]; - bool has_set_health() const; - private: - bool _internal_has_set_health() const; + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- - public: - void clear_set_health() ; - const ::df::plugin::SetHealthAction& set_health() const; - [[nodiscard]] ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE release_set_health(); - ::df::plugin::SetHealthAction* PROTOBUF_NONNULL mutable_set_health(); - void set_allocated_set_health(::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_health(::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE unsafe_arena_release_set_health(); + // accessors ------------------------------------------------------- + enum : int { + kWorldFieldNumber = 1, + }; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::df::plugin::SetHealthAction& _internal_set_health() const; - ::df::plugin::SetHealthAction* PROTOBUF_NONNULL _internal_mutable_set_health(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // .df.plugin.SetFoodAction set_food = 21 [json_name = "setFood"]; - bool has_set_food() const; - private: - bool _internal_has_set_food() const; - - public: - void clear_set_food() ; - const ::df::plugin::SetFoodAction& set_food() const; - [[nodiscard]] ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE release_set_food(); - ::df::plugin::SetFoodAction* PROTOBUF_NONNULL mutable_set_food(); - void set_allocated_set_food(::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_food(::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE unsafe_arena_release_set_food(); - - private: - const ::df::plugin::SetFoodAction& _internal_set_food() const; - ::df::plugin::SetFoodAction* PROTOBUF_NONNULL _internal_mutable_set_food(); - - public: - // .df.plugin.SetExperienceAction set_experience = 22 [json_name = "setExperience"]; - bool has_set_experience() const; - private: - bool _internal_has_set_experience() const; - - public: - void clear_set_experience() ; - const ::df::plugin::SetExperienceAction& set_experience() const; - [[nodiscard]] ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE release_set_experience(); - ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL mutable_set_experience(); - void set_allocated_set_experience(::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_experience(::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE unsafe_arena_release_set_experience(); - - private: - const ::df::plugin::SetExperienceAction& _internal_set_experience() const; - ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL _internal_mutable_set_experience(); - - public: - // .df.plugin.SetVelocityAction set_velocity = 23 [json_name = "setVelocity"]; - bool has_set_velocity() const; - private: - bool _internal_has_set_velocity() const; - - public: - void clear_set_velocity() ; - const ::df::plugin::SetVelocityAction& set_velocity() const; - [[nodiscard]] ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE release_set_velocity(); - ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL mutable_set_velocity(); - void set_allocated_set_velocity(::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_set_velocity(::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value); - ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE unsafe_arena_release_set_velocity(); - - private: - const ::df::plugin::SetVelocityAction& _internal_set_velocity() const; - ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL _internal_mutable_set_velocity(); - - public: - // .df.plugin.AddEffectAction add_effect = 30 [json_name = "addEffect"]; - bool has_add_effect() const; - private: - bool _internal_has_add_effect() const; - - public: - void clear_add_effect() ; - const ::df::plugin::AddEffectAction& add_effect() const; - [[nodiscard]] ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE release_add_effect(); - ::df::plugin::AddEffectAction* PROTOBUF_NONNULL mutable_add_effect(); - void set_allocated_add_effect(::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_add_effect(::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value); - ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE unsafe_arena_release_add_effect(); - - private: - const ::df::plugin::AddEffectAction& _internal_add_effect() const; - ::df::plugin::AddEffectAction* PROTOBUF_NONNULL _internal_mutable_add_effect(); - - public: - // .df.plugin.RemoveEffectAction remove_effect = 31 [json_name = "removeEffect"]; - bool has_remove_effect() const; - private: - bool _internal_has_remove_effect() const; - - public: - void clear_remove_effect() ; - const ::df::plugin::RemoveEffectAction& remove_effect() const; - [[nodiscard]] ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE release_remove_effect(); - ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL mutable_remove_effect(); - void set_allocated_remove_effect(::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_remove_effect(::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value); - ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE unsafe_arena_release_remove_effect(); - - private: - const ::df::plugin::RemoveEffectAction& _internal_remove_effect() const; - ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL _internal_mutable_remove_effect(); - - public: - // .df.plugin.SendTitleAction send_title = 40 [json_name = "sendTitle"]; - bool has_send_title() const; - private: - bool _internal_has_send_title() const; - - public: - void clear_send_title() ; - const ::df::plugin::SendTitleAction& send_title() const; - [[nodiscard]] ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE release_send_title(); - ::df::plugin::SendTitleAction* PROTOBUF_NONNULL mutable_send_title(); - void set_allocated_send_title(::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_send_title(::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value); - ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE unsafe_arena_release_send_title(); - - private: - const ::df::plugin::SendTitleAction& _internal_send_title() const; - ::df::plugin::SendTitleAction* PROTOBUF_NONNULL _internal_mutable_send_title(); - - public: - // .df.plugin.SendPopupAction send_popup = 41 [json_name = "sendPopup"]; - bool has_send_popup() const; - private: - bool _internal_has_send_popup() const; - - public: - void clear_send_popup() ; - const ::df::plugin::SendPopupAction& send_popup() const; - [[nodiscard]] ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE release_send_popup(); - ::df::plugin::SendPopupAction* PROTOBUF_NONNULL mutable_send_popup(); - void set_allocated_send_popup(::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_send_popup(::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value); - ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE unsafe_arena_release_send_popup(); - - private: - const ::df::plugin::SendPopupAction& _internal_send_popup() const; - ::df::plugin::SendPopupAction* PROTOBUF_NONNULL _internal_mutable_send_popup(); - - public: - // .df.plugin.SendTipAction send_tip = 42 [json_name = "sendTip"]; - bool has_send_tip() const; - private: - bool _internal_has_send_tip() const; - - public: - void clear_send_tip() ; - const ::df::plugin::SendTipAction& send_tip() const; - [[nodiscard]] ::df::plugin::SendTipAction* PROTOBUF_NULLABLE release_send_tip(); - ::df::plugin::SendTipAction* PROTOBUF_NONNULL mutable_send_tip(); - void set_allocated_send_tip(::df::plugin::SendTipAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_send_tip(::df::plugin::SendTipAction* PROTOBUF_NULLABLE value); - ::df::plugin::SendTipAction* PROTOBUF_NULLABLE unsafe_arena_release_send_tip(); - - private: - const ::df::plugin::SendTipAction& _internal_send_tip() const; - ::df::plugin::SendTipAction* PROTOBUF_NONNULL _internal_mutable_send_tip(); - - public: - // .df.plugin.PlaySoundAction play_sound = 43 [json_name = "playSound"]; - bool has_play_sound() const; - private: - bool _internal_has_play_sound() const; - - public: - void clear_play_sound() ; - const ::df::plugin::PlaySoundAction& play_sound() const; - [[nodiscard]] ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE release_play_sound(); - ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL mutable_play_sound(); - void set_allocated_play_sound(::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_play_sound(::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value); - ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE unsafe_arena_release_play_sound(); - - private: - const ::df::plugin::PlaySoundAction& _internal_play_sound() const; - ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL _internal_mutable_play_sound(); - - public: - // .df.plugin.ExecuteCommandAction execute_command = 50 [json_name = "executeCommand"]; - bool has_execute_command() const; - private: - bool _internal_has_execute_command() const; - - public: - void clear_execute_command() ; - const ::df::plugin::ExecuteCommandAction& execute_command() const; - [[nodiscard]] ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE release_execute_command(); - ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL mutable_execute_command(); - void set_allocated_execute_command(::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_execute_command(::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value); - ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE unsafe_arena_release_execute_command(); - - private: - const ::df::plugin::ExecuteCommandAction& _internal_execute_command() const; - ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL _internal_mutable_execute_command(); - - public: - void clear_kind(); - KindCase kind_case() const; - // @@protoc_insertion_point(class_scope:df.plugin.Action) - private: - class _Internal; - void set_has_send_chat(); - void set_has_teleport(); - void set_has_kick(); - void set_has_set_game_mode(); - void set_has_give_item(); - void set_has_clear_inventory(); - void set_has_set_held_item(); - void set_has_set_health(); - void set_has_set_food(); - void set_has_set_experience(); - void set_has_set_velocity(); - void set_has_add_effect(); - void set_has_remove_effect(); - void set_has_send_title(); - void set_has_send_popup(); - void set_has_send_tip(); - void set_has_play_sound(); - void set_has_execute_command(); - inline bool has_kind() const; - inline void clear_has_kind(); - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<0, 19, - 18, 55, - 7> - _table_; + // @@protoc_insertion_point(class_scope:df.plugin.WorldQueryPlayersAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 1, 0, + 2> + _table_; friend class ::google::protobuf::MessageLite; friend class ::google::protobuf::Arena; @@ -4710,66 +4574,43 @@ class Action final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const Action& from_msg); + const WorldQueryPlayersAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr correlation_id_; - union KindUnion { - constexpr KindUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::google::protobuf::Message* PROTOBUF_NULLABLE send_chat_; - ::google::protobuf::Message* PROTOBUF_NULLABLE teleport_; - ::google::protobuf::Message* PROTOBUF_NULLABLE kick_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_game_mode_; - ::google::protobuf::Message* PROTOBUF_NULLABLE give_item_; - ::google::protobuf::Message* PROTOBUF_NULLABLE clear_inventory_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_held_item_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_health_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_food_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_experience_; - ::google::protobuf::Message* PROTOBUF_NULLABLE set_velocity_; - ::google::protobuf::Message* PROTOBUF_NULLABLE add_effect_; - ::google::protobuf::Message* PROTOBUF_NULLABLE remove_effect_; - ::google::protobuf::Message* PROTOBUF_NULLABLE send_title_; - ::google::protobuf::Message* PROTOBUF_NULLABLE send_popup_; - ::google::protobuf::Message* PROTOBUF_NULLABLE send_tip_; - ::google::protobuf::Message* PROTOBUF_NULLABLE play_sound_; - ::google::protobuf::Message* PROTOBUF_NULLABLE execute_command_; - } kind_; - ::uint32_t _oneof_case_[1]; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull Action_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldQueryPlayersAction_class_data_; // ------------------------------------------------------------------- -class ActionBatch final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.ActionBatch) */ { +class WorldQueryEntitiesAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldQueryEntitiesAction) */ { public: - inline ActionBatch() : ActionBatch(nullptr) {} - ~ActionBatch() PROTOBUF_FINAL; + inline WorldQueryEntitiesAction() : WorldQueryEntitiesAction(nullptr) {} + ~WorldQueryEntitiesAction() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ActionBatch* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(WorldQueryEntitiesAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ActionBatch)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldQueryEntitiesAction)); } #endif template - explicit PROTOBUF_CONSTEXPR ActionBatch(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR WorldQueryEntitiesAction(::google::protobuf::internal::ConstantInitialized); - inline ActionBatch(const ActionBatch& from) : ActionBatch(nullptr, from) {} - inline ActionBatch(ActionBatch&& from) noexcept - : ActionBatch(nullptr, ::std::move(from)) {} - inline ActionBatch& operator=(const ActionBatch& from) { + inline WorldQueryEntitiesAction(const WorldQueryEntitiesAction& from) : WorldQueryEntitiesAction(nullptr, from) {} + inline WorldQueryEntitiesAction(WorldQueryEntitiesAction&& from) noexcept + : WorldQueryEntitiesAction(nullptr, ::std::move(from)) {} + inline WorldQueryEntitiesAction& operator=(const WorldQueryEntitiesAction& from) { CopyFrom(from); return *this; } - inline ActionBatch& operator=(ActionBatch&& from) noexcept { + inline WorldQueryEntitiesAction& operator=(WorldQueryEntitiesAction&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -4797,13 +4638,13 @@ class ActionBatch final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const ActionBatch& default_instance() { - return *reinterpret_cast( - &_ActionBatch_default_instance_); + static const WorldQueryEntitiesAction& default_instance() { + return *reinterpret_cast( + &_WorldQueryEntitiesAction_default_instance_); } - static constexpr int kIndexInFileMessages = 0; - friend void swap(ActionBatch& a, ActionBatch& b) { a.Swap(&b); } - inline void Swap(ActionBatch* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 26; + friend void swap(WorldQueryEntitiesAction& a, WorldQueryEntitiesAction& b) { a.Swap(&b); } + inline void Swap(WorldQueryEntitiesAction* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -4811,7 +4652,7 @@ class ActionBatch final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(ActionBatch* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(WorldQueryEntitiesAction* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -4819,13 +4660,13 @@ class ActionBatch final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - ActionBatch* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + WorldQueryEntitiesAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const ActionBatch& from); + void CopyFrom(const WorldQueryEntitiesAction& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const ActionBatch& from) { ActionBatch::MergeImpl(*this, from); } + void MergeFrom(const WorldQueryEntitiesAction& from) { WorldQueryEntitiesAction::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -4861,17 +4702,17 @@ class ActionBatch final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(ActionBatch* PROTOBUF_NONNULL other); + void InternalSwap(WorldQueryEntitiesAction* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.ActionBatch"; } + static ::absl::string_view FullMessageName() { return "df.plugin.WorldQueryEntitiesAction"; } - explicit ActionBatch(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - ActionBatch(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ActionBatch& from); - ActionBatch( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ActionBatch&& from) noexcept - : ActionBatch(arena) { + explicit WorldQueryEntitiesAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldQueryEntitiesAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldQueryEntitiesAction& from); + WorldQueryEntitiesAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldQueryEntitiesAction&& from) noexcept + : WorldQueryEntitiesAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -4888,26 +4729,24 @@ class ActionBatch final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kActionsFieldNumber = 1, + kWorldFieldNumber = 1, }; - // repeated .df.plugin.Action actions = 1 [json_name = "actions"]; - int actions_size() const; - private: - int _internal_actions_size() const; - - public: - void clear_actions() ; - ::df::plugin::Action* PROTOBUF_NONNULL mutable_actions(int index); - ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL mutable_actions(); + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); private: - const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& _internal_actions() const; - ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL _internal_mutable_actions(); + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + public: - const ::df::plugin::Action& actions(int index) const; - ::df::plugin::Action* PROTOBUF_NONNULL add_actions(); - const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& actions() const; - // @@protoc_insertion_point(class_scope:df.plugin.ActionBatch) + // @@protoc_insertion_point(class_scope:df.plugin.WorldQueryEntitiesAction) private: class _Internal; friend class ::google::protobuf::internal::TcParser; @@ -4930,2082 +4769,8779 @@ class ActionBatch final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const ActionBatch& from_msg); + const WorldQueryEntitiesAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::RepeatedPtrField< ::df::plugin::Action > actions_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull ActionBatch_class_data_; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ +extern const ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesAction_class_data_; // ------------------------------------------------------------------- -// ActionBatch - -// repeated .df.plugin.Action actions = 1 [json_name = "actions"]; -inline int ActionBatch::_internal_actions_size() const { - return _internal_actions().size(); -} -inline int ActionBatch::actions_size() const { - return _internal_actions_size(); -} -inline void ActionBatch::clear_actions() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.actions_.Clear(); - ClearHasBitForRepeated(_impl_._has_bits_[0], - 0x00000001U); -} -inline ::df::plugin::Action* PROTOBUF_NONNULL ActionBatch::mutable_actions(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:df.plugin.ActionBatch.actions) - return _internal_mutable_actions()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL ActionBatch::mutable_actions() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); - // @@protoc_insertion_point(field_mutable_list:df.plugin.ActionBatch.actions) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_actions(); -} -inline const ::df::plugin::Action& ActionBatch::actions(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.ActionBatch.actions) - return _internal_actions().Get(index); -} -inline ::df::plugin::Action* PROTOBUF_NONNULL ActionBatch::add_actions() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::df::plugin::Action* _add = - _internal_mutable_actions()->InternalAddWithArena( - ::google::protobuf::MessageLite::internal_visibility(), GetArena()); - SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); - // @@protoc_insertion_point(field_add:df.plugin.ActionBatch.actions) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& ActionBatch::actions() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:df.plugin.ActionBatch.actions) - return _internal_actions(); -} -inline const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& -ActionBatch::_internal_actions() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.actions_; -} -inline ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL -ActionBatch::_internal_mutable_actions() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.actions_; -} +class WorldPlaySoundAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldPlaySoundAction) */ { + public: + inline WorldPlaySoundAction() : WorldPlaySoundAction(nullptr) {} + ~WorldPlaySoundAction() PROTOBUF_FINAL; -// ------------------------------------------------------------------- +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldPlaySoundAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldPlaySoundAction)); + } +#endif -// Action + template + explicit PROTOBUF_CONSTEXPR WorldPlaySoundAction(::google::protobuf::internal::ConstantInitialized); -// optional string correlation_id = 1 [json_name = "correlationId"]; -inline bool Action::has_correlation_id() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); - return value; -} -inline void Action::clear_correlation_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.correlation_id_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -inline const ::std::string& Action::correlation_id() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.correlation_id) - return _internal_correlation_id(); -} -template -PROTOBUF_ALWAYS_INLINE void Action::set_correlation_id(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.correlation_id_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.Action.correlation_id) -} -inline ::std::string* PROTOBUF_NONNULL Action::mutable_correlation_id() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_correlation_id(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.correlation_id) - return _s; -} -inline const ::std::string& Action::_internal_correlation_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.correlation_id_.Get(); -} -inline void Action::_internal_set_correlation_id(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.correlation_id_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL Action::_internal_mutable_correlation_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.correlation_id_.Mutable( GetArena()); -} -inline ::std::string* PROTOBUF_NULLABLE Action::release_correlation_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.Action.correlation_id) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; + inline WorldPlaySoundAction(const WorldPlaySoundAction& from) : WorldPlaySoundAction(nullptr, from) {} + inline WorldPlaySoundAction(WorldPlaySoundAction&& from) noexcept + : WorldPlaySoundAction(nullptr, ::std::move(from)) {} + inline WorldPlaySoundAction& operator=(const WorldPlaySoundAction& from) { + CopyFrom(from); + return *this; } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.correlation_id_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.correlation_id_.Set("", GetArena()); + inline WorldPlaySoundAction& operator=(WorldPlaySoundAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; } - return released; -} -inline void Action::set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); } - _impl_.correlation_id_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.correlation_id_.IsDefault()) { - _impl_.correlation_id_.Set("", GetArena()); + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.correlation_id) -} -// .df.plugin.SendChatAction send_chat = 10 [json_name = "sendChat"]; -inline bool Action::has_send_chat() const { - return kind_case() == kSendChat; -} -inline bool Action::_internal_has_send_chat() const { - return kind_case() == kSendChat; -} -inline void Action::set_has_send_chat() { - _impl_._oneof_case_[0] = kSendChat; -} -inline void Action::clear_send_chat() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSendChat) { - if (GetArena() == nullptr) { - delete _impl_.kind_.send_chat_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_chat_); - } - clear_has_kind(); + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); } -} -inline ::df::plugin::SendChatAction* PROTOBUF_NULLABLE Action::release_send_chat() { - // @@protoc_insertion_point(field_release:df.plugin.Action.send_chat) - if (kind_case() == kSendChat) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.send_chat_ = nullptr; - return temp; - } else { - return nullptr; + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; } -} -inline const ::df::plugin::SendChatAction& Action::_internal_send_chat() const { - return kind_case() == kSendChat ? static_cast(*reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_)) - : reinterpret_cast(::df::plugin::_SendChatAction_default_instance_); -} -inline const ::df::plugin::SendChatAction& Action::send_chat() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.send_chat) - return _internal_send_chat(); -} -inline ::df::plugin::SendChatAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_chat() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_chat) - if (kind_case() == kSendChat) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); - _impl_.kind_.send_chat_ = nullptr; - return temp; - } else { - return nullptr; + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; } -} -inline void Action::unsafe_arena_set_allocated_send_chat( - ::df::plugin::SendChatAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_send_chat(); - _impl_.kind_.send_chat_ = reinterpret_cast<::google::protobuf::Message*>(value); + static const WorldPlaySoundAction& default_instance() { + return *reinterpret_cast( + &_WorldPlaySoundAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 24; + friend void swap(WorldPlaySoundAction& a, WorldPlaySoundAction& b) { a.Swap(&b); } + inline void Swap(WorldPlaySoundAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldPlaySoundAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldPlaySoundAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldPlaySoundAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldPlaySoundAction& from) { WorldPlaySoundAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldPlaySoundAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldPlaySoundAction"; } + + explicit WorldPlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldPlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldPlaySoundAction& from); + WorldPlaySoundAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldPlaySoundAction&& from) noexcept + : WorldPlaySoundAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kWorldFieldNumber = 1, + kPositionFieldNumber = 3, + kSoundFieldNumber = 2, + }; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // .df.plugin.Vec3 position = 3 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + void clear_sound() ; + ::df::plugin::Sound sound() const; + void set_sound(::df::plugin::Sound value); + + private: + ::df::plugin::Sound _internal_sound() const; + void _internal_set_sound(::df::plugin::Sound value); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldPlaySoundAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldPlaySoundAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + int sound_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldPlaySoundAction_class_data_; +// ------------------------------------------------------------------- + +class TeleportAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.TeleportAction) */ { + public: + inline TeleportAction() : TeleportAction(nullptr) {} + ~TeleportAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TeleportAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TeleportAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR TeleportAction(::google::protobuf::internal::ConstantInitialized); + + inline TeleportAction(const TeleportAction& from) : TeleportAction(nullptr, from) {} + inline TeleportAction(TeleportAction&& from) noexcept + : TeleportAction(nullptr, ::std::move(from)) {} + inline TeleportAction& operator=(const TeleportAction& from) { + CopyFrom(from); + return *this; + } + inline TeleportAction& operator=(TeleportAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const TeleportAction& default_instance() { + return *reinterpret_cast( + &_TeleportAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(TeleportAction& a, TeleportAction& b) { a.Swap(&b); } + inline void Swap(TeleportAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TeleportAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TeleportAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const TeleportAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const TeleportAction& from) { TeleportAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(TeleportAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.TeleportAction"; } + + explicit TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + TeleportAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const TeleportAction& from); + TeleportAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, TeleportAction&& from) noexcept + : TeleportAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayerUuidFieldNumber = 1, + kPositionFieldNumber = 2, + kRotationFieldNumber = 3, + }; + // string player_uuid = 1 [json_name = "playerUuid"]; + void clear_player_uuid() ; + const ::std::string& player_uuid() const; + template + void set_player_uuid(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); + void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_player_uuid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + + public: + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; + bool has_rotation() const; + void clear_rotation() ; + const ::df::plugin::Vec3& rotation() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_rotation(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_rotation(); + void set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_rotation(); + + private: + const ::df::plugin::Vec3& _internal_rotation() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_rotation(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.TeleportAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 44, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const TeleportAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr player_uuid_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE rotation_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull TeleportAction_class_data_; +// ------------------------------------------------------------------- + +class SetVelocityAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.SetVelocityAction) */ { + public: + inline SetVelocityAction() : SetVelocityAction(nullptr) {} + ~SetVelocityAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetVelocityAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetVelocityAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetVelocityAction(::google::protobuf::internal::ConstantInitialized); + + inline SetVelocityAction(const SetVelocityAction& from) : SetVelocityAction(nullptr, from) {} + inline SetVelocityAction(SetVelocityAction&& from) noexcept + : SetVelocityAction(nullptr, ::std::move(from)) {} + inline SetVelocityAction& operator=(const SetVelocityAction& from) { + CopyFrom(from); + return *this; + } + inline SetVelocityAction& operator=(SetVelocityAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetVelocityAction& default_instance() { + return *reinterpret_cast( + &_SetVelocityAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 12; + friend void swap(SetVelocityAction& a, SetVelocityAction& b) { a.Swap(&b); } + inline void Swap(SetVelocityAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetVelocityAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetVelocityAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetVelocityAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetVelocityAction& from) { SetVelocityAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetVelocityAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.SetVelocityAction"; } + + explicit SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + SetVelocityAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SetVelocityAction& from); + SetVelocityAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SetVelocityAction&& from) noexcept + : SetVelocityAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayerUuidFieldNumber = 1, + kVelocityFieldNumber = 2, + }; + // string player_uuid = 1 [json_name = "playerUuid"]; + void clear_player_uuid() ; + const ::std::string& player_uuid() const; + template + void set_player_uuid(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); + void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_player_uuid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + + public: + // .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; + bool has_velocity() const; + void clear_velocity() ; + const ::df::plugin::Vec3& velocity() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_velocity(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_velocity(); + void set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_velocity(); + + private: + const ::df::plugin::Vec3& _internal_velocity() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_velocity(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.SetVelocityAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 47, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const SetVelocityAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr player_uuid_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE velocity_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull SetVelocityAction_class_data_; +// ------------------------------------------------------------------- + +class SetHeldItemAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.SetHeldItemAction) */ { + public: + inline SetHeldItemAction() : SetHeldItemAction(nullptr) {} + ~SetHeldItemAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetHeldItemAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetHeldItemAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetHeldItemAction(::google::protobuf::internal::ConstantInitialized); + + inline SetHeldItemAction(const SetHeldItemAction& from) : SetHeldItemAction(nullptr, from) {} + inline SetHeldItemAction(SetHeldItemAction&& from) noexcept + : SetHeldItemAction(nullptr, ::std::move(from)) {} + inline SetHeldItemAction& operator=(const SetHeldItemAction& from) { + CopyFrom(from); + return *this; + } + inline SetHeldItemAction& operator=(SetHeldItemAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const SetHeldItemAction& default_instance() { + return *reinterpret_cast( + &_SetHeldItemAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(SetHeldItemAction& a, SetHeldItemAction& b) { a.Swap(&b); } + inline void Swap(SetHeldItemAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetHeldItemAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetHeldItemAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const SetHeldItemAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const SetHeldItemAction& from) { SetHeldItemAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetHeldItemAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.SetHeldItemAction"; } + + explicit SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + SetHeldItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const SetHeldItemAction& from); + SetHeldItemAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, SetHeldItemAction&& from) noexcept + : SetHeldItemAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayerUuidFieldNumber = 1, + kMainFieldNumber = 2, + kOffhandFieldNumber = 3, + }; + // string player_uuid = 1 [json_name = "playerUuid"]; + void clear_player_uuid() ; + const ::std::string& player_uuid() const; + template + void set_player_uuid(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); + void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_player_uuid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + + public: + // optional .df.plugin.ItemStack main = 2 [json_name = "main"]; + bool has_main() const; + void clear_main() ; + const ::df::plugin::ItemStack& main() const; + [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_main(); + ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_main(); + void set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_main(); + + private: + const ::df::plugin::ItemStack& _internal_main() const; + ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_main(); + + public: + // optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; + bool has_offhand() const; + void clear_offhand() ; + const ::df::plugin::ItemStack& offhand() const; + [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_offhand(); + ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_offhand(); + void set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_offhand(); + + private: + const ::df::plugin::ItemStack& _internal_offhand() const; + ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_offhand(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.SetHeldItemAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 2, 47, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const SetHeldItemAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr player_uuid_; + ::df::plugin::ItemStack* PROTOBUF_NULLABLE main_; + ::df::plugin::ItemStack* PROTOBUF_NULLABLE offhand_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull SetHeldItemAction_class_data_; +// ------------------------------------------------------------------- + +class PlaySoundAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.PlaySoundAction) */ { + public: + inline PlaySoundAction() : PlaySoundAction(nullptr) {} + ~PlaySoundAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PlaySoundAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PlaySoundAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PlaySoundAction(::google::protobuf::internal::ConstantInitialized); + + inline PlaySoundAction(const PlaySoundAction& from) : PlaySoundAction(nullptr, from) {} + inline PlaySoundAction(PlaySoundAction&& from) noexcept + : PlaySoundAction(nullptr, ::std::move(from)) {} + inline PlaySoundAction& operator=(const PlaySoundAction& from) { + CopyFrom(from); + return *this; + } + inline PlaySoundAction& operator=(PlaySoundAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PlaySoundAction& default_instance() { + return *reinterpret_cast( + &_PlaySoundAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 18; + friend void swap(PlaySoundAction& a, PlaySoundAction& b) { a.Swap(&b); } + inline void Swap(PlaySoundAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PlaySoundAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PlaySoundAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const PlaySoundAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const PlaySoundAction& from) { PlaySoundAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PlaySoundAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.PlaySoundAction"; } + + explicit PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PlaySoundAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PlaySoundAction& from); + PlaySoundAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PlaySoundAction&& from) noexcept + : PlaySoundAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayerUuidFieldNumber = 1, + kPositionFieldNumber = 3, + kSoundFieldNumber = 2, + kVolumeFieldNumber = 4, + kPitchFieldNumber = 5, + }; + // string player_uuid = 1 [json_name = "playerUuid"]; + void clear_player_uuid() ; + const ::std::string& player_uuid() const; + template + void set_player_uuid(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); + void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_player_uuid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + + public: + // optional .df.plugin.Vec3 position = 3 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // .df.plugin.Sound sound = 2 [json_name = "sound"]; + void clear_sound() ; + ::df::plugin::Sound sound() const; + void set_sound(::df::plugin::Sound value); + + private: + ::df::plugin::Sound _internal_sound() const; + void _internal_set_sound(::df::plugin::Sound value); + + public: + // optional float volume = 4 [json_name = "volume"]; + bool has_volume() const; + void clear_volume() ; + float volume() const; + void set_volume(float value); + + private: + float _internal_volume() const; + void _internal_set_volume(float value); + + public: + // optional float pitch = 5 [json_name = "pitch"]; + bool has_pitch() const; + void clear_pitch() ; + float pitch() const; + void set_pitch(float value); + + private: + float _internal_pitch() const; + void _internal_set_pitch(float value); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.PlaySoundAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 1, 45, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const PlaySoundAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr player_uuid_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + int sound_; + float volume_; + float pitch_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull PlaySoundAction_class_data_; +// ------------------------------------------------------------------- + +class GiveItemAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.GiveItemAction) */ { + public: + inline GiveItemAction() : GiveItemAction(nullptr) {} + ~GiveItemAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GiveItemAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GiveItemAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GiveItemAction(::google::protobuf::internal::ConstantInitialized); + + inline GiveItemAction(const GiveItemAction& from) : GiveItemAction(nullptr, from) {} + inline GiveItemAction(GiveItemAction&& from) noexcept + : GiveItemAction(nullptr, ::std::move(from)) {} + inline GiveItemAction& operator=(const GiveItemAction& from) { + CopyFrom(from); + return *this; + } + inline GiveItemAction& operator=(GiveItemAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const GiveItemAction& default_instance() { + return *reinterpret_cast( + &_GiveItemAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(GiveItemAction& a, GiveItemAction& b) { a.Swap(&b); } + inline void Swap(GiveItemAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GiveItemAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GiveItemAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const GiveItemAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const GiveItemAction& from) { GiveItemAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GiveItemAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.GiveItemAction"; } + + explicit GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + GiveItemAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const GiveItemAction& from); + GiveItemAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, GiveItemAction&& from) noexcept + : GiveItemAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayerUuidFieldNumber = 1, + kItemFieldNumber = 2, + }; + // string player_uuid = 1 [json_name = "playerUuid"]; + void clear_player_uuid() ; + const ::std::string& player_uuid() const; + template + void set_player_uuid(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_player_uuid(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_player_uuid(); + void set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_player_uuid() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_player_uuid(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_player_uuid(); + + public: + // .df.plugin.ItemStack item = 2 [json_name = "item"]; + bool has_item() const; + void clear_item() ; + const ::df::plugin::ItemStack& item() const; + [[nodiscard]] ::df::plugin::ItemStack* PROTOBUF_NULLABLE release_item(); + ::df::plugin::ItemStack* PROTOBUF_NONNULL mutable_item(); + void set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value); + ::df::plugin::ItemStack* PROTOBUF_NULLABLE unsafe_arena_release_item(); + + private: + const ::df::plugin::ItemStack& _internal_item() const; + ::df::plugin::ItemStack* PROTOBUF_NONNULL _internal_mutable_item(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.GiveItemAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 1, 44, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const GiveItemAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr player_uuid_; + ::df::plugin::ItemStack* PROTOBUF_NULLABLE item_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull GiveItemAction_class_data_; +// ------------------------------------------------------------------- + +class WorldSetBlockAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldSetBlockAction) */ { + public: + inline WorldSetBlockAction() : WorldSetBlockAction(nullptr) {} + ~WorldSetBlockAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldSetBlockAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldSetBlockAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldSetBlockAction(::google::protobuf::internal::ConstantInitialized); + + inline WorldSetBlockAction(const WorldSetBlockAction& from) : WorldSetBlockAction(nullptr, from) {} + inline WorldSetBlockAction(WorldSetBlockAction&& from) noexcept + : WorldSetBlockAction(nullptr, ::std::move(from)) {} + inline WorldSetBlockAction& operator=(const WorldSetBlockAction& from) { + CopyFrom(from); + return *this; + } + inline WorldSetBlockAction& operator=(WorldSetBlockAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldSetBlockAction& default_instance() { + return *reinterpret_cast( + &_WorldSetBlockAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 23; + friend void swap(WorldSetBlockAction& a, WorldSetBlockAction& b) { a.Swap(&b); } + inline void Swap(WorldSetBlockAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldSetBlockAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldSetBlockAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldSetBlockAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldSetBlockAction& from) { WorldSetBlockAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldSetBlockAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldSetBlockAction"; } + + explicit WorldSetBlockAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldSetBlockAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldSetBlockAction& from); + WorldSetBlockAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetBlockAction&& from) noexcept + : WorldSetBlockAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kWorldFieldNumber = 1, + kPositionFieldNumber = 2, + kBlockFieldNumber = 3, + }; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // .df.plugin.BlockPos position = 2 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::BlockPos& position() const; + [[nodiscard]] ::df::plugin::BlockPos* PROTOBUF_NULLABLE release_position(); + ::df::plugin::BlockPos* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::BlockPos* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::BlockPos* PROTOBUF_NULLABLE value); + ::df::plugin::BlockPos* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::BlockPos& _internal_position() const; + ::df::plugin::BlockPos* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // optional .df.plugin.BlockState block = 3 [json_name = "block"]; + bool has_block() const; + void clear_block() ; + const ::df::plugin::BlockState& block() const; + [[nodiscard]] ::df::plugin::BlockState* PROTOBUF_NULLABLE release_block(); + ::df::plugin::BlockState* PROTOBUF_NONNULL mutable_block(); + void set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value); + ::df::plugin::BlockState* PROTOBUF_NULLABLE unsafe_arena_release_block(); + + private: + const ::df::plugin::BlockState& _internal_block() const; + ::df::plugin::BlockState* PROTOBUF_NONNULL _internal_mutable_block(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldSetBlockAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 3, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldSetBlockAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::BlockPos* PROTOBUF_NULLABLE position_; + ::df::plugin::BlockState* PROTOBUF_NULLABLE block_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldSetBlockAction_class_data_; +// ------------------------------------------------------------------- + +class WorldQueryEntitiesWithinAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldQueryEntitiesWithinAction) */ { + public: + inline WorldQueryEntitiesWithinAction() : WorldQueryEntitiesWithinAction(nullptr) {} + ~WorldQueryEntitiesWithinAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldQueryEntitiesWithinAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldQueryEntitiesWithinAction(::google::protobuf::internal::ConstantInitialized); + + inline WorldQueryEntitiesWithinAction(const WorldQueryEntitiesWithinAction& from) : WorldQueryEntitiesWithinAction(nullptr, from) {} + inline WorldQueryEntitiesWithinAction(WorldQueryEntitiesWithinAction&& from) noexcept + : WorldQueryEntitiesWithinAction(nullptr, ::std::move(from)) {} + inline WorldQueryEntitiesWithinAction& operator=(const WorldQueryEntitiesWithinAction& from) { + CopyFrom(from); + return *this; + } + inline WorldQueryEntitiesWithinAction& operator=(WorldQueryEntitiesWithinAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldQueryEntitiesWithinAction& default_instance() { + return *reinterpret_cast( + &_WorldQueryEntitiesWithinAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 28; + friend void swap(WorldQueryEntitiesWithinAction& a, WorldQueryEntitiesWithinAction& b) { a.Swap(&b); } + inline void Swap(WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldQueryEntitiesWithinAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldQueryEntitiesWithinAction& from) { WorldQueryEntitiesWithinAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldQueryEntitiesWithinAction"; } + + explicit WorldQueryEntitiesWithinAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldQueryEntitiesWithinAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldQueryEntitiesWithinAction& from); + WorldQueryEntitiesWithinAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldQueryEntitiesWithinAction&& from) noexcept + : WorldQueryEntitiesWithinAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kWorldFieldNumber = 1, + kBoxFieldNumber = 2, + }; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // .df.plugin.BBox box = 2 [json_name = "box"]; + bool has_box() const; + void clear_box() ; + const ::df::plugin::BBox& box() const; + [[nodiscard]] ::df::plugin::BBox* PROTOBUF_NULLABLE release_box(); + ::df::plugin::BBox* PROTOBUF_NONNULL mutable_box(); + void set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value); + ::df::plugin::BBox* PROTOBUF_NULLABLE unsafe_arena_release_box(); + + private: + const ::df::plugin::BBox& _internal_box() const; + ::df::plugin::BBox* PROTOBUF_NONNULL _internal_mutable_box(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldQueryEntitiesWithinAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldQueryEntitiesWithinAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::BBox* PROTOBUF_NULLABLE box_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldQueryEntitiesWithinAction_class_data_; +// ------------------------------------------------------------------- + +class WorldPlayersResult final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldPlayersResult) */ { + public: + inline WorldPlayersResult() : WorldPlayersResult(nullptr) {} + ~WorldPlayersResult() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldPlayersResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldPlayersResult)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldPlayersResult(::google::protobuf::internal::ConstantInitialized); + + inline WorldPlayersResult(const WorldPlayersResult& from) : WorldPlayersResult(nullptr, from) {} + inline WorldPlayersResult(WorldPlayersResult&& from) noexcept + : WorldPlayersResult(nullptr, ::std::move(from)) {} + inline WorldPlayersResult& operator=(const WorldPlayersResult& from) { + CopyFrom(from); + return *this; + } + inline WorldPlayersResult& operator=(WorldPlayersResult&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldPlayersResult& default_instance() { + return *reinterpret_cast( + &_WorldPlayersResult_default_instance_); + } + static constexpr int kIndexInFileMessages = 33; + friend void swap(WorldPlayersResult& a, WorldPlayersResult& b) { a.Swap(&b); } + inline void Swap(WorldPlayersResult* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldPlayersResult* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldPlayersResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldPlayersResult& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldPlayersResult& from) { WorldPlayersResult::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldPlayersResult* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldPlayersResult"; } + + explicit WorldPlayersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldPlayersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldPlayersResult& from); + WorldPlayersResult( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldPlayersResult&& from) noexcept + : WorldPlayersResult(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPlayersFieldNumber = 2, + kWorldFieldNumber = 1, + }; + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + int players_size() const; + private: + int _internal_players_size() const; + + public: + void clear_players() ; + ::df::plugin::EntityRef* PROTOBUF_NONNULL mutable_players(int index); + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL mutable_players(); + + private: + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& _internal_players() const; + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL _internal_mutable_players(); + public: + const ::df::plugin::EntityRef& players(int index) const; + ::df::plugin::EntityRef* PROTOBUF_NONNULL add_players(); + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& players() const; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldPlayersResult) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldPlayersResult& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField< ::df::plugin::EntityRef > players_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldPlayersResult_class_data_; +// ------------------------------------------------------------------- + +class WorldEntitiesWithinResult final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldEntitiesWithinResult) */ { + public: + inline WorldEntitiesWithinResult() : WorldEntitiesWithinResult(nullptr) {} + ~WorldEntitiesWithinResult() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldEntitiesWithinResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldEntitiesWithinResult)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldEntitiesWithinResult(::google::protobuf::internal::ConstantInitialized); + + inline WorldEntitiesWithinResult(const WorldEntitiesWithinResult& from) : WorldEntitiesWithinResult(nullptr, from) {} + inline WorldEntitiesWithinResult(WorldEntitiesWithinResult&& from) noexcept + : WorldEntitiesWithinResult(nullptr, ::std::move(from)) {} + inline WorldEntitiesWithinResult& operator=(const WorldEntitiesWithinResult& from) { + CopyFrom(from); + return *this; + } + inline WorldEntitiesWithinResult& operator=(WorldEntitiesWithinResult&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldEntitiesWithinResult& default_instance() { + return *reinterpret_cast( + &_WorldEntitiesWithinResult_default_instance_); + } + static constexpr int kIndexInFileMessages = 32; + friend void swap(WorldEntitiesWithinResult& a, WorldEntitiesWithinResult& b) { a.Swap(&b); } + inline void Swap(WorldEntitiesWithinResult* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldEntitiesWithinResult* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldEntitiesWithinResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldEntitiesWithinResult& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldEntitiesWithinResult& from) { WorldEntitiesWithinResult::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldEntitiesWithinResult* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldEntitiesWithinResult"; } + + explicit WorldEntitiesWithinResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldEntitiesWithinResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldEntitiesWithinResult& from); + WorldEntitiesWithinResult( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldEntitiesWithinResult&& from) noexcept + : WorldEntitiesWithinResult(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEntitiesFieldNumber = 3, + kWorldFieldNumber = 1, + kBoxFieldNumber = 2, + }; + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + int entities_size() const; + private: + int _internal_entities_size() const; + + public: + void clear_entities() ; + ::df::plugin::EntityRef* PROTOBUF_NONNULL mutable_entities(int index); + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL mutable_entities(); + + private: + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& _internal_entities() const; + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL _internal_mutable_entities(); + public: + const ::df::plugin::EntityRef& entities(int index) const; + ::df::plugin::EntityRef* PROTOBUF_NONNULL add_entities(); + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& entities() const; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // .df.plugin.BBox box = 2 [json_name = "box"]; + bool has_box() const; + void clear_box() ; + const ::df::plugin::BBox& box() const; + [[nodiscard]] ::df::plugin::BBox* PROTOBUF_NULLABLE release_box(); + ::df::plugin::BBox* PROTOBUF_NONNULL mutable_box(); + void set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value); + ::df::plugin::BBox* PROTOBUF_NULLABLE unsafe_arena_release_box(); + + private: + const ::df::plugin::BBox& _internal_box() const; + ::df::plugin::BBox* PROTOBUF_NONNULL _internal_mutable_box(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldEntitiesWithinResult) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 3, + 3, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldEntitiesWithinResult& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField< ::df::plugin::EntityRef > entities_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::BBox* PROTOBUF_NULLABLE box_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldEntitiesWithinResult_class_data_; +// ------------------------------------------------------------------- + +class WorldEntitiesResult final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldEntitiesResult) */ { + public: + inline WorldEntitiesResult() : WorldEntitiesResult(nullptr) {} + ~WorldEntitiesResult() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldEntitiesResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldEntitiesResult)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldEntitiesResult(::google::protobuf::internal::ConstantInitialized); + + inline WorldEntitiesResult(const WorldEntitiesResult& from) : WorldEntitiesResult(nullptr, from) {} + inline WorldEntitiesResult(WorldEntitiesResult&& from) noexcept + : WorldEntitiesResult(nullptr, ::std::move(from)) {} + inline WorldEntitiesResult& operator=(const WorldEntitiesResult& from) { + CopyFrom(from); + return *this; + } + inline WorldEntitiesResult& operator=(WorldEntitiesResult&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldEntitiesResult& default_instance() { + return *reinterpret_cast( + &_WorldEntitiesResult_default_instance_); + } + static constexpr int kIndexInFileMessages = 31; + friend void swap(WorldEntitiesResult& a, WorldEntitiesResult& b) { a.Swap(&b); } + inline void Swap(WorldEntitiesResult* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldEntitiesResult* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldEntitiesResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldEntitiesResult& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldEntitiesResult& from) { WorldEntitiesResult::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldEntitiesResult* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldEntitiesResult"; } + + explicit WorldEntitiesResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldEntitiesResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldEntitiesResult& from); + WorldEntitiesResult( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldEntitiesResult&& from) noexcept + : WorldEntitiesResult(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kEntitiesFieldNumber = 2, + kWorldFieldNumber = 1, + }; + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + int entities_size() const; + private: + int _internal_entities_size() const; + + public: + void clear_entities() ; + ::df::plugin::EntityRef* PROTOBUF_NONNULL mutable_entities(int index); + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL mutable_entities(); + + private: + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& _internal_entities() const; + ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL _internal_mutable_entities(); + public: + const ::df::plugin::EntityRef& entities(int index) const; + ::df::plugin::EntityRef* PROTOBUF_NONNULL add_entities(); + const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& entities() const; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldEntitiesResult) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldEntitiesResult& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField< ::df::plugin::EntityRef > entities_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldEntitiesResult_class_data_; +// ------------------------------------------------------------------- + +class WorldAddParticleAction final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.WorldAddParticleAction) */ { + public: + inline WorldAddParticleAction() : WorldAddParticleAction(nullptr) {} + ~WorldAddParticleAction() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(WorldAddParticleAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldAddParticleAction)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR WorldAddParticleAction(::google::protobuf::internal::ConstantInitialized); + + inline WorldAddParticleAction(const WorldAddParticleAction& from) : WorldAddParticleAction(nullptr, from) {} + inline WorldAddParticleAction(WorldAddParticleAction&& from) noexcept + : WorldAddParticleAction(nullptr, ::std::move(from)) {} + inline WorldAddParticleAction& operator=(const WorldAddParticleAction& from) { + CopyFrom(from); + return *this; + } + inline WorldAddParticleAction& operator=(WorldAddParticleAction&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const WorldAddParticleAction& default_instance() { + return *reinterpret_cast( + &_WorldAddParticleAction_default_instance_); + } + static constexpr int kIndexInFileMessages = 25; + friend void swap(WorldAddParticleAction& a, WorldAddParticleAction& b) { a.Swap(&b); } + inline void Swap(WorldAddParticleAction* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(WorldAddParticleAction* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + WorldAddParticleAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const WorldAddParticleAction& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const WorldAddParticleAction& from) { WorldAddParticleAction::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(WorldAddParticleAction* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.WorldAddParticleAction"; } + + explicit WorldAddParticleAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + WorldAddParticleAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldAddParticleAction& from); + WorldAddParticleAction( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldAddParticleAction&& from) noexcept + : WorldAddParticleAction(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kWorldFieldNumber = 1, + kPositionFieldNumber = 2, + kBlockFieldNumber = 4, + kParticleFieldNumber = 3, + kFaceFieldNumber = 5, + }; + // .df.plugin.WorldRef world = 1 [json_name = "world"]; + bool has_world() const; + void clear_world() ; + const ::df::plugin::WorldRef& world() const; + [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); + ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); + void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); + ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); + + private: + const ::df::plugin::WorldRef& _internal_world() const; + ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); + + public: + // .df.plugin.Vec3 position = 2 [json_name = "position"]; + bool has_position() const; + void clear_position() ; + const ::df::plugin::Vec3& position() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); + void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + + private: + const ::df::plugin::Vec3& _internal_position() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + + public: + // optional .df.plugin.BlockState block = 4 [json_name = "block"]; + bool has_block() const; + void clear_block() ; + const ::df::plugin::BlockState& block() const; + [[nodiscard]] ::df::plugin::BlockState* PROTOBUF_NULLABLE release_block(); + ::df::plugin::BlockState* PROTOBUF_NONNULL mutable_block(); + void set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value); + ::df::plugin::BlockState* PROTOBUF_NULLABLE unsafe_arena_release_block(); + + private: + const ::df::plugin::BlockState& _internal_block() const; + ::df::plugin::BlockState* PROTOBUF_NONNULL _internal_mutable_block(); + + public: + // .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + void clear_particle() ; + ::df::plugin::ParticleType particle() const; + void set_particle(::df::plugin::ParticleType value); + + private: + ::df::plugin::ParticleType _internal_particle() const; + void _internal_set_particle(::df::plugin::ParticleType value); + + public: + // optional int32 face = 5 [json_name = "face"]; + bool has_face() const; + void clear_face() ; + ::int32_t face() const; + void set_face(::int32_t value); + + private: + ::int32_t _internal_face() const; + void _internal_set_face(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.WorldAddParticleAction) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<3, 5, + 3, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const WorldAddParticleAction& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + ::df::plugin::BlockState* PROTOBUF_NULLABLE block_; + int particle_; + ::int32_t face_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull WorldAddParticleAction_class_data_; +// ------------------------------------------------------------------- + +class ActionResult final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.ActionResult) */ { + public: + inline ActionResult() : ActionResult(nullptr) {} + ~ActionResult() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ActionResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ActionResult)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ActionResult(::google::protobuf::internal::ConstantInitialized); + + inline ActionResult(const ActionResult& from) : ActionResult(nullptr, from) {} + inline ActionResult(ActionResult&& from) noexcept + : ActionResult(nullptr, ::std::move(from)) {} + inline ActionResult& operator=(const ActionResult& from) { + CopyFrom(from); + return *this; + } + inline ActionResult& operator=(ActionResult&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ActionResult& default_instance() { + return *reinterpret_cast( + &_ActionResult_default_instance_); + } + enum ResultCase { + kWorldEntities = 10, + kWorldPlayers = 11, + kWorldEntitiesWithin = 12, + kWorldViewers = 13, + RESULT_NOT_SET = 0, + }; + static constexpr int kIndexInFileMessages = 35; + friend void swap(ActionResult& a, ActionResult& b) { a.Swap(&b); } + inline void Swap(ActionResult* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ActionResult* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ActionResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ActionResult& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ActionResult& from) { ActionResult::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ActionResult* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.ActionResult"; } + + explicit ActionResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ActionResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ActionResult& from); + ActionResult( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ActionResult&& from) noexcept + : ActionResult(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kCorrelationIdFieldNumber = 1, + kStatusFieldNumber = 2, + kWorldEntitiesFieldNumber = 10, + kWorldPlayersFieldNumber = 11, + kWorldEntitiesWithinFieldNumber = 12, + kWorldViewersFieldNumber = 13, + }; + // string correlation_id = 1 [json_name = "correlationId"]; + void clear_correlation_id() ; + const ::std::string& correlation_id() const; + template + void set_correlation_id(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_correlation_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_correlation_id(); + void set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_correlation_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_correlation_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_correlation_id(); + + public: + // optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + bool has_status() const; + void clear_status() ; + const ::df::plugin::ActionStatus& status() const; + [[nodiscard]] ::df::plugin::ActionStatus* PROTOBUF_NULLABLE release_status(); + ::df::plugin::ActionStatus* PROTOBUF_NONNULL mutable_status(); + void set_allocated_status(::df::plugin::ActionStatus* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_status(::df::plugin::ActionStatus* PROTOBUF_NULLABLE value); + ::df::plugin::ActionStatus* PROTOBUF_NULLABLE unsafe_arena_release_status(); + + private: + const ::df::plugin::ActionStatus& _internal_status() const; + ::df::plugin::ActionStatus* PROTOBUF_NONNULL _internal_mutable_status(); + + public: + // .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; + bool has_world_entities() const; + private: + bool _internal_has_world_entities() const; + + public: + void clear_world_entities() ; + const ::df::plugin::WorldEntitiesResult& world_entities() const; + [[nodiscard]] ::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE release_world_entities(); + ::df::plugin::WorldEntitiesResult* PROTOBUF_NONNULL mutable_world_entities(); + void set_allocated_world_entities(::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_entities(::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE value); + ::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE unsafe_arena_release_world_entities(); + + private: + const ::df::plugin::WorldEntitiesResult& _internal_world_entities() const; + ::df::plugin::WorldEntitiesResult* PROTOBUF_NONNULL _internal_mutable_world_entities(); + + public: + // .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; + bool has_world_players() const; + private: + bool _internal_has_world_players() const; + + public: + void clear_world_players() ; + const ::df::plugin::WorldPlayersResult& world_players() const; + [[nodiscard]] ::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE release_world_players(); + ::df::plugin::WorldPlayersResult* PROTOBUF_NONNULL mutable_world_players(); + void set_allocated_world_players(::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_players(::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE value); + ::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE unsafe_arena_release_world_players(); + + private: + const ::df::plugin::WorldPlayersResult& _internal_world_players() const; + ::df::plugin::WorldPlayersResult* PROTOBUF_NONNULL _internal_mutable_world_players(); + + public: + // .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; + bool has_world_entities_within() const; + private: + bool _internal_has_world_entities_within() const; + + public: + void clear_world_entities_within() ; + const ::df::plugin::WorldEntitiesWithinResult& world_entities_within() const; + [[nodiscard]] ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE release_world_entities_within(); + ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL mutable_world_entities_within(); + void set_allocated_world_entities_within(::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_entities_within(::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE value); + ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE unsafe_arena_release_world_entities_within(); + + private: + const ::df::plugin::WorldEntitiesWithinResult& _internal_world_entities_within() const; + ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL _internal_mutable_world_entities_within(); + + public: + // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; + bool has_world_viewers() const; + private: + bool _internal_has_world_viewers() const; + + public: + void clear_world_viewers() ; + const ::df::plugin::WorldViewersResult& world_viewers() const; + [[nodiscard]] ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE release_world_viewers(); + ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL mutable_world_viewers(); + void set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value); + ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE unsafe_arena_release_world_viewers(); + + private: + const ::df::plugin::WorldViewersResult& _internal_world_viewers() const; + ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL _internal_mutable_world_viewers(); + + public: + void clear_result(); + ResultCase result_case() const; + // @@protoc_insertion_point(class_scope:df.plugin.ActionResult) + private: + class _Internal; + void set_has_world_entities(); + void set_has_world_players(); + void set_has_world_entities_within(); + void set_has_world_viewers(); + inline bool has_result() const; + inline void clear_has_result(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 6, + 5, 45, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ActionResult& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr correlation_id_; + ::df::plugin::ActionStatus* PROTOBUF_NULLABLE status_; + union ResultUnion { + constexpr ResultUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_entities_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_players_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_entities_within_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_viewers_; + } result_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull ActionResult_class_data_; +// ------------------------------------------------------------------- + +class Action final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.Action) */ { + public: + inline Action() : Action(nullptr) {} + ~Action() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Action* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Action)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Action(::google::protobuf::internal::ConstantInitialized); + + inline Action(const Action& from) : Action(nullptr, from) {} + inline Action(Action&& from) noexcept + : Action(nullptr, ::std::move(from)) {} + inline Action& operator=(const Action& from) { + CopyFrom(from); + return *this; + } + inline Action& operator=(Action&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const Action& default_instance() { + return *reinterpret_cast( + &_Action_default_instance_); + } + enum KindCase { + kSendChat = 10, + kTeleport = 11, + kKick = 12, + kSetGameMode = 13, + kGiveItem = 14, + kClearInventory = 15, + kSetHeldItem = 16, + kSetHealth = 20, + kSetFood = 21, + kSetExperience = 22, + kSetVelocity = 23, + kAddEffect = 30, + kRemoveEffect = 31, + kSendTitle = 40, + kSendPopup = 41, + kSendTip = 42, + kPlaySound = 43, + kExecuteCommand = 50, + kWorldSetDefaultGameMode = 60, + kWorldSetDifficulty = 61, + kWorldSetTickRange = 62, + kWorldSetBlock = 63, + kWorldPlaySound = 64, + kWorldAddParticle = 65, + kWorldQueryEntities = 70, + kWorldQueryPlayers = 71, + kWorldQueryEntitiesWithin = 72, + kWorldQueryViewers = 73, + KIND_NOT_SET = 0, + }; + static constexpr int kIndexInFileMessages = 1; + friend void swap(Action& a, Action& b) { a.Swap(&b); } + inline void Swap(Action* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Action* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Action* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const Action& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const Action& from) { Action::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Action* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.Action"; } + + explicit Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Action& from); + Action( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, Action&& from) noexcept + : Action(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kCorrelationIdFieldNumber = 1, + kSendChatFieldNumber = 10, + kTeleportFieldNumber = 11, + kKickFieldNumber = 12, + kSetGameModeFieldNumber = 13, + kGiveItemFieldNumber = 14, + kClearInventoryFieldNumber = 15, + kSetHeldItemFieldNumber = 16, + kSetHealthFieldNumber = 20, + kSetFoodFieldNumber = 21, + kSetExperienceFieldNumber = 22, + kSetVelocityFieldNumber = 23, + kAddEffectFieldNumber = 30, + kRemoveEffectFieldNumber = 31, + kSendTitleFieldNumber = 40, + kSendPopupFieldNumber = 41, + kSendTipFieldNumber = 42, + kPlaySoundFieldNumber = 43, + kExecuteCommandFieldNumber = 50, + kWorldSetDefaultGameModeFieldNumber = 60, + kWorldSetDifficultyFieldNumber = 61, + kWorldSetTickRangeFieldNumber = 62, + kWorldSetBlockFieldNumber = 63, + kWorldPlaySoundFieldNumber = 64, + kWorldAddParticleFieldNumber = 65, + kWorldQueryEntitiesFieldNumber = 70, + kWorldQueryPlayersFieldNumber = 71, + kWorldQueryEntitiesWithinFieldNumber = 72, + kWorldQueryViewersFieldNumber = 73, + }; + // optional string correlation_id = 1 [json_name = "correlationId"]; + bool has_correlation_id() const; + void clear_correlation_id() ; + const ::std::string& correlation_id() const; + template + void set_correlation_id(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_correlation_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_correlation_id(); + void set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value); + + private: + const ::std::string& _internal_correlation_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_correlation_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_correlation_id(); + + public: + // .df.plugin.SendChatAction send_chat = 10 [json_name = "sendChat"]; + bool has_send_chat() const; + private: + bool _internal_has_send_chat() const; + + public: + void clear_send_chat() ; + const ::df::plugin::SendChatAction& send_chat() const; + [[nodiscard]] ::df::plugin::SendChatAction* PROTOBUF_NULLABLE release_send_chat(); + ::df::plugin::SendChatAction* PROTOBUF_NONNULL mutable_send_chat(); + void set_allocated_send_chat(::df::plugin::SendChatAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_send_chat(::df::plugin::SendChatAction* PROTOBUF_NULLABLE value); + ::df::plugin::SendChatAction* PROTOBUF_NULLABLE unsafe_arena_release_send_chat(); + + private: + const ::df::plugin::SendChatAction& _internal_send_chat() const; + ::df::plugin::SendChatAction* PROTOBUF_NONNULL _internal_mutable_send_chat(); + + public: + // .df.plugin.TeleportAction teleport = 11 [json_name = "teleport"]; + bool has_teleport() const; + private: + bool _internal_has_teleport() const; + + public: + void clear_teleport() ; + const ::df::plugin::TeleportAction& teleport() const; + [[nodiscard]] ::df::plugin::TeleportAction* PROTOBUF_NULLABLE release_teleport(); + ::df::plugin::TeleportAction* PROTOBUF_NONNULL mutable_teleport(); + void set_allocated_teleport(::df::plugin::TeleportAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_teleport(::df::plugin::TeleportAction* PROTOBUF_NULLABLE value); + ::df::plugin::TeleportAction* PROTOBUF_NULLABLE unsafe_arena_release_teleport(); + + private: + const ::df::plugin::TeleportAction& _internal_teleport() const; + ::df::plugin::TeleportAction* PROTOBUF_NONNULL _internal_mutable_teleport(); + + public: + // .df.plugin.KickAction kick = 12 [json_name = "kick"]; + bool has_kick() const; + private: + bool _internal_has_kick() const; + + public: + void clear_kick() ; + const ::df::plugin::KickAction& kick() const; + [[nodiscard]] ::df::plugin::KickAction* PROTOBUF_NULLABLE release_kick(); + ::df::plugin::KickAction* PROTOBUF_NONNULL mutable_kick(); + void set_allocated_kick(::df::plugin::KickAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_kick(::df::plugin::KickAction* PROTOBUF_NULLABLE value); + ::df::plugin::KickAction* PROTOBUF_NULLABLE unsafe_arena_release_kick(); + + private: + const ::df::plugin::KickAction& _internal_kick() const; + ::df::plugin::KickAction* PROTOBUF_NONNULL _internal_mutable_kick(); + + public: + // .df.plugin.SetGameModeAction set_game_mode = 13 [json_name = "setGameMode"]; + bool has_set_game_mode() const; + private: + bool _internal_has_set_game_mode() const; + + public: + void clear_set_game_mode() ; + const ::df::plugin::SetGameModeAction& set_game_mode() const; + [[nodiscard]] ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE release_set_game_mode(); + ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL mutable_set_game_mode(); + void set_allocated_set_game_mode(::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_game_mode(::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE unsafe_arena_release_set_game_mode(); + + private: + const ::df::plugin::SetGameModeAction& _internal_set_game_mode() const; + ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL _internal_mutable_set_game_mode(); + + public: + // .df.plugin.GiveItemAction give_item = 14 [json_name = "giveItem"]; + bool has_give_item() const; + private: + bool _internal_has_give_item() const; + + public: + void clear_give_item() ; + const ::df::plugin::GiveItemAction& give_item() const; + [[nodiscard]] ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE release_give_item(); + ::df::plugin::GiveItemAction* PROTOBUF_NONNULL mutable_give_item(); + void set_allocated_give_item(::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_give_item(::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value); + ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE unsafe_arena_release_give_item(); + + private: + const ::df::plugin::GiveItemAction& _internal_give_item() const; + ::df::plugin::GiveItemAction* PROTOBUF_NONNULL _internal_mutable_give_item(); + + public: + // .df.plugin.ClearInventoryAction clear_inventory = 15 [json_name = "clearInventory"]; + bool has_clear_inventory() const; + private: + bool _internal_has_clear_inventory() const; + + public: + void clear_clear_inventory() ; + const ::df::plugin::ClearInventoryAction& clear_inventory() const; + [[nodiscard]] ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE release_clear_inventory(); + ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL mutable_clear_inventory(); + void set_allocated_clear_inventory(::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_clear_inventory(::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value); + ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE unsafe_arena_release_clear_inventory(); + + private: + const ::df::plugin::ClearInventoryAction& _internal_clear_inventory() const; + ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL _internal_mutable_clear_inventory(); + + public: + // .df.plugin.SetHeldItemAction set_held_item = 16 [json_name = "setHeldItem"]; + bool has_set_held_item() const; + private: + bool _internal_has_set_held_item() const; + + public: + void clear_set_held_item() ; + const ::df::plugin::SetHeldItemAction& set_held_item() const; + [[nodiscard]] ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE release_set_held_item(); + ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL mutable_set_held_item(); + void set_allocated_set_held_item(::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_held_item(::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE unsafe_arena_release_set_held_item(); + + private: + const ::df::plugin::SetHeldItemAction& _internal_set_held_item() const; + ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL _internal_mutable_set_held_item(); + + public: + // .df.plugin.SetHealthAction set_health = 20 [json_name = "setHealth"]; + bool has_set_health() const; + private: + bool _internal_has_set_health() const; + + public: + void clear_set_health() ; + const ::df::plugin::SetHealthAction& set_health() const; + [[nodiscard]] ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE release_set_health(); + ::df::plugin::SetHealthAction* PROTOBUF_NONNULL mutable_set_health(); + void set_allocated_set_health(::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_health(::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE unsafe_arena_release_set_health(); + + private: + const ::df::plugin::SetHealthAction& _internal_set_health() const; + ::df::plugin::SetHealthAction* PROTOBUF_NONNULL _internal_mutable_set_health(); + + public: + // .df.plugin.SetFoodAction set_food = 21 [json_name = "setFood"]; + bool has_set_food() const; + private: + bool _internal_has_set_food() const; + + public: + void clear_set_food() ; + const ::df::plugin::SetFoodAction& set_food() const; + [[nodiscard]] ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE release_set_food(); + ::df::plugin::SetFoodAction* PROTOBUF_NONNULL mutable_set_food(); + void set_allocated_set_food(::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_food(::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE unsafe_arena_release_set_food(); + + private: + const ::df::plugin::SetFoodAction& _internal_set_food() const; + ::df::plugin::SetFoodAction* PROTOBUF_NONNULL _internal_mutable_set_food(); + + public: + // .df.plugin.SetExperienceAction set_experience = 22 [json_name = "setExperience"]; + bool has_set_experience() const; + private: + bool _internal_has_set_experience() const; + + public: + void clear_set_experience() ; + const ::df::plugin::SetExperienceAction& set_experience() const; + [[nodiscard]] ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE release_set_experience(); + ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL mutable_set_experience(); + void set_allocated_set_experience(::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_experience(::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE unsafe_arena_release_set_experience(); + + private: + const ::df::plugin::SetExperienceAction& _internal_set_experience() const; + ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL _internal_mutable_set_experience(); + + public: + // .df.plugin.SetVelocityAction set_velocity = 23 [json_name = "setVelocity"]; + bool has_set_velocity() const; + private: + bool _internal_has_set_velocity() const; + + public: + void clear_set_velocity() ; + const ::df::plugin::SetVelocityAction& set_velocity() const; + [[nodiscard]] ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE release_set_velocity(); + ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL mutable_set_velocity(); + void set_allocated_set_velocity(::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_set_velocity(::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value); + ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE unsafe_arena_release_set_velocity(); + + private: + const ::df::plugin::SetVelocityAction& _internal_set_velocity() const; + ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL _internal_mutable_set_velocity(); + + public: + // .df.plugin.AddEffectAction add_effect = 30 [json_name = "addEffect"]; + bool has_add_effect() const; + private: + bool _internal_has_add_effect() const; + + public: + void clear_add_effect() ; + const ::df::plugin::AddEffectAction& add_effect() const; + [[nodiscard]] ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE release_add_effect(); + ::df::plugin::AddEffectAction* PROTOBUF_NONNULL mutable_add_effect(); + void set_allocated_add_effect(::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_add_effect(::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value); + ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE unsafe_arena_release_add_effect(); + + private: + const ::df::plugin::AddEffectAction& _internal_add_effect() const; + ::df::plugin::AddEffectAction* PROTOBUF_NONNULL _internal_mutable_add_effect(); + + public: + // .df.plugin.RemoveEffectAction remove_effect = 31 [json_name = "removeEffect"]; + bool has_remove_effect() const; + private: + bool _internal_has_remove_effect() const; + + public: + void clear_remove_effect() ; + const ::df::plugin::RemoveEffectAction& remove_effect() const; + [[nodiscard]] ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE release_remove_effect(); + ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL mutable_remove_effect(); + void set_allocated_remove_effect(::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_remove_effect(::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value); + ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE unsafe_arena_release_remove_effect(); + + private: + const ::df::plugin::RemoveEffectAction& _internal_remove_effect() const; + ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL _internal_mutable_remove_effect(); + + public: + // .df.plugin.SendTitleAction send_title = 40 [json_name = "sendTitle"]; + bool has_send_title() const; + private: + bool _internal_has_send_title() const; + + public: + void clear_send_title() ; + const ::df::plugin::SendTitleAction& send_title() const; + [[nodiscard]] ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE release_send_title(); + ::df::plugin::SendTitleAction* PROTOBUF_NONNULL mutable_send_title(); + void set_allocated_send_title(::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_send_title(::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value); + ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE unsafe_arena_release_send_title(); + + private: + const ::df::plugin::SendTitleAction& _internal_send_title() const; + ::df::plugin::SendTitleAction* PROTOBUF_NONNULL _internal_mutable_send_title(); + + public: + // .df.plugin.SendPopupAction send_popup = 41 [json_name = "sendPopup"]; + bool has_send_popup() const; + private: + bool _internal_has_send_popup() const; + + public: + void clear_send_popup() ; + const ::df::plugin::SendPopupAction& send_popup() const; + [[nodiscard]] ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE release_send_popup(); + ::df::plugin::SendPopupAction* PROTOBUF_NONNULL mutable_send_popup(); + void set_allocated_send_popup(::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_send_popup(::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value); + ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE unsafe_arena_release_send_popup(); + + private: + const ::df::plugin::SendPopupAction& _internal_send_popup() const; + ::df::plugin::SendPopupAction* PROTOBUF_NONNULL _internal_mutable_send_popup(); + + public: + // .df.plugin.SendTipAction send_tip = 42 [json_name = "sendTip"]; + bool has_send_tip() const; + private: + bool _internal_has_send_tip() const; + + public: + void clear_send_tip() ; + const ::df::plugin::SendTipAction& send_tip() const; + [[nodiscard]] ::df::plugin::SendTipAction* PROTOBUF_NULLABLE release_send_tip(); + ::df::plugin::SendTipAction* PROTOBUF_NONNULL mutable_send_tip(); + void set_allocated_send_tip(::df::plugin::SendTipAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_send_tip(::df::plugin::SendTipAction* PROTOBUF_NULLABLE value); + ::df::plugin::SendTipAction* PROTOBUF_NULLABLE unsafe_arena_release_send_tip(); + + private: + const ::df::plugin::SendTipAction& _internal_send_tip() const; + ::df::plugin::SendTipAction* PROTOBUF_NONNULL _internal_mutable_send_tip(); + + public: + // .df.plugin.PlaySoundAction play_sound = 43 [json_name = "playSound"]; + bool has_play_sound() const; + private: + bool _internal_has_play_sound() const; + + public: + void clear_play_sound() ; + const ::df::plugin::PlaySoundAction& play_sound() const; + [[nodiscard]] ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE release_play_sound(); + ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL mutable_play_sound(); + void set_allocated_play_sound(::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_play_sound(::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value); + ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE unsafe_arena_release_play_sound(); + + private: + const ::df::plugin::PlaySoundAction& _internal_play_sound() const; + ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL _internal_mutable_play_sound(); + + public: + // .df.plugin.ExecuteCommandAction execute_command = 50 [json_name = "executeCommand"]; + bool has_execute_command() const; + private: + bool _internal_has_execute_command() const; + + public: + void clear_execute_command() ; + const ::df::plugin::ExecuteCommandAction& execute_command() const; + [[nodiscard]] ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE release_execute_command(); + ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL mutable_execute_command(); + void set_allocated_execute_command(::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_execute_command(::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value); + ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE unsafe_arena_release_execute_command(); + + private: + const ::df::plugin::ExecuteCommandAction& _internal_execute_command() const; + ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL _internal_mutable_execute_command(); + + public: + // .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; + bool has_world_set_default_game_mode() const; + private: + bool _internal_has_world_set_default_game_mode() const; + + public: + void clear_world_set_default_game_mode() ; + const ::df::plugin::WorldSetDefaultGameModeAction& world_set_default_game_mode() const; + [[nodiscard]] ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE release_world_set_default_game_mode(); + ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NONNULL mutable_world_set_default_game_mode(); + void set_allocated_world_set_default_game_mode(::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_set_default_game_mode(::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE unsafe_arena_release_world_set_default_game_mode(); + + private: + const ::df::plugin::WorldSetDefaultGameModeAction& _internal_world_set_default_game_mode() const; + ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NONNULL _internal_mutable_world_set_default_game_mode(); + + public: + // .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; + bool has_world_set_difficulty() const; + private: + bool _internal_has_world_set_difficulty() const; + + public: + void clear_world_set_difficulty() ; + const ::df::plugin::WorldSetDifficultyAction& world_set_difficulty() const; + [[nodiscard]] ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE release_world_set_difficulty(); + ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NONNULL mutable_world_set_difficulty(); + void set_allocated_world_set_difficulty(::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_set_difficulty(::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE unsafe_arena_release_world_set_difficulty(); + + private: + const ::df::plugin::WorldSetDifficultyAction& _internal_world_set_difficulty() const; + ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NONNULL _internal_mutable_world_set_difficulty(); + + public: + // .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; + bool has_world_set_tick_range() const; + private: + bool _internal_has_world_set_tick_range() const; + + public: + void clear_world_set_tick_range() ; + const ::df::plugin::WorldSetTickRangeAction& world_set_tick_range() const; + [[nodiscard]] ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE release_world_set_tick_range(); + ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NONNULL mutable_world_set_tick_range(); + void set_allocated_world_set_tick_range(::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_set_tick_range(::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE unsafe_arena_release_world_set_tick_range(); + + private: + const ::df::plugin::WorldSetTickRangeAction& _internal_world_set_tick_range() const; + ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NONNULL _internal_mutable_world_set_tick_range(); + + public: + // .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; + bool has_world_set_block() const; + private: + bool _internal_has_world_set_block() const; + + public: + void clear_world_set_block() ; + const ::df::plugin::WorldSetBlockAction& world_set_block() const; + [[nodiscard]] ::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE release_world_set_block(); + ::df::plugin::WorldSetBlockAction* PROTOBUF_NONNULL mutable_world_set_block(); + void set_allocated_world_set_block(::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_set_block(::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE unsafe_arena_release_world_set_block(); + + private: + const ::df::plugin::WorldSetBlockAction& _internal_world_set_block() const; + ::df::plugin::WorldSetBlockAction* PROTOBUF_NONNULL _internal_mutable_world_set_block(); + + public: + // .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; + bool has_world_play_sound() const; + private: + bool _internal_has_world_play_sound() const; + + public: + void clear_world_play_sound() ; + const ::df::plugin::WorldPlaySoundAction& world_play_sound() const; + [[nodiscard]] ::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE release_world_play_sound(); + ::df::plugin::WorldPlaySoundAction* PROTOBUF_NONNULL mutable_world_play_sound(); + void set_allocated_world_play_sound(::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_play_sound(::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE unsafe_arena_release_world_play_sound(); + + private: + const ::df::plugin::WorldPlaySoundAction& _internal_world_play_sound() const; + ::df::plugin::WorldPlaySoundAction* PROTOBUF_NONNULL _internal_mutable_world_play_sound(); + + public: + // .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; + bool has_world_add_particle() const; + private: + bool _internal_has_world_add_particle() const; + + public: + void clear_world_add_particle() ; + const ::df::plugin::WorldAddParticleAction& world_add_particle() const; + [[nodiscard]] ::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE release_world_add_particle(); + ::df::plugin::WorldAddParticleAction* PROTOBUF_NONNULL mutable_world_add_particle(); + void set_allocated_world_add_particle(::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_add_particle(::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE unsafe_arena_release_world_add_particle(); + + private: + const ::df::plugin::WorldAddParticleAction& _internal_world_add_particle() const; + ::df::plugin::WorldAddParticleAction* PROTOBUF_NONNULL _internal_mutable_world_add_particle(); + + public: + // .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; + bool has_world_query_entities() const; + private: + bool _internal_has_world_query_entities() const; + + public: + void clear_world_query_entities() ; + const ::df::plugin::WorldQueryEntitiesAction& world_query_entities() const; + [[nodiscard]] ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE release_world_query_entities(); + ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NONNULL mutable_world_query_entities(); + void set_allocated_world_query_entities(::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_query_entities(::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE unsafe_arena_release_world_query_entities(); + + private: + const ::df::plugin::WorldQueryEntitiesAction& _internal_world_query_entities() const; + ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NONNULL _internal_mutable_world_query_entities(); + + public: + // .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; + bool has_world_query_players() const; + private: + bool _internal_has_world_query_players() const; + + public: + void clear_world_query_players() ; + const ::df::plugin::WorldQueryPlayersAction& world_query_players() const; + [[nodiscard]] ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE release_world_query_players(); + ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NONNULL mutable_world_query_players(); + void set_allocated_world_query_players(::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_query_players(::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE unsafe_arena_release_world_query_players(); + + private: + const ::df::plugin::WorldQueryPlayersAction& _internal_world_query_players() const; + ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NONNULL _internal_mutable_world_query_players(); + + public: + // .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; + bool has_world_query_entities_within() const; + private: + bool _internal_has_world_query_entities_within() const; + + public: + void clear_world_query_entities_within() ; + const ::df::plugin::WorldQueryEntitiesWithinAction& world_query_entities_within() const; + [[nodiscard]] ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE release_world_query_entities_within(); + ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL mutable_world_query_entities_within(); + void set_allocated_world_query_entities_within(::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_query_entities_within(::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE unsafe_arena_release_world_query_entities_within(); + + private: + const ::df::plugin::WorldQueryEntitiesWithinAction& _internal_world_query_entities_within() const; + ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL _internal_mutable_world_query_entities_within(); + + public: + // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; + bool has_world_query_viewers() const; + private: + bool _internal_has_world_query_viewers() const; + + public: + void clear_world_query_viewers() ; + const ::df::plugin::WorldQueryViewersAction& world_query_viewers() const; + [[nodiscard]] ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE release_world_query_viewers(); + ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL mutable_world_query_viewers(); + void set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value); + ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE unsafe_arena_release_world_query_viewers(); + + private: + const ::df::plugin::WorldQueryViewersAction& _internal_world_query_viewers() const; + ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL _internal_mutable_world_query_viewers(); + + public: + void clear_kind(); + KindCase kind_case() const; + // @@protoc_insertion_point(class_scope:df.plugin.Action) + private: + class _Internal; + void set_has_send_chat(); + void set_has_teleport(); + void set_has_kick(); + void set_has_set_game_mode(); + void set_has_give_item(); + void set_has_clear_inventory(); + void set_has_set_held_item(); + void set_has_set_health(); + void set_has_set_food(); + void set_has_set_experience(); + void set_has_set_velocity(); + void set_has_add_effect(); + void set_has_remove_effect(); + void set_has_send_title(); + void set_has_send_popup(); + void set_has_send_tip(); + void set_has_play_sound(); + void set_has_execute_command(); + void set_has_world_set_default_game_mode(); + void set_has_world_set_difficulty(); + void set_has_world_set_tick_range(); + void set_has_world_set_block(); + void set_has_world_play_sound(); + void set_has_world_add_particle(); + void set_has_world_query_entities(); + void set_has_world_query_players(); + void set_has_world_query_entities_within(); + void set_has_world_query_viewers(); + inline bool has_kind() const; + inline void clear_has_kind(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 29, + 28, 63, + 11> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const Action& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr correlation_id_; + union KindUnion { + constexpr KindUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE send_chat_; + ::google::protobuf::Message* PROTOBUF_NULLABLE teleport_; + ::google::protobuf::Message* PROTOBUF_NULLABLE kick_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_game_mode_; + ::google::protobuf::Message* PROTOBUF_NULLABLE give_item_; + ::google::protobuf::Message* PROTOBUF_NULLABLE clear_inventory_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_held_item_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_health_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_food_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_experience_; + ::google::protobuf::Message* PROTOBUF_NULLABLE set_velocity_; + ::google::protobuf::Message* PROTOBUF_NULLABLE add_effect_; + ::google::protobuf::Message* PROTOBUF_NULLABLE remove_effect_; + ::google::protobuf::Message* PROTOBUF_NULLABLE send_title_; + ::google::protobuf::Message* PROTOBUF_NULLABLE send_popup_; + ::google::protobuf::Message* PROTOBUF_NULLABLE send_tip_; + ::google::protobuf::Message* PROTOBUF_NULLABLE play_sound_; + ::google::protobuf::Message* PROTOBUF_NULLABLE execute_command_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_set_default_game_mode_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_set_difficulty_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_set_tick_range_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_set_block_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_play_sound_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_add_particle_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_entities_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_players_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_entities_within_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_viewers_; + } kind_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull Action_class_data_; +// ------------------------------------------------------------------- + +class ActionBatch final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.ActionBatch) */ { + public: + inline ActionBatch() : ActionBatch(nullptr) {} + ~ActionBatch() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ActionBatch* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ActionBatch)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ActionBatch(::google::protobuf::internal::ConstantInitialized); + + inline ActionBatch(const ActionBatch& from) : ActionBatch(nullptr, from) {} + inline ActionBatch(ActionBatch&& from) noexcept + : ActionBatch(nullptr, ::std::move(from)) {} + inline ActionBatch& operator=(const ActionBatch& from) { + CopyFrom(from); + return *this; + } + inline ActionBatch& operator=(ActionBatch&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const ActionBatch& default_instance() { + return *reinterpret_cast( + &_ActionBatch_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(ActionBatch& a, ActionBatch& b) { a.Swap(&b); } + inline void Swap(ActionBatch* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ActionBatch* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ActionBatch* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const ActionBatch& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const ActionBatch& from) { ActionBatch::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ActionBatch* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.ActionBatch"; } + + explicit ActionBatch(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + ActionBatch(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const ActionBatch& from); + ActionBatch( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, ActionBatch&& from) noexcept + : ActionBatch(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kActionsFieldNumber = 1, + }; + // repeated .df.plugin.Action actions = 1 [json_name = "actions"]; + int actions_size() const; + private: + int _internal_actions_size() const; + + public: + void clear_actions() ; + ::df::plugin::Action* PROTOBUF_NONNULL mutable_actions(int index); + ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL mutable_actions(); + + private: + const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& _internal_actions() const; + ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL _internal_mutable_actions(); + public: + const ::df::plugin::Action& actions(int index) const; + ::df::plugin::Action* PROTOBUF_NONNULL add_actions(); + const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& actions() const; + // @@protoc_insertion_point(class_scope:df.plugin.ActionBatch) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<0, 1, + 1, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const ActionBatch& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::RepeatedPtrField< ::df::plugin::Action > actions_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_actions_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull ActionBatch_class_data_; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ActionBatch + +// repeated .df.plugin.Action actions = 1 [json_name = "actions"]; +inline int ActionBatch::_internal_actions_size() const { + return _internal_actions().size(); +} +inline int ActionBatch::actions_size() const { + return _internal_actions_size(); +} +inline void ActionBatch::clear_actions() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.actions_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); +} +inline ::df::plugin::Action* PROTOBUF_NONNULL ActionBatch::mutable_actions(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:df.plugin.ActionBatch.actions) + return _internal_mutable_actions()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL ActionBatch::mutable_actions() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:df.plugin.ActionBatch.actions) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_actions(); +} +inline const ::df::plugin::Action& ActionBatch::actions(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionBatch.actions) + return _internal_actions().Get(index); +} +inline ::df::plugin::Action* PROTOBUF_NONNULL ActionBatch::add_actions() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::df::plugin::Action* _add = + _internal_mutable_actions()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:df.plugin.ActionBatch.actions) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& ActionBatch::actions() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:df.plugin.ActionBatch.actions) + return _internal_actions(); +} +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::Action>& +ActionBatch::_internal_actions() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.actions_; +} +inline ::google::protobuf::RepeatedPtrField<::df::plugin::Action>* PROTOBUF_NONNULL +ActionBatch::_internal_mutable_actions() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.actions_; +} + +// ------------------------------------------------------------------- + +// Action + +// optional string correlation_id = 1 [json_name = "correlationId"]; +inline bool Action::has_correlation_id() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + return value; +} +inline void Action::clear_correlation_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.correlation_id_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& Action::correlation_id() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.correlation_id) + return _internal_correlation_id(); +} +template +PROTOBUF_ALWAYS_INLINE void Action::set_correlation_id(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.correlation_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.Action.correlation_id) +} +inline ::std::string* PROTOBUF_NONNULL Action::mutable_correlation_id() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_correlation_id(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.correlation_id) + return _s; +} +inline const ::std::string& Action::_internal_correlation_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.correlation_id_.Get(); +} +inline void Action::_internal_set_correlation_id(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.correlation_id_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL Action::_internal_mutable_correlation_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.correlation_id_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE Action::release_correlation_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.Action.correlation_id) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.correlation_id_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.correlation_id_.Set("", GetArena()); + } + return released; +} +inline void Action::set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.correlation_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.correlation_id_.IsDefault()) { + _impl_.correlation_id_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.correlation_id) +} + +// .df.plugin.SendChatAction send_chat = 10 [json_name = "sendChat"]; +inline bool Action::has_send_chat() const { + return kind_case() == kSendChat; +} +inline bool Action::_internal_has_send_chat() const { + return kind_case() == kSendChat; +} +inline void Action::set_has_send_chat() { + _impl_._oneof_case_[0] = kSendChat; +} +inline void Action::clear_send_chat() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSendChat) { + if (GetArena() == nullptr) { + delete _impl_.kind_.send_chat_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_chat_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SendChatAction* PROTOBUF_NULLABLE Action::release_send_chat() { + // @@protoc_insertion_point(field_release:df.plugin.Action.send_chat) + if (kind_case() == kSendChat) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.send_chat_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SendChatAction& Action::_internal_send_chat() const { + return kind_case() == kSendChat ? static_cast(*reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_)) + : reinterpret_cast(::df::plugin::_SendChatAction_default_instance_); +} +inline const ::df::plugin::SendChatAction& Action::send_chat() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.send_chat) + return _internal_send_chat(); +} +inline ::df::plugin::SendChatAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_chat() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_chat) + if (kind_case() == kSendChat) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); + _impl_.kind_.send_chat_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_send_chat( + ::df::plugin::SendChatAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_send_chat(); + _impl_.kind_.send_chat_ = reinterpret_cast<::google::protobuf::Message*>(value); } // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_chat) } -inline ::df::plugin::SendChatAction* PROTOBUF_NONNULL Action::_internal_mutable_send_chat() { - if (kind_case() != kSendChat) { - clear_kind(); - set_has_send_chat(); - _impl_.kind_.send_chat_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendChatAction>(GetArena())); +inline ::df::plugin::SendChatAction* PROTOBUF_NONNULL Action::_internal_mutable_send_chat() { + if (kind_case() != kSendChat) { + clear_kind(); + set_has_send_chat(); + _impl_.kind_.send_chat_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendChatAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); +} +inline ::df::plugin::SendChatAction* PROTOBUF_NONNULL Action::mutable_send_chat() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SendChatAction* _msg = _internal_mutable_send_chat(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_chat) + return _msg; +} + +// .df.plugin.TeleportAction teleport = 11 [json_name = "teleport"]; +inline bool Action::has_teleport() const { + return kind_case() == kTeleport; +} +inline bool Action::_internal_has_teleport() const { + return kind_case() == kTeleport; +} +inline void Action::set_has_teleport() { + _impl_._oneof_case_[0] = kTeleport; +} +inline void Action::clear_teleport() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kTeleport) { + if (GetArena() == nullptr) { + delete _impl_.kind_.teleport_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.teleport_); + } + clear_has_kind(); + } +} +inline ::df::plugin::TeleportAction* PROTOBUF_NULLABLE Action::release_teleport() { + // @@protoc_insertion_point(field_release:df.plugin.Action.teleport) + if (kind_case() == kTeleport) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.teleport_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::TeleportAction& Action::_internal_teleport() const { + return kind_case() == kTeleport ? static_cast(*reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_)) + : reinterpret_cast(::df::plugin::_TeleportAction_default_instance_); +} +inline const ::df::plugin::TeleportAction& Action::teleport() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.teleport) + return _internal_teleport(); +} +inline ::df::plugin::TeleportAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_teleport() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.teleport) + if (kind_case() == kTeleport) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); + _impl_.kind_.teleport_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_teleport( + ::df::plugin::TeleportAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_teleport(); + _impl_.kind_.teleport_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.teleport) +} +inline ::df::plugin::TeleportAction* PROTOBUF_NONNULL Action::_internal_mutable_teleport() { + if (kind_case() != kTeleport) { + clear_kind(); + set_has_teleport(); + _impl_.kind_.teleport_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::TeleportAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); +} +inline ::df::plugin::TeleportAction* PROTOBUF_NONNULL Action::mutable_teleport() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::TeleportAction* _msg = _internal_mutable_teleport(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.teleport) + return _msg; +} + +// .df.plugin.KickAction kick = 12 [json_name = "kick"]; +inline bool Action::has_kick() const { + return kind_case() == kKick; +} +inline bool Action::_internal_has_kick() const { + return kind_case() == kKick; +} +inline void Action::set_has_kick() { + _impl_._oneof_case_[0] = kKick; +} +inline void Action::clear_kick() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kKick) { + if (GetArena() == nullptr) { + delete _impl_.kind_.kick_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.kick_); + } + clear_has_kind(); + } +} +inline ::df::plugin::KickAction* PROTOBUF_NULLABLE Action::release_kick() { + // @@protoc_insertion_point(field_release:df.plugin.Action.kick) + if (kind_case() == kKick) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.kick_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::KickAction& Action::_internal_kick() const { + return kind_case() == kKick ? static_cast(*reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_)) + : reinterpret_cast(::df::plugin::_KickAction_default_instance_); +} +inline const ::df::plugin::KickAction& Action::kick() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.kick) + return _internal_kick(); +} +inline ::df::plugin::KickAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_kick() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.kick) + if (kind_case() == kKick) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); + _impl_.kind_.kick_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_kick( + ::df::plugin::KickAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_kick(); + _impl_.kind_.kick_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.kick) +} +inline ::df::plugin::KickAction* PROTOBUF_NONNULL Action::_internal_mutable_kick() { + if (kind_case() != kKick) { + clear_kind(); + set_has_kick(); + _impl_.kind_.kick_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::KickAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); +} +inline ::df::plugin::KickAction* PROTOBUF_NONNULL Action::mutable_kick() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::KickAction* _msg = _internal_mutable_kick(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.kick) + return _msg; +} + +// .df.plugin.SetGameModeAction set_game_mode = 13 [json_name = "setGameMode"]; +inline bool Action::has_set_game_mode() const { + return kind_case() == kSetGameMode; +} +inline bool Action::_internal_has_set_game_mode() const { + return kind_case() == kSetGameMode; +} +inline void Action::set_has_set_game_mode() { + _impl_._oneof_case_[0] = kSetGameMode; +} +inline void Action::clear_set_game_mode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetGameMode) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_game_mode_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_game_mode_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE Action::release_set_game_mode() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_game_mode) + if (kind_case() == kSetGameMode) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_game_mode_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetGameModeAction& Action::_internal_set_game_mode() const { + return kind_case() == kSetGameMode ? static_cast(*reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_)) + : reinterpret_cast(::df::plugin::_SetGameModeAction_default_instance_); +} +inline const ::df::plugin::SetGameModeAction& Action::set_game_mode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_game_mode) + return _internal_set_game_mode(); +} +inline ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_game_mode() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_game_mode) + if (kind_case() == kSetGameMode) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); + _impl_.kind_.set_game_mode_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_game_mode( + ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_game_mode(); + _impl_.kind_.set_game_mode_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_game_mode) +} +inline ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL Action::_internal_mutable_set_game_mode() { + if (kind_case() != kSetGameMode) { + clear_kind(); + set_has_set_game_mode(); + _impl_.kind_.set_game_mode_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetGameModeAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); +} +inline ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL Action::mutable_set_game_mode() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetGameModeAction* _msg = _internal_mutable_set_game_mode(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_game_mode) + return _msg; +} + +// .df.plugin.GiveItemAction give_item = 14 [json_name = "giveItem"]; +inline bool Action::has_give_item() const { + return kind_case() == kGiveItem; +} +inline bool Action::_internal_has_give_item() const { + return kind_case() == kGiveItem; +} +inline void Action::set_has_give_item() { + _impl_._oneof_case_[0] = kGiveItem; +} +inline void Action::clear_give_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kGiveItem) { + if (GetArena() == nullptr) { + delete _impl_.kind_.give_item_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.give_item_); + } + clear_has_kind(); + } +} +inline ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE Action::release_give_item() { + // @@protoc_insertion_point(field_release:df.plugin.Action.give_item) + if (kind_case() == kGiveItem) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.give_item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::GiveItemAction& Action::_internal_give_item() const { + return kind_case() == kGiveItem ? static_cast(*reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_)) + : reinterpret_cast(::df::plugin::_GiveItemAction_default_instance_); +} +inline const ::df::plugin::GiveItemAction& Action::give_item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.give_item) + return _internal_give_item(); +} +inline ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_give_item() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.give_item) + if (kind_case() == kGiveItem) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); + _impl_.kind_.give_item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_give_item( + ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_give_item(); + _impl_.kind_.give_item_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.give_item) +} +inline ::df::plugin::GiveItemAction* PROTOBUF_NONNULL Action::_internal_mutable_give_item() { + if (kind_case() != kGiveItem) { + clear_kind(); + set_has_give_item(); + _impl_.kind_.give_item_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::GiveItemAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); +} +inline ::df::plugin::GiveItemAction* PROTOBUF_NONNULL Action::mutable_give_item() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::GiveItemAction* _msg = _internal_mutable_give_item(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.give_item) + return _msg; +} + +// .df.plugin.ClearInventoryAction clear_inventory = 15 [json_name = "clearInventory"]; +inline bool Action::has_clear_inventory() const { + return kind_case() == kClearInventory; +} +inline bool Action::_internal_has_clear_inventory() const { + return kind_case() == kClearInventory; +} +inline void Action::set_has_clear_inventory() { + _impl_._oneof_case_[0] = kClearInventory; +} +inline void Action::clear_clear_inventory() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kClearInventory) { + if (GetArena() == nullptr) { + delete _impl_.kind_.clear_inventory_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.clear_inventory_); + } + clear_has_kind(); + } +} +inline ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE Action::release_clear_inventory() { + // @@protoc_insertion_point(field_release:df.plugin.Action.clear_inventory) + if (kind_case() == kClearInventory) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.clear_inventory_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::ClearInventoryAction& Action::_internal_clear_inventory() const { + return kind_case() == kClearInventory ? static_cast(*reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_)) + : reinterpret_cast(::df::plugin::_ClearInventoryAction_default_instance_); +} +inline const ::df::plugin::ClearInventoryAction& Action::clear_inventory() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.clear_inventory) + return _internal_clear_inventory(); +} +inline ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_clear_inventory() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.clear_inventory) + if (kind_case() == kClearInventory) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); + _impl_.kind_.clear_inventory_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_clear_inventory( + ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_clear_inventory(); + _impl_.kind_.clear_inventory_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.clear_inventory) +} +inline ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL Action::_internal_mutable_clear_inventory() { + if (kind_case() != kClearInventory) { + clear_kind(); + set_has_clear_inventory(); + _impl_.kind_.clear_inventory_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::ClearInventoryAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); +} +inline ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL Action::mutable_clear_inventory() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::ClearInventoryAction* _msg = _internal_mutable_clear_inventory(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.clear_inventory) + return _msg; +} + +// .df.plugin.SetHeldItemAction set_held_item = 16 [json_name = "setHeldItem"]; +inline bool Action::has_set_held_item() const { + return kind_case() == kSetHeldItem; +} +inline bool Action::_internal_has_set_held_item() const { + return kind_case() == kSetHeldItem; +} +inline void Action::set_has_set_held_item() { + _impl_._oneof_case_[0] = kSetHeldItem; +} +inline void Action::clear_set_held_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetHeldItem) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_held_item_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_held_item_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE Action::release_set_held_item() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_held_item) + if (kind_case() == kSetHeldItem) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_held_item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetHeldItemAction& Action::_internal_set_held_item() const { + return kind_case() == kSetHeldItem ? static_cast(*reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_)) + : reinterpret_cast(::df::plugin::_SetHeldItemAction_default_instance_); +} +inline const ::df::plugin::SetHeldItemAction& Action::set_held_item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_held_item) + return _internal_set_held_item(); +} +inline ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_held_item() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_held_item) + if (kind_case() == kSetHeldItem) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); + _impl_.kind_.set_held_item_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_held_item( + ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_held_item(); + _impl_.kind_.set_held_item_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_held_item) +} +inline ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL Action::_internal_mutable_set_held_item() { + if (kind_case() != kSetHeldItem) { + clear_kind(); + set_has_set_held_item(); + _impl_.kind_.set_held_item_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetHeldItemAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); +} +inline ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL Action::mutable_set_held_item() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetHeldItemAction* _msg = _internal_mutable_set_held_item(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_held_item) + return _msg; +} + +// .df.plugin.SetHealthAction set_health = 20 [json_name = "setHealth"]; +inline bool Action::has_set_health() const { + return kind_case() == kSetHealth; +} +inline bool Action::_internal_has_set_health() const { + return kind_case() == kSetHealth; +} +inline void Action::set_has_set_health() { + _impl_._oneof_case_[0] = kSetHealth; +} +inline void Action::clear_set_health() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetHealth) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_health_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_health_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE Action::release_set_health() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_health) + if (kind_case() == kSetHealth) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_health_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetHealthAction& Action::_internal_set_health() const { + return kind_case() == kSetHealth ? static_cast(*reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_)) + : reinterpret_cast(::df::plugin::_SetHealthAction_default_instance_); +} +inline const ::df::plugin::SetHealthAction& Action::set_health() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_health) + return _internal_set_health(); +} +inline ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_health() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_health) + if (kind_case() == kSetHealth) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); + _impl_.kind_.set_health_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_health( + ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_health(); + _impl_.kind_.set_health_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_health) +} +inline ::df::plugin::SetHealthAction* PROTOBUF_NONNULL Action::_internal_mutable_set_health() { + if (kind_case() != kSetHealth) { + clear_kind(); + set_has_set_health(); + _impl_.kind_.set_health_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetHealthAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); +} +inline ::df::plugin::SetHealthAction* PROTOBUF_NONNULL Action::mutable_set_health() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetHealthAction* _msg = _internal_mutable_set_health(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_health) + return _msg; +} + +// .df.plugin.SetFoodAction set_food = 21 [json_name = "setFood"]; +inline bool Action::has_set_food() const { + return kind_case() == kSetFood; +} +inline bool Action::_internal_has_set_food() const { + return kind_case() == kSetFood; +} +inline void Action::set_has_set_food() { + _impl_._oneof_case_[0] = kSetFood; +} +inline void Action::clear_set_food() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetFood) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_food_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_food_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE Action::release_set_food() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_food) + if (kind_case() == kSetFood) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_food_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetFoodAction& Action::_internal_set_food() const { + return kind_case() == kSetFood ? static_cast(*reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_)) + : reinterpret_cast(::df::plugin::_SetFoodAction_default_instance_); +} +inline const ::df::plugin::SetFoodAction& Action::set_food() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_food) + return _internal_set_food(); +} +inline ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_food() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_food) + if (kind_case() == kSetFood) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); + _impl_.kind_.set_food_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_food( + ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_food(); + _impl_.kind_.set_food_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_food) +} +inline ::df::plugin::SetFoodAction* PROTOBUF_NONNULL Action::_internal_mutable_set_food() { + if (kind_case() != kSetFood) { + clear_kind(); + set_has_set_food(); + _impl_.kind_.set_food_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetFoodAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); +} +inline ::df::plugin::SetFoodAction* PROTOBUF_NONNULL Action::mutable_set_food() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetFoodAction* _msg = _internal_mutable_set_food(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_food) + return _msg; +} + +// .df.plugin.SetExperienceAction set_experience = 22 [json_name = "setExperience"]; +inline bool Action::has_set_experience() const { + return kind_case() == kSetExperience; +} +inline bool Action::_internal_has_set_experience() const { + return kind_case() == kSetExperience; +} +inline void Action::set_has_set_experience() { + _impl_._oneof_case_[0] = kSetExperience; +} +inline void Action::clear_set_experience() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetExperience) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_experience_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_experience_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE Action::release_set_experience() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_experience) + if (kind_case() == kSetExperience) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_experience_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetExperienceAction& Action::_internal_set_experience() const { + return kind_case() == kSetExperience ? static_cast(*reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_)) + : reinterpret_cast(::df::plugin::_SetExperienceAction_default_instance_); +} +inline const ::df::plugin::SetExperienceAction& Action::set_experience() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_experience) + return _internal_set_experience(); +} +inline ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_experience() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_experience) + if (kind_case() == kSetExperience) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); + _impl_.kind_.set_experience_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_experience( + ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_experience(); + _impl_.kind_.set_experience_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_experience) +} +inline ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL Action::_internal_mutable_set_experience() { + if (kind_case() != kSetExperience) { + clear_kind(); + set_has_set_experience(); + _impl_.kind_.set_experience_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetExperienceAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); +} +inline ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL Action::mutable_set_experience() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetExperienceAction* _msg = _internal_mutable_set_experience(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_experience) + return _msg; +} + +// .df.plugin.SetVelocityAction set_velocity = 23 [json_name = "setVelocity"]; +inline bool Action::has_set_velocity() const { + return kind_case() == kSetVelocity; +} +inline bool Action::_internal_has_set_velocity() const { + return kind_case() == kSetVelocity; +} +inline void Action::set_has_set_velocity() { + _impl_._oneof_case_[0] = kSetVelocity; +} +inline void Action::clear_set_velocity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSetVelocity) { + if (GetArena() == nullptr) { + delete _impl_.kind_.set_velocity_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_velocity_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE Action::release_set_velocity() { + // @@protoc_insertion_point(field_release:df.plugin.Action.set_velocity) + if (kind_case() == kSetVelocity) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.set_velocity_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SetVelocityAction& Action::_internal_set_velocity() const { + return kind_case() == kSetVelocity ? static_cast(*reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_)) + : reinterpret_cast(::df::plugin::_SetVelocityAction_default_instance_); +} +inline const ::df::plugin::SetVelocityAction& Action::set_velocity() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.set_velocity) + return _internal_set_velocity(); +} +inline ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_velocity() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_velocity) + if (kind_case() == kSetVelocity) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); + _impl_.kind_.set_velocity_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_set_velocity( + ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_set_velocity(); + _impl_.kind_.set_velocity_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_velocity) +} +inline ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL Action::_internal_mutable_set_velocity() { + if (kind_case() != kSetVelocity) { + clear_kind(); + set_has_set_velocity(); + _impl_.kind_.set_velocity_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetVelocityAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); +} +inline ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL Action::mutable_set_velocity() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SetVelocityAction* _msg = _internal_mutable_set_velocity(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_velocity) + return _msg; +} + +// .df.plugin.AddEffectAction add_effect = 30 [json_name = "addEffect"]; +inline bool Action::has_add_effect() const { + return kind_case() == kAddEffect; +} +inline bool Action::_internal_has_add_effect() const { + return kind_case() == kAddEffect; +} +inline void Action::set_has_add_effect() { + _impl_._oneof_case_[0] = kAddEffect; +} +inline void Action::clear_add_effect() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kAddEffect) { + if (GetArena() == nullptr) { + delete _impl_.kind_.add_effect_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.add_effect_); + } + clear_has_kind(); + } +} +inline ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE Action::release_add_effect() { + // @@protoc_insertion_point(field_release:df.plugin.Action.add_effect) + if (kind_case() == kAddEffect) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.add_effect_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::AddEffectAction& Action::_internal_add_effect() const { + return kind_case() == kAddEffect ? static_cast(*reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_)) + : reinterpret_cast(::df::plugin::_AddEffectAction_default_instance_); +} +inline const ::df::plugin::AddEffectAction& Action::add_effect() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.add_effect) + return _internal_add_effect(); +} +inline ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_add_effect() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.add_effect) + if (kind_case() == kAddEffect) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); + _impl_.kind_.add_effect_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_add_effect( + ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_add_effect(); + _impl_.kind_.add_effect_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.add_effect) +} +inline ::df::plugin::AddEffectAction* PROTOBUF_NONNULL Action::_internal_mutable_add_effect() { + if (kind_case() != kAddEffect) { + clear_kind(); + set_has_add_effect(); + _impl_.kind_.add_effect_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::AddEffectAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); +} +inline ::df::plugin::AddEffectAction* PROTOBUF_NONNULL Action::mutable_add_effect() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::AddEffectAction* _msg = _internal_mutable_add_effect(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.add_effect) + return _msg; +} + +// .df.plugin.RemoveEffectAction remove_effect = 31 [json_name = "removeEffect"]; +inline bool Action::has_remove_effect() const { + return kind_case() == kRemoveEffect; +} +inline bool Action::_internal_has_remove_effect() const { + return kind_case() == kRemoveEffect; +} +inline void Action::set_has_remove_effect() { + _impl_._oneof_case_[0] = kRemoveEffect; +} +inline void Action::clear_remove_effect() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kRemoveEffect) { + if (GetArena() == nullptr) { + delete _impl_.kind_.remove_effect_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.remove_effect_); + } + clear_has_kind(); + } +} +inline ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE Action::release_remove_effect() { + // @@protoc_insertion_point(field_release:df.plugin.Action.remove_effect) + if (kind_case() == kRemoveEffect) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.remove_effect_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::RemoveEffectAction& Action::_internal_remove_effect() const { + return kind_case() == kRemoveEffect ? static_cast(*reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_)) + : reinterpret_cast(::df::plugin::_RemoveEffectAction_default_instance_); +} +inline const ::df::plugin::RemoveEffectAction& Action::remove_effect() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.remove_effect) + return _internal_remove_effect(); +} +inline ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_remove_effect() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.remove_effect) + if (kind_case() == kRemoveEffect) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); + _impl_.kind_.remove_effect_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_remove_effect( + ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_remove_effect(); + _impl_.kind_.remove_effect_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.remove_effect) +} +inline ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL Action::_internal_mutable_remove_effect() { + if (kind_case() != kRemoveEffect) { + clear_kind(); + set_has_remove_effect(); + _impl_.kind_.remove_effect_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::RemoveEffectAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); +} +inline ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL Action::mutable_remove_effect() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::RemoveEffectAction* _msg = _internal_mutable_remove_effect(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.remove_effect) + return _msg; +} + +// .df.plugin.SendTitleAction send_title = 40 [json_name = "sendTitle"]; +inline bool Action::has_send_title() const { + return kind_case() == kSendTitle; +} +inline bool Action::_internal_has_send_title() const { + return kind_case() == kSendTitle; +} +inline void Action::set_has_send_title() { + _impl_._oneof_case_[0] = kSendTitle; +} +inline void Action::clear_send_title() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSendTitle) { + if (GetArena() == nullptr) { + delete _impl_.kind_.send_title_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_title_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE Action::release_send_title() { + // @@protoc_insertion_point(field_release:df.plugin.Action.send_title) + if (kind_case() == kSendTitle) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.send_title_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SendTitleAction& Action::_internal_send_title() const { + return kind_case() == kSendTitle ? static_cast(*reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_)) + : reinterpret_cast(::df::plugin::_SendTitleAction_default_instance_); +} +inline const ::df::plugin::SendTitleAction& Action::send_title() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.send_title) + return _internal_send_title(); +} +inline ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_title() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_title) + if (kind_case() == kSendTitle) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); + _impl_.kind_.send_title_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_send_title( + ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_send_title(); + _impl_.kind_.send_title_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_title) +} +inline ::df::plugin::SendTitleAction* PROTOBUF_NONNULL Action::_internal_mutable_send_title() { + if (kind_case() != kSendTitle) { + clear_kind(); + set_has_send_title(); + _impl_.kind_.send_title_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendTitleAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); +} +inline ::df::plugin::SendTitleAction* PROTOBUF_NONNULL Action::mutable_send_title() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SendTitleAction* _msg = _internal_mutable_send_title(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_title) + return _msg; +} + +// .df.plugin.SendPopupAction send_popup = 41 [json_name = "sendPopup"]; +inline bool Action::has_send_popup() const { + return kind_case() == kSendPopup; +} +inline bool Action::_internal_has_send_popup() const { + return kind_case() == kSendPopup; +} +inline void Action::set_has_send_popup() { + _impl_._oneof_case_[0] = kSendPopup; +} +inline void Action::clear_send_popup() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSendPopup) { + if (GetArena() == nullptr) { + delete _impl_.kind_.send_popup_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_popup_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE Action::release_send_popup() { + // @@protoc_insertion_point(field_release:df.plugin.Action.send_popup) + if (kind_case() == kSendPopup) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.send_popup_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SendPopupAction& Action::_internal_send_popup() const { + return kind_case() == kSendPopup ? static_cast(*reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_)) + : reinterpret_cast(::df::plugin::_SendPopupAction_default_instance_); +} +inline const ::df::plugin::SendPopupAction& Action::send_popup() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.send_popup) + return _internal_send_popup(); +} +inline ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_popup() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_popup) + if (kind_case() == kSendPopup) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); + _impl_.kind_.send_popup_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_send_popup( + ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_send_popup(); + _impl_.kind_.send_popup_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_popup) +} +inline ::df::plugin::SendPopupAction* PROTOBUF_NONNULL Action::_internal_mutable_send_popup() { + if (kind_case() != kSendPopup) { + clear_kind(); + set_has_send_popup(); + _impl_.kind_.send_popup_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendPopupAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); +} +inline ::df::plugin::SendPopupAction* PROTOBUF_NONNULL Action::mutable_send_popup() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SendPopupAction* _msg = _internal_mutable_send_popup(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_popup) + return _msg; +} + +// .df.plugin.SendTipAction send_tip = 42 [json_name = "sendTip"]; +inline bool Action::has_send_tip() const { + return kind_case() == kSendTip; +} +inline bool Action::_internal_has_send_tip() const { + return kind_case() == kSendTip; +} +inline void Action::set_has_send_tip() { + _impl_._oneof_case_[0] = kSendTip; +} +inline void Action::clear_send_tip() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kSendTip) { + if (GetArena() == nullptr) { + delete _impl_.kind_.send_tip_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_tip_); + } + clear_has_kind(); + } +} +inline ::df::plugin::SendTipAction* PROTOBUF_NULLABLE Action::release_send_tip() { + // @@protoc_insertion_point(field_release:df.plugin.Action.send_tip) + if (kind_case() == kSendTip) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.send_tip_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::SendTipAction& Action::_internal_send_tip() const { + return kind_case() == kSendTip ? static_cast(*reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_)) + : reinterpret_cast(::df::plugin::_SendTipAction_default_instance_); +} +inline const ::df::plugin::SendTipAction& Action::send_tip() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.send_tip) + return _internal_send_tip(); +} +inline ::df::plugin::SendTipAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_tip() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_tip) + if (kind_case() == kSendTip) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); + _impl_.kind_.send_tip_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_send_tip( + ::df::plugin::SendTipAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_send_tip(); + _impl_.kind_.send_tip_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_tip) +} +inline ::df::plugin::SendTipAction* PROTOBUF_NONNULL Action::_internal_mutable_send_tip() { + if (kind_case() != kSendTip) { + clear_kind(); + set_has_send_tip(); + _impl_.kind_.send_tip_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendTipAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); +} +inline ::df::plugin::SendTipAction* PROTOBUF_NONNULL Action::mutable_send_tip() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::SendTipAction* _msg = _internal_mutable_send_tip(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_tip) + return _msg; +} + +// .df.plugin.PlaySoundAction play_sound = 43 [json_name = "playSound"]; +inline bool Action::has_play_sound() const { + return kind_case() == kPlaySound; +} +inline bool Action::_internal_has_play_sound() const { + return kind_case() == kPlaySound; +} +inline void Action::set_has_play_sound() { + _impl_._oneof_case_[0] = kPlaySound; +} +inline void Action::clear_play_sound() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kPlaySound) { + if (GetArena() == nullptr) { + delete _impl_.kind_.play_sound_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.play_sound_); + } + clear_has_kind(); + } +} +inline ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE Action::release_play_sound() { + // @@protoc_insertion_point(field_release:df.plugin.Action.play_sound) + if (kind_case() == kPlaySound) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.play_sound_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::PlaySoundAction& Action::_internal_play_sound() const { + return kind_case() == kPlaySound ? static_cast(*reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_)) + : reinterpret_cast(::df::plugin::_PlaySoundAction_default_instance_); +} +inline const ::df::plugin::PlaySoundAction& Action::play_sound() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.play_sound) + return _internal_play_sound(); +} +inline ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_play_sound() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.play_sound) + if (kind_case() == kPlaySound) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); + _impl_.kind_.play_sound_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_play_sound( + ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_play_sound(); + _impl_.kind_.play_sound_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.play_sound) +} +inline ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL Action::_internal_mutable_play_sound() { + if (kind_case() != kPlaySound) { + clear_kind(); + set_has_play_sound(); + _impl_.kind_.play_sound_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::PlaySoundAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); +} +inline ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL Action::mutable_play_sound() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::PlaySoundAction* _msg = _internal_mutable_play_sound(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.play_sound) + return _msg; +} + +// .df.plugin.ExecuteCommandAction execute_command = 50 [json_name = "executeCommand"]; +inline bool Action::has_execute_command() const { + return kind_case() == kExecuteCommand; +} +inline bool Action::_internal_has_execute_command() const { + return kind_case() == kExecuteCommand; +} +inline void Action::set_has_execute_command() { + _impl_._oneof_case_[0] = kExecuteCommand; +} +inline void Action::clear_execute_command() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kExecuteCommand) { + if (GetArena() == nullptr) { + delete _impl_.kind_.execute_command_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.execute_command_); + } + clear_has_kind(); + } +} +inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE Action::release_execute_command() { + // @@protoc_insertion_point(field_release:df.plugin.Action.execute_command) + if (kind_case() == kExecuteCommand) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.execute_command_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::ExecuteCommandAction& Action::_internal_execute_command() const { + return kind_case() == kExecuteCommand ? static_cast(*reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_)) + : reinterpret_cast(::df::plugin::_ExecuteCommandAction_default_instance_); +} +inline const ::df::plugin::ExecuteCommandAction& Action::execute_command() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.execute_command) + return _internal_execute_command(); +} +inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_execute_command() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.execute_command) + if (kind_case() == kExecuteCommand) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); + _impl_.kind_.execute_command_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_execute_command( + ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_execute_command(); + _impl_.kind_.execute_command_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.execute_command) +} +inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL Action::_internal_mutable_execute_command() { + if (kind_case() != kExecuteCommand) { + clear_kind(); + set_has_execute_command(); + _impl_.kind_.execute_command_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::ExecuteCommandAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); +} +inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL Action::mutable_execute_command() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::ExecuteCommandAction* _msg = _internal_mutable_execute_command(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.execute_command) + return _msg; +} + +// .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; +inline bool Action::has_world_set_default_game_mode() const { + return kind_case() == kWorldSetDefaultGameMode; +} +inline bool Action::_internal_has_world_set_default_game_mode() const { + return kind_case() == kWorldSetDefaultGameMode; +} +inline void Action::set_has_world_set_default_game_mode() { + _impl_._oneof_case_[0] = kWorldSetDefaultGameMode; +} +inline void Action::clear_world_set_default_game_mode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldSetDefaultGameMode) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_default_game_mode_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_default_game_mode_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE Action::release_world_set_default_game_mode() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_set_default_game_mode) + if (kind_case() == kWorldSetDefaultGameMode) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetDefaultGameModeAction*>(_impl_.kind_.world_set_default_game_mode_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_set_default_game_mode_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldSetDefaultGameModeAction& Action::_internal_world_set_default_game_mode() const { + return kind_case() == kWorldSetDefaultGameMode ? static_cast(*reinterpret_cast<::df::plugin::WorldSetDefaultGameModeAction*>(_impl_.kind_.world_set_default_game_mode_)) + : reinterpret_cast(::df::plugin::_WorldSetDefaultGameModeAction_default_instance_); +} +inline const ::df::plugin::WorldSetDefaultGameModeAction& Action::world_set_default_game_mode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_set_default_game_mode) + return _internal_world_set_default_game_mode(); +} +inline ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_set_default_game_mode() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_set_default_game_mode) + if (kind_case() == kWorldSetDefaultGameMode) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetDefaultGameModeAction*>(_impl_.kind_.world_set_default_game_mode_); + _impl_.kind_.world_set_default_game_mode_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_set_default_game_mode( + ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_set_default_game_mode(); + _impl_.kind_.world_set_default_game_mode_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_set_default_game_mode) +} +inline ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NONNULL Action::_internal_mutable_world_set_default_game_mode() { + if (kind_case() != kWorldSetDefaultGameMode) { + clear_kind(); + set_has_world_set_default_game_mode(); + _impl_.kind_.world_set_default_game_mode_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldSetDefaultGameModeAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldSetDefaultGameModeAction*>(_impl_.kind_.world_set_default_game_mode_); +} +inline ::df::plugin::WorldSetDefaultGameModeAction* PROTOBUF_NONNULL Action::mutable_world_set_default_game_mode() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldSetDefaultGameModeAction* _msg = _internal_mutable_world_set_default_game_mode(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_set_default_game_mode) + return _msg; +} + +// .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; +inline bool Action::has_world_set_difficulty() const { + return kind_case() == kWorldSetDifficulty; +} +inline bool Action::_internal_has_world_set_difficulty() const { + return kind_case() == kWorldSetDifficulty; +} +inline void Action::set_has_world_set_difficulty() { + _impl_._oneof_case_[0] = kWorldSetDifficulty; +} +inline void Action::clear_world_set_difficulty() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldSetDifficulty) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_difficulty_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_difficulty_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE Action::release_world_set_difficulty() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_set_difficulty) + if (kind_case() == kWorldSetDifficulty) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetDifficultyAction*>(_impl_.kind_.world_set_difficulty_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_set_difficulty_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldSetDifficultyAction& Action::_internal_world_set_difficulty() const { + return kind_case() == kWorldSetDifficulty ? static_cast(*reinterpret_cast<::df::plugin::WorldSetDifficultyAction*>(_impl_.kind_.world_set_difficulty_)) + : reinterpret_cast(::df::plugin::_WorldSetDifficultyAction_default_instance_); +} +inline const ::df::plugin::WorldSetDifficultyAction& Action::world_set_difficulty() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_set_difficulty) + return _internal_world_set_difficulty(); +} +inline ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_set_difficulty() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_set_difficulty) + if (kind_case() == kWorldSetDifficulty) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetDifficultyAction*>(_impl_.kind_.world_set_difficulty_); + _impl_.kind_.world_set_difficulty_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_set_difficulty( + ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_set_difficulty(); + _impl_.kind_.world_set_difficulty_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_set_difficulty) +} +inline ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NONNULL Action::_internal_mutable_world_set_difficulty() { + if (kind_case() != kWorldSetDifficulty) { + clear_kind(); + set_has_world_set_difficulty(); + _impl_.kind_.world_set_difficulty_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldSetDifficultyAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldSetDifficultyAction*>(_impl_.kind_.world_set_difficulty_); +} +inline ::df::plugin::WorldSetDifficultyAction* PROTOBUF_NONNULL Action::mutable_world_set_difficulty() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldSetDifficultyAction* _msg = _internal_mutable_world_set_difficulty(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_set_difficulty) + return _msg; +} + +// .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; +inline bool Action::has_world_set_tick_range() const { + return kind_case() == kWorldSetTickRange; +} +inline bool Action::_internal_has_world_set_tick_range() const { + return kind_case() == kWorldSetTickRange; +} +inline void Action::set_has_world_set_tick_range() { + _impl_._oneof_case_[0] = kWorldSetTickRange; +} +inline void Action::clear_world_set_tick_range() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldSetTickRange) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_tick_range_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_tick_range_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE Action::release_world_set_tick_range() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_set_tick_range) + if (kind_case() == kWorldSetTickRange) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetTickRangeAction*>(_impl_.kind_.world_set_tick_range_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_set_tick_range_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldSetTickRangeAction& Action::_internal_world_set_tick_range() const { + return kind_case() == kWorldSetTickRange ? static_cast(*reinterpret_cast<::df::plugin::WorldSetTickRangeAction*>(_impl_.kind_.world_set_tick_range_)) + : reinterpret_cast(::df::plugin::_WorldSetTickRangeAction_default_instance_); +} +inline const ::df::plugin::WorldSetTickRangeAction& Action::world_set_tick_range() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_set_tick_range) + return _internal_world_set_tick_range(); +} +inline ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_set_tick_range() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_set_tick_range) + if (kind_case() == kWorldSetTickRange) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetTickRangeAction*>(_impl_.kind_.world_set_tick_range_); + _impl_.kind_.world_set_tick_range_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_set_tick_range( + ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_set_tick_range(); + _impl_.kind_.world_set_tick_range_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_set_tick_range) +} +inline ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NONNULL Action::_internal_mutable_world_set_tick_range() { + if (kind_case() != kWorldSetTickRange) { + clear_kind(); + set_has_world_set_tick_range(); + _impl_.kind_.world_set_tick_range_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldSetTickRangeAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldSetTickRangeAction*>(_impl_.kind_.world_set_tick_range_); +} +inline ::df::plugin::WorldSetTickRangeAction* PROTOBUF_NONNULL Action::mutable_world_set_tick_range() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldSetTickRangeAction* _msg = _internal_mutable_world_set_tick_range(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_set_tick_range) + return _msg; +} + +// .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; +inline bool Action::has_world_set_block() const { + return kind_case() == kWorldSetBlock; +} +inline bool Action::_internal_has_world_set_block() const { + return kind_case() == kWorldSetBlock; +} +inline void Action::set_has_world_set_block() { + _impl_._oneof_case_[0] = kWorldSetBlock; +} +inline void Action::clear_world_set_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldSetBlock) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_set_block_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_set_block_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE Action::release_world_set_block() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_set_block) + if (kind_case() == kWorldSetBlock) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetBlockAction*>(_impl_.kind_.world_set_block_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_set_block_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldSetBlockAction& Action::_internal_world_set_block() const { + return kind_case() == kWorldSetBlock ? static_cast(*reinterpret_cast<::df::plugin::WorldSetBlockAction*>(_impl_.kind_.world_set_block_)) + : reinterpret_cast(::df::plugin::_WorldSetBlockAction_default_instance_); +} +inline const ::df::plugin::WorldSetBlockAction& Action::world_set_block() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_set_block) + return _internal_world_set_block(); +} +inline ::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_set_block() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_set_block) + if (kind_case() == kWorldSetBlock) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldSetBlockAction*>(_impl_.kind_.world_set_block_); + _impl_.kind_.world_set_block_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_set_block( + ::df::plugin::WorldSetBlockAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_set_block(); + _impl_.kind_.world_set_block_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_set_block) +} +inline ::df::plugin::WorldSetBlockAction* PROTOBUF_NONNULL Action::_internal_mutable_world_set_block() { + if (kind_case() != kWorldSetBlock) { + clear_kind(); + set_has_world_set_block(); + _impl_.kind_.world_set_block_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldSetBlockAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldSetBlockAction*>(_impl_.kind_.world_set_block_); +} +inline ::df::plugin::WorldSetBlockAction* PROTOBUF_NONNULL Action::mutable_world_set_block() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldSetBlockAction* _msg = _internal_mutable_world_set_block(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_set_block) + return _msg; +} + +// .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; +inline bool Action::has_world_play_sound() const { + return kind_case() == kWorldPlaySound; +} +inline bool Action::_internal_has_world_play_sound() const { + return kind_case() == kWorldPlaySound; +} +inline void Action::set_has_world_play_sound() { + _impl_._oneof_case_[0] = kWorldPlaySound; +} +inline void Action::clear_world_play_sound() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldPlaySound) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_play_sound_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_play_sound_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE Action::release_world_play_sound() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_play_sound) + if (kind_case() == kWorldPlaySound) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldPlaySoundAction*>(_impl_.kind_.world_play_sound_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_play_sound_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldPlaySoundAction& Action::_internal_world_play_sound() const { + return kind_case() == kWorldPlaySound ? static_cast(*reinterpret_cast<::df::plugin::WorldPlaySoundAction*>(_impl_.kind_.world_play_sound_)) + : reinterpret_cast(::df::plugin::_WorldPlaySoundAction_default_instance_); +} +inline const ::df::plugin::WorldPlaySoundAction& Action::world_play_sound() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_play_sound) + return _internal_world_play_sound(); +} +inline ::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_play_sound() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_play_sound) + if (kind_case() == kWorldPlaySound) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldPlaySoundAction*>(_impl_.kind_.world_play_sound_); + _impl_.kind_.world_play_sound_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_play_sound( + ::df::plugin::WorldPlaySoundAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_play_sound(); + _impl_.kind_.world_play_sound_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_play_sound) +} +inline ::df::plugin::WorldPlaySoundAction* PROTOBUF_NONNULL Action::_internal_mutable_world_play_sound() { + if (kind_case() != kWorldPlaySound) { + clear_kind(); + set_has_world_play_sound(); + _impl_.kind_.world_play_sound_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldPlaySoundAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldPlaySoundAction*>(_impl_.kind_.world_play_sound_); +} +inline ::df::plugin::WorldPlaySoundAction* PROTOBUF_NONNULL Action::mutable_world_play_sound() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldPlaySoundAction* _msg = _internal_mutable_world_play_sound(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_play_sound) + return _msg; +} + +// .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; +inline bool Action::has_world_add_particle() const { + return kind_case() == kWorldAddParticle; +} +inline bool Action::_internal_has_world_add_particle() const { + return kind_case() == kWorldAddParticle; +} +inline void Action::set_has_world_add_particle() { + _impl_._oneof_case_[0] = kWorldAddParticle; +} +inline void Action::clear_world_add_particle() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldAddParticle) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_add_particle_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_add_particle_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE Action::release_world_add_particle() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_add_particle) + if (kind_case() == kWorldAddParticle) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldAddParticleAction*>(_impl_.kind_.world_add_particle_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_add_particle_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldAddParticleAction& Action::_internal_world_add_particle() const { + return kind_case() == kWorldAddParticle ? static_cast(*reinterpret_cast<::df::plugin::WorldAddParticleAction*>(_impl_.kind_.world_add_particle_)) + : reinterpret_cast(::df::plugin::_WorldAddParticleAction_default_instance_); +} +inline const ::df::plugin::WorldAddParticleAction& Action::world_add_particle() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_add_particle) + return _internal_world_add_particle(); +} +inline ::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_add_particle() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_add_particle) + if (kind_case() == kWorldAddParticle) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldAddParticleAction*>(_impl_.kind_.world_add_particle_); + _impl_.kind_.world_add_particle_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_add_particle( + ::df::plugin::WorldAddParticleAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_add_particle(); + _impl_.kind_.world_add_particle_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_add_particle) +} +inline ::df::plugin::WorldAddParticleAction* PROTOBUF_NONNULL Action::_internal_mutable_world_add_particle() { + if (kind_case() != kWorldAddParticle) { + clear_kind(); + set_has_world_add_particle(); + _impl_.kind_.world_add_particle_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldAddParticleAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldAddParticleAction*>(_impl_.kind_.world_add_particle_); +} +inline ::df::plugin::WorldAddParticleAction* PROTOBUF_NONNULL Action::mutable_world_add_particle() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldAddParticleAction* _msg = _internal_mutable_world_add_particle(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_add_particle) + return _msg; +} + +// .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; +inline bool Action::has_world_query_entities() const { + return kind_case() == kWorldQueryEntities; +} +inline bool Action::_internal_has_world_query_entities() const { + return kind_case() == kWorldQueryEntities; +} +inline void Action::set_has_world_query_entities() { + _impl_._oneof_case_[0] = kWorldQueryEntities; +} +inline void Action::clear_world_query_entities() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldQueryEntities) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_entities_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_entities_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE Action::release_world_query_entities() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_query_entities) + if (kind_case() == kWorldQueryEntities) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryEntitiesAction*>(_impl_.kind_.world_query_entities_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_query_entities_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldQueryEntitiesAction& Action::_internal_world_query_entities() const { + return kind_case() == kWorldQueryEntities ? static_cast(*reinterpret_cast<::df::plugin::WorldQueryEntitiesAction*>(_impl_.kind_.world_query_entities_)) + : reinterpret_cast(::df::plugin::_WorldQueryEntitiesAction_default_instance_); +} +inline const ::df::plugin::WorldQueryEntitiesAction& Action::world_query_entities() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_query_entities) + return _internal_world_query_entities(); +} +inline ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_query_entities() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_query_entities) + if (kind_case() == kWorldQueryEntities) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryEntitiesAction*>(_impl_.kind_.world_query_entities_); + _impl_.kind_.world_query_entities_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_query_entities( + ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_query_entities(); + _impl_.kind_.world_query_entities_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_query_entities) +} +inline ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NONNULL Action::_internal_mutable_world_query_entities() { + if (kind_case() != kWorldQueryEntities) { + clear_kind(); + set_has_world_query_entities(); + _impl_.kind_.world_query_entities_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldQueryEntitiesAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldQueryEntitiesAction*>(_impl_.kind_.world_query_entities_); +} +inline ::df::plugin::WorldQueryEntitiesAction* PROTOBUF_NONNULL Action::mutable_world_query_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldQueryEntitiesAction* _msg = _internal_mutable_world_query_entities(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_query_entities) + return _msg; +} + +// .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; +inline bool Action::has_world_query_players() const { + return kind_case() == kWorldQueryPlayers; +} +inline bool Action::_internal_has_world_query_players() const { + return kind_case() == kWorldQueryPlayers; +} +inline void Action::set_has_world_query_players() { + _impl_._oneof_case_[0] = kWorldQueryPlayers; +} +inline void Action::clear_world_query_players() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldQueryPlayers) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_players_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_players_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE Action::release_world_query_players() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_query_players) + if (kind_case() == kWorldQueryPlayers) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryPlayersAction*>(_impl_.kind_.world_query_players_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_query_players_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldQueryPlayersAction& Action::_internal_world_query_players() const { + return kind_case() == kWorldQueryPlayers ? static_cast(*reinterpret_cast<::df::plugin::WorldQueryPlayersAction*>(_impl_.kind_.world_query_players_)) + : reinterpret_cast(::df::plugin::_WorldQueryPlayersAction_default_instance_); +} +inline const ::df::plugin::WorldQueryPlayersAction& Action::world_query_players() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_query_players) + return _internal_world_query_players(); +} +inline ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_query_players() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_query_players) + if (kind_case() == kWorldQueryPlayers) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryPlayersAction*>(_impl_.kind_.world_query_players_); + _impl_.kind_.world_query_players_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_query_players( + ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_query_players(); + _impl_.kind_.world_query_players_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_query_players) +} +inline ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NONNULL Action::_internal_mutable_world_query_players() { + if (kind_case() != kWorldQueryPlayers) { + clear_kind(); + set_has_world_query_players(); + _impl_.kind_.world_query_players_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldQueryPlayersAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldQueryPlayersAction*>(_impl_.kind_.world_query_players_); +} +inline ::df::plugin::WorldQueryPlayersAction* PROTOBUF_NONNULL Action::mutable_world_query_players() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldQueryPlayersAction* _msg = _internal_mutable_world_query_players(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_query_players) + return _msg; +} + +// .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; +inline bool Action::has_world_query_entities_within() const { + return kind_case() == kWorldQueryEntitiesWithin; +} +inline bool Action::_internal_has_world_query_entities_within() const { + return kind_case() == kWorldQueryEntitiesWithin; +} +inline void Action::set_has_world_query_entities_within() { + _impl_._oneof_case_[0] = kWorldQueryEntitiesWithin; +} +inline void Action::clear_world_query_entities_within() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldQueryEntitiesWithin) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_entities_within_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_entities_within_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE Action::release_world_query_entities_within() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_query_entities_within) + if (kind_case() == kWorldQueryEntitiesWithin) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryEntitiesWithinAction*>(_impl_.kind_.world_query_entities_within_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_query_entities_within_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldQueryEntitiesWithinAction& Action::_internal_world_query_entities_within() const { + return kind_case() == kWorldQueryEntitiesWithin ? static_cast(*reinterpret_cast<::df::plugin::WorldQueryEntitiesWithinAction*>(_impl_.kind_.world_query_entities_within_)) + : reinterpret_cast(::df::plugin::_WorldQueryEntitiesWithinAction_default_instance_); +} +inline const ::df::plugin::WorldQueryEntitiesWithinAction& Action::world_query_entities_within() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_query_entities_within) + return _internal_world_query_entities_within(); +} +inline ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_query_entities_within() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_query_entities_within) + if (kind_case() == kWorldQueryEntitiesWithin) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryEntitiesWithinAction*>(_impl_.kind_.world_query_entities_within_); + _impl_.kind_.world_query_entities_within_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_query_entities_within( + ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_query_entities_within(); + _impl_.kind_.world_query_entities_within_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_query_entities_within) +} +inline ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL Action::_internal_mutable_world_query_entities_within() { + if (kind_case() != kWorldQueryEntitiesWithin) { + clear_kind(); + set_has_world_query_entities_within(); + _impl_.kind_.world_query_entities_within_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldQueryEntitiesWithinAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldQueryEntitiesWithinAction*>(_impl_.kind_.world_query_entities_within_); +} +inline ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL Action::mutable_world_query_entities_within() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldQueryEntitiesWithinAction* _msg = _internal_mutable_world_query_entities_within(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_query_entities_within) + return _msg; +} + +// .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; +inline bool Action::has_world_query_viewers() const { + return kind_case() == kWorldQueryViewers; +} +inline bool Action::_internal_has_world_query_viewers() const { + return kind_case() == kWorldQueryViewers; +} +inline void Action::set_has_world_query_viewers() { + _impl_._oneof_case_[0] = kWorldQueryViewers; +} +inline void Action::clear_world_query_viewers() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (kind_case() == kWorldQueryViewers) { + if (GetArena() == nullptr) { + delete _impl_.kind_.world_query_viewers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_viewers_); + } + clear_has_kind(); + } +} +inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE Action::release_world_query_viewers() { + // @@protoc_insertion_point(field_release:df.plugin.Action.world_query_viewers) + if (kind_case() == kWorldQueryViewers) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.kind_.world_query_viewers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldQueryViewersAction& Action::_internal_world_query_viewers() const { + return kind_case() == kWorldQueryViewers ? static_cast(*reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_)) + : reinterpret_cast(::df::plugin::_WorldQueryViewersAction_default_instance_); +} +inline const ::df::plugin::WorldQueryViewersAction& Action::world_query_viewers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.Action.world_query_viewers) + return _internal_world_query_viewers(); +} +inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_query_viewers() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_query_viewers) + if (kind_case() == kWorldQueryViewers) { + clear_has_kind(); + auto* temp = reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); + _impl_.kind_.world_query_viewers_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Action::unsafe_arena_set_allocated_world_query_viewers( + ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_kind(); + if (value) { + set_has_world_query_viewers(); + _impl_.kind_.world_query_viewers_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_query_viewers) +} +inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL Action::_internal_mutable_world_query_viewers() { + if (kind_case() != kWorldQueryViewers) { + clear_kind(); + set_has_world_query_viewers(); + _impl_.kind_.world_query_viewers_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldQueryViewersAction>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); +} +inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL Action::mutable_world_query_viewers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldQueryViewersAction* _msg = _internal_mutable_world_query_viewers(); + // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_query_viewers) + return _msg; +} + +inline bool Action::has_kind() const { + return kind_case() != KIND_NOT_SET; +} +inline void Action::clear_has_kind() { + _impl_._oneof_case_[0] = KIND_NOT_SET; +} +inline Action::KindCase Action::kind_case() const { + return Action::KindCase(_impl_._oneof_case_[0]); +} +// ------------------------------------------------------------------- + +// SendChatAction + +// string target_uuid = 1 [json_name = "targetUuid"]; +inline void SendChatAction::clear_target_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.target_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& SendChatAction::target_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SendChatAction.target_uuid) + return _internal_target_uuid(); +} +template +PROTOBUF_ALWAYS_INLINE void SendChatAction::set_target_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.target_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendChatAction.target_uuid) +} +inline ::std::string* PROTOBUF_NONNULL SendChatAction::mutable_target_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_target_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendChatAction.target_uuid) + return _s; +} +inline const ::std::string& SendChatAction::_internal_target_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.target_uuid_.Get(); +} +inline void SendChatAction::_internal_set_target_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.target_uuid_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL SendChatAction::_internal_mutable_target_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.target_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE SendChatAction::release_target_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SendChatAction.target_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.target_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.target_uuid_.Set("", GetArena()); + } + return released; +} +inline void SendChatAction::set_allocated_target_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.target_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.target_uuid_.IsDefault()) { + _impl_.target_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendChatAction.target_uuid) +} + +// string message = 2 [json_name = "message"]; +inline void SendChatAction::clear_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.message_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +inline const ::std::string& SendChatAction::message() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SendChatAction.message) + return _internal_message(); +} +template +PROTOBUF_ALWAYS_INLINE void SendChatAction::set_message(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + _impl_.message_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendChatAction.message) +} +inline ::std::string* PROTOBUF_NONNULL SendChatAction::mutable_message() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendChatAction.message) + return _s; +} +inline const ::std::string& SendChatAction::_internal_message() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.message_.Get(); +} +inline void SendChatAction::_internal_set_message(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.message_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL SendChatAction::_internal_mutable_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.message_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE SendChatAction::release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SendChatAction.message) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.message_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.message_.Set("", GetArena()); + } + return released; +} +inline void SendChatAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + _impl_.message_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendChatAction.message) +} + +// ------------------------------------------------------------------- + +// TeleportAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void TeleportAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& TeleportAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.player_uuid) + return _internal_player_uuid(); +} +template +PROTOBUF_ALWAYS_INLINE void TeleportAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.TeleportAction.player_uuid) +} +inline ::std::string* PROTOBUF_NONNULL TeleportAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.player_uuid) + return _s; +} +inline const ::std::string& TeleportAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); +} +inline void TeleportAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL TeleportAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE TeleportAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); + } + return released; +} +inline void TeleportAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.player_uuid) +} + +// .df.plugin.Vec3 position = 2 [json_name = "position"]; +inline bool TeleportAction::has_position() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); + return value; +} +inline const ::df::plugin::Vec3& TeleportAction::_internal_position() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.position_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +} +inline const ::df::plugin::Vec3& TeleportAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.position) + return _internal_position(); +} +inline void TeleportAction::unsafe_arena_set_allocated_position( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.TeleportAction.position) +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::release_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* released = _impl_.position_; + _impl_.position_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::unsafe_arena_release_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.position) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* temp = _impl_.position_; + _impl_.position_ = nullptr; + return temp; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::_internal_mutable_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.position_; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::mutable_position() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.position) + return _msg; +} +inline void TeleportAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.position) +} + +// .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; +inline bool TeleportAction::has_rotation() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + PROTOBUF_ASSUME(!value || _impl_.rotation_ != nullptr); + return value; +} +inline const ::df::plugin::Vec3& TeleportAction::_internal_rotation() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.rotation_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +} +inline const ::df::plugin::Vec3& TeleportAction::rotation() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.rotation) + return _internal_rotation(); +} +inline void TeleportAction::unsafe_arena_set_allocated_rotation( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rotation_); } - return reinterpret_cast<::df::plugin::SendChatAction*>(_impl_.kind_.send_chat_); + _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.TeleportAction.rotation) } -inline ::df::plugin::SendChatAction* PROTOBUF_NONNULL Action::mutable_send_chat() +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::release_rotation() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::Vec3* released = _impl_.rotation_; + _impl_.rotation_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::unsafe_arena_release_rotation() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.rotation) + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::Vec3* temp = _impl_.rotation_; + _impl_.rotation_ = nullptr; + return temp; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::_internal_mutable_rotation() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.rotation_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.rotation_; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::mutable_rotation() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SendChatAction* _msg = _internal_mutable_send_chat(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_chat) + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::Vec3* _msg = _internal_mutable_rotation(); + // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.rotation) return _msg; } - -// .df.plugin.TeleportAction teleport = 11 [json_name = "teleport"]; -inline bool Action::has_teleport() const { - return kind_case() == kTeleport; +inline void TeleportAction::set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rotation_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + + _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.rotation) +} + +// ------------------------------------------------------------------- + +// KickAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void KickAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& KickAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.KickAction.player_uuid) + return _internal_player_uuid(); +} +template +PROTOBUF_ALWAYS_INLINE void KickAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.KickAction.player_uuid) +} +inline ::std::string* PROTOBUF_NONNULL KickAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.KickAction.player_uuid) + return _s; +} +inline const ::std::string& KickAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); +} +inline void KickAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL KickAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE KickAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.KickAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); + } + return released; +} +inline void KickAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.KickAction.player_uuid) +} + +// string reason = 2 [json_name = "reason"]; +inline void KickAction::clear_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +inline const ::std::string& KickAction::reason() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.KickAction.reason) + return _internal_reason(); +} +template +PROTOBUF_ALWAYS_INLINE void KickAction::set_reason(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + _impl_.reason_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.KickAction.reason) +} +inline ::std::string* PROTOBUF_NONNULL KickAction::mutable_reason() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_reason(); + // @@protoc_insertion_point(field_mutable:df.plugin.KickAction.reason) + return _s; +} +inline const ::std::string& KickAction::_internal_reason() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.reason_.Get(); +} +inline void KickAction::_internal_set_reason(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.reason_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL KickAction::_internal_mutable_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.reason_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE KickAction::release_reason() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.KickAction.reason) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.reason_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.reason_.Set("", GetArena()); + } + return released; +} +inline void KickAction::set_allocated_reason(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + _impl_.reason_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.reason_.IsDefault()) { + _impl_.reason_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.KickAction.reason) +} + +// ------------------------------------------------------------------- + +// SetGameModeAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetGameModeAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& SetGameModeAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetGameModeAction.player_uuid) + return _internal_player_uuid(); +} +template +PROTOBUF_ALWAYS_INLINE void SetGameModeAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetGameModeAction.player_uuid) +} +inline ::std::string* PROTOBUF_NONNULL SetGameModeAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetGameModeAction.player_uuid) + return _s; +} +inline const ::std::string& SetGameModeAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline bool Action::_internal_has_teleport() const { - return kind_case() == kTeleport; +inline void SetGameModeAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline void Action::set_has_teleport() { - _impl_._oneof_case_[0] = kTeleport; +inline ::std::string* PROTOBUF_NONNULL SetGameModeAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline void Action::clear_teleport() { +inline ::std::string* PROTOBUF_NULLABLE SetGameModeAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kTeleport) { - if (GetArena() == nullptr) { - delete _impl_.kind_.teleport_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.teleport_); - } - clear_has_kind(); + // @@protoc_insertion_point(field_release:df.plugin.SetGameModeAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } + return released; } -inline ::df::plugin::TeleportAction* PROTOBUF_NULLABLE Action::release_teleport() { - // @@protoc_insertion_point(field_release:df.plugin.Action.teleport) - if (kind_case() == kTeleport) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.teleport_ = nullptr; - return temp; +inline void SetGameModeAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetGameModeAction.player_uuid) } -inline const ::df::plugin::TeleportAction& Action::_internal_teleport() const { - return kind_case() == kTeleport ? static_cast(*reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_)) - : reinterpret_cast(::df::plugin::_TeleportAction_default_instance_); -} -inline const ::df::plugin::TeleportAction& Action::teleport() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.teleport) - return _internal_teleport(); + +// .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; +inline void SetGameModeAction::clear_game_mode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.game_mode_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline ::df::plugin::TeleportAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_teleport() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.teleport) - if (kind_case() == kTeleport) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); - _impl_.kind_.teleport_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::df::plugin::GameMode SetGameModeAction::game_mode() const { + // @@protoc_insertion_point(field_get:df.plugin.SetGameModeAction.game_mode) + return _internal_game_mode(); } -inline void Action::unsafe_arena_set_allocated_teleport( - ::df::plugin::TeleportAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_teleport(); - _impl_.kind_.teleport_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.teleport) +inline void SetGameModeAction::set_game_mode(::df::plugin::GameMode value) { + _internal_set_game_mode(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.SetGameModeAction.game_mode) } -inline ::df::plugin::TeleportAction* PROTOBUF_NONNULL Action::_internal_mutable_teleport() { - if (kind_case() != kTeleport) { - clear_kind(); - set_has_teleport(); - _impl_.kind_.teleport_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::TeleportAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::TeleportAction*>(_impl_.kind_.teleport_); +inline ::df::plugin::GameMode SetGameModeAction::_internal_game_mode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::GameMode>(_impl_.game_mode_); } -inline ::df::plugin::TeleportAction* PROTOBUF_NONNULL Action::mutable_teleport() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::TeleportAction* _msg = _internal_mutable_teleport(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.teleport) - return _msg; +inline void SetGameModeAction::_internal_set_game_mode(::df::plugin::GameMode value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.game_mode_ = value; } -// .df.plugin.KickAction kick = 12 [json_name = "kick"]; -inline bool Action::has_kick() const { - return kind_case() == kKick; -} -inline bool Action::_internal_has_kick() const { - return kind_case() == kKick; +// ------------------------------------------------------------------- + +// GiveItemAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void GiveItemAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline void Action::set_has_kick() { - _impl_._oneof_case_[0] = kKick; +inline const ::std::string& GiveItemAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.GiveItemAction.player_uuid) + return _internal_player_uuid(); } -inline void Action::clear_kick() { +template +PROTOBUF_ALWAYS_INLINE void GiveItemAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kKick) { - if (GetArena() == nullptr) { - delete _impl_.kind_.kick_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.kick_); - } - clear_has_kind(); - } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.GiveItemAction.player_uuid) } -inline ::df::plugin::KickAction* PROTOBUF_NULLABLE Action::release_kick() { - // @@protoc_insertion_point(field_release:df.plugin.Action.kick) - if (kind_case() == kKick) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.kick_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::std::string* PROTOBUF_NONNULL GiveItemAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.GiveItemAction.player_uuid) + return _s; } -inline const ::df::plugin::KickAction& Action::_internal_kick() const { - return kind_case() == kKick ? static_cast(*reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_)) - : reinterpret_cast(::df::plugin::_KickAction_default_instance_); +inline const ::std::string& GiveItemAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline const ::df::plugin::KickAction& Action::kick() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.kick) - return _internal_kick(); +inline void GiveItemAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline ::df::plugin::KickAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_kick() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.kick) - if (kind_case() == kKick) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); - _impl_.kind_.kick_ = nullptr; - return temp; - } else { +inline ::std::string* PROTOBUF_NONNULL GiveItemAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE GiveItemAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.GiveItemAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } -} -inline void Action::unsafe_arena_set_allocated_kick( - ::df::plugin::KickAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_kick(); - _impl_.kind_.kick_ = reinterpret_cast<::google::protobuf::Message*>(value); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.kick) + return released; } -inline ::df::plugin::KickAction* PROTOBUF_NONNULL Action::_internal_mutable_kick() { - if (kind_case() != kKick) { - clear_kind(); - set_has_kick(); - _impl_.kind_.kick_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::KickAction>(GetArena())); +inline void GiveItemAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - return reinterpret_cast<::df::plugin::KickAction*>(_impl_.kind_.kick_); -} -inline ::df::plugin::KickAction* PROTOBUF_NONNULL Action::mutable_kick() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::KickAction* _msg = _internal_mutable_kick(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.kick) - return _msg; + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.GiveItemAction.player_uuid) } -// .df.plugin.SetGameModeAction set_game_mode = 13 [json_name = "setGameMode"]; -inline bool Action::has_set_game_mode() const { - return kind_case() == kSetGameMode; +// .df.plugin.ItemStack item = 2 [json_name = "item"]; +inline bool GiveItemAction::has_item() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.item_ != nullptr); + return value; } -inline bool Action::_internal_has_set_game_mode() const { - return kind_case() == kSetGameMode; +inline const ::df::plugin::ItemStack& GiveItemAction::_internal_item() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::ItemStack* p = _impl_.item_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); } -inline void Action::set_has_set_game_mode() { - _impl_._oneof_case_[0] = kSetGameMode; +inline const ::df::plugin::ItemStack& GiveItemAction::item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.GiveItemAction.item) + return _internal_item(); } -inline void Action::clear_set_game_mode() { +inline void GiveItemAction::unsafe_arena_set_allocated_item( + ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetGameMode) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_game_mode_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_game_mode_); - } - clear_has_kind(); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.item_); } -} -inline ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE Action::release_set_game_mode() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_game_mode) - if (kind_case() == kSetGameMode) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_game_mode_ = nullptr; - return temp; + _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.GiveItemAction.item) } -inline const ::df::plugin::SetGameModeAction& Action::_internal_set_game_mode() const { - return kind_case() == kSetGameMode ? static_cast(*reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_)) - : reinterpret_cast(::df::plugin::_SetGameModeAction_default_instance_); -} -inline const ::df::plugin::SetGameModeAction& Action::set_game_mode() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_game_mode) - return _internal_set_game_mode(); -} -inline ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_game_mode() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_game_mode) - if (kind_case() == kSetGameMode) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); - _impl_.kind_.set_game_mode_ = nullptr; - return temp; +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE GiveItemAction::release_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* released = _impl_.item_; + _impl_.item_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } } else { - return nullptr; + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } + return released; } -inline void Action::unsafe_arena_set_allocated_set_game_mode( - ::df::plugin::SetGameModeAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_game_mode(); - _impl_.kind_.set_game_mode_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_game_mode) +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE GiveItemAction::unsafe_arena_release_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.GiveItemAction.item) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* temp = _impl_.item_; + _impl_.item_ = nullptr; + return temp; } -inline ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL Action::_internal_mutable_set_game_mode() { - if (kind_case() != kSetGameMode) { - clear_kind(); - set_has_set_game_mode(); - _impl_.kind_.set_game_mode_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetGameModeAction>(GetArena())); +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL GiveItemAction::_internal_mutable_item() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.item_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); + _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(p); } - return reinterpret_cast<::df::plugin::SetGameModeAction*>(_impl_.kind_.set_game_mode_); + return _impl_.item_; } -inline ::df::plugin::SetGameModeAction* PROTOBUF_NONNULL Action::mutable_set_game_mode() +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL GiveItemAction::mutable_item() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetGameModeAction* _msg = _internal_mutable_set_game_mode(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_game_mode) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* _msg = _internal_mutable_item(); + // @@protoc_insertion_point(field_mutable:df.plugin.GiveItemAction.item) return _msg; } +inline void GiveItemAction::set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.item_); + } -// .df.plugin.GiveItemAction give_item = 14 [json_name = "giveItem"]; -inline bool Action::has_give_item() const { - return kind_case() == kGiveItem; + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.GiveItemAction.item) } -inline bool Action::_internal_has_give_item() const { - return kind_case() == kGiveItem; + +// ------------------------------------------------------------------- + +// ClearInventoryAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void ClearInventoryAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline void Action::set_has_give_item() { - _impl_._oneof_case_[0] = kGiveItem; +inline const ::std::string& ClearInventoryAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ClearInventoryAction.player_uuid) + return _internal_player_uuid(); } -inline void Action::clear_give_item() { +template +PROTOBUF_ALWAYS_INLINE void ClearInventoryAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kGiveItem) { - if (GetArena() == nullptr) { - delete _impl_.kind_.give_item_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.give_item_); - } - clear_has_kind(); - } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.ClearInventoryAction.player_uuid) } -inline ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE Action::release_give_item() { - // @@protoc_insertion_point(field_release:df.plugin.Action.give_item) - if (kind_case() == kGiveItem) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.give_item_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::std::string* PROTOBUF_NONNULL ClearInventoryAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.ClearInventoryAction.player_uuid) + return _s; } -inline const ::df::plugin::GiveItemAction& Action::_internal_give_item() const { - return kind_case() == kGiveItem ? static_cast(*reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_)) - : reinterpret_cast(::df::plugin::_GiveItemAction_default_instance_); +inline const ::std::string& ClearInventoryAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline const ::df::plugin::GiveItemAction& Action::give_item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.give_item) - return _internal_give_item(); +inline void ClearInventoryAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_give_item() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.give_item) - if (kind_case() == kGiveItem) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); - _impl_.kind_.give_item_ = nullptr; - return temp; - } else { +inline ::std::string* PROTOBUF_NONNULL ClearInventoryAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE ClearInventoryAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.ClearInventoryAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } -} -inline void Action::unsafe_arena_set_allocated_give_item( - ::df::plugin::GiveItemAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_give_item(); - _impl_.kind_.give_item_ = reinterpret_cast<::google::protobuf::Message*>(value); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.give_item) + return released; } -inline ::df::plugin::GiveItemAction* PROTOBUF_NONNULL Action::_internal_mutable_give_item() { - if (kind_case() != kGiveItem) { - clear_kind(); - set_has_give_item(); - _impl_.kind_.give_item_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::GiveItemAction>(GetArena())); +inline void ClearInventoryAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - return reinterpret_cast<::df::plugin::GiveItemAction*>(_impl_.kind_.give_item_); + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ClearInventoryAction.player_uuid) +} + +// ------------------------------------------------------------------- + +// SetHeldItemAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetHeldItemAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& SetHeldItemAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.player_uuid) + return _internal_player_uuid(); } -inline ::df::plugin::GiveItemAction* PROTOBUF_NONNULL Action::mutable_give_item() +template +PROTOBUF_ALWAYS_INLINE void SetHeldItemAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetHeldItemAction.player_uuid) +} +inline ::std::string* PROTOBUF_NONNULL SetHeldItemAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::GiveItemAction* _msg = _internal_mutable_give_item(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.give_item) - return _msg; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.player_uuid) + return _s; } - -// .df.plugin.ClearInventoryAction clear_inventory = 15 [json_name = "clearInventory"]; -inline bool Action::has_clear_inventory() const { - return kind_case() == kClearInventory; +inline const ::std::string& SetHeldItemAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline bool Action::_internal_has_clear_inventory() const { - return kind_case() == kClearInventory; +inline void SetHeldItemAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline void Action::set_has_clear_inventory() { - _impl_._oneof_case_[0] = kClearInventory; +inline ::std::string* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline void Action::clear_clear_inventory() { +inline ::std::string* PROTOBUF_NULLABLE SetHeldItemAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kClearInventory) { - if (GetArena() == nullptr) { - delete _impl_.kind_.clear_inventory_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.clear_inventory_); - } - clear_has_kind(); + // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); + } + return released; } -inline ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE Action::release_clear_inventory() { - // @@protoc_insertion_point(field_release:df.plugin.Action.clear_inventory) - if (kind_case() == kClearInventory) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.clear_inventory_ = nullptr; - return temp; +inline void SetHeldItemAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.player_uuid) } -inline const ::df::plugin::ClearInventoryAction& Action::_internal_clear_inventory() const { - return kind_case() == kClearInventory ? static_cast(*reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_)) - : reinterpret_cast(::df::plugin::_ClearInventoryAction_default_instance_); + +// optional .df.plugin.ItemStack main = 2 [json_name = "main"]; +inline bool SetHeldItemAction::has_main() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.main_ != nullptr); + return value; } -inline const ::df::plugin::ClearInventoryAction& Action::clear_inventory() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.clear_inventory) - return _internal_clear_inventory(); +inline const ::df::plugin::ItemStack& SetHeldItemAction::_internal_main() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::ItemStack* p = _impl_.main_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); } -inline ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_clear_inventory() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.clear_inventory) - if (kind_case() == kClearInventory) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); - _impl_.kind_.clear_inventory_ = nullptr; - return temp; +inline const ::df::plugin::ItemStack& SetHeldItemAction::main() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.main) + return _internal_main(); +} +inline void SetHeldItemAction::unsafe_arena_set_allocated_main( + ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.main_); + } + _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetHeldItemAction.main) } -inline void Action::unsafe_arena_set_allocated_clear_inventory( - ::df::plugin::ClearInventoryAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_clear_inventory(); - _impl_.kind_.clear_inventory_ = reinterpret_cast<::google::protobuf::Message*>(value); +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::release_main() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* released = _impl_.main_; + _impl_.main_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.clear_inventory) + return released; } -inline ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL Action::_internal_mutable_clear_inventory() { - if (kind_case() != kClearInventory) { - clear_kind(); - set_has_clear_inventory(); - _impl_.kind_.clear_inventory_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::ClearInventoryAction>(GetArena())); +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::unsafe_arena_release_main() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.main) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* temp = _impl_.main_; + _impl_.main_ = nullptr; + return temp; +} +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_main() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.main_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); + _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(p); } - return reinterpret_cast<::df::plugin::ClearInventoryAction*>(_impl_.kind_.clear_inventory_); + return _impl_.main_; } -inline ::df::plugin::ClearInventoryAction* PROTOBUF_NONNULL Action::mutable_clear_inventory() +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::mutable_main() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::ClearInventoryAction* _msg = _internal_mutable_clear_inventory(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.clear_inventory) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ItemStack* _msg = _internal_mutable_main(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.main) return _msg; } +inline void SetHeldItemAction::set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.main_); + } -// .df.plugin.SetHeldItemAction set_held_item = 16 [json_name = "setHeldItem"]; -inline bool Action::has_set_held_item() const { - return kind_case() == kSetHeldItem; + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.main) } -inline bool Action::_internal_has_set_held_item() const { - return kind_case() == kSetHeldItem; + +// optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; +inline bool SetHeldItemAction::has_offhand() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + PROTOBUF_ASSUME(!value || _impl_.offhand_ != nullptr); + return value; } -inline void Action::set_has_set_held_item() { - _impl_._oneof_case_[0] = kSetHeldItem; +inline const ::df::plugin::ItemStack& SetHeldItemAction::_internal_offhand() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::ItemStack* p = _impl_.offhand_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); } -inline void Action::clear_set_held_item() { +inline const ::df::plugin::ItemStack& SetHeldItemAction::offhand() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.offhand) + return _internal_offhand(); +} +inline void SetHeldItemAction::unsafe_arena_set_allocated_offhand( + ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetHeldItem) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_held_item_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_held_item_); - } - clear_has_kind(); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.offhand_); } -} -inline ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE Action::release_set_held_item() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_held_item) - if (kind_case() == kSetHeldItem) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_held_item_ = nullptr; - return temp; + _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetHeldItemAction.offhand) } -inline const ::df::plugin::SetHeldItemAction& Action::_internal_set_held_item() const { - return kind_case() == kSetHeldItem ? static_cast(*reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_)) - : reinterpret_cast(::df::plugin::_SetHeldItemAction_default_instance_); -} -inline const ::df::plugin::SetHeldItemAction& Action::set_held_item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_held_item) - return _internal_set_held_item(); -} -inline ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_held_item() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_held_item) - if (kind_case() == kSetHeldItem) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); - _impl_.kind_.set_held_item_ = nullptr; - return temp; +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::release_offhand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::ItemStack* released = _impl_.offhand_; + _impl_.offhand_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } } else { - return nullptr; + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } + return released; } -inline void Action::unsafe_arena_set_allocated_set_held_item( - ::df::plugin::SetHeldItemAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_held_item(); - _impl_.kind_.set_held_item_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_held_item) +inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::unsafe_arena_release_offhand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.offhand) + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::ItemStack* temp = _impl_.offhand_; + _impl_.offhand_ = nullptr; + return temp; } -inline ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL Action::_internal_mutable_set_held_item() { - if (kind_case() != kSetHeldItem) { - clear_kind(); - set_has_set_held_item(); - _impl_.kind_.set_held_item_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetHeldItemAction>(GetArena())); +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_offhand() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.offhand_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); + _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(p); } - return reinterpret_cast<::df::plugin::SetHeldItemAction*>(_impl_.kind_.set_held_item_); + return _impl_.offhand_; } -inline ::df::plugin::SetHeldItemAction* PROTOBUF_NONNULL Action::mutable_set_held_item() +inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::mutable_offhand() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetHeldItemAction* _msg = _internal_mutable_set_held_item(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_held_item) + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::ItemStack* _msg = _internal_mutable_offhand(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.offhand) return _msg; } +inline void SetHeldItemAction::set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.offhand_); + } -// .df.plugin.SetHealthAction set_health = 20 [json_name = "setHealth"]; -inline bool Action::has_set_health() const { - return kind_case() == kSetHealth; + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + + _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.offhand) } -inline bool Action::_internal_has_set_health() const { - return kind_case() == kSetHealth; + +// ------------------------------------------------------------------- + +// SetHealthAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetHealthAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline void Action::set_has_set_health() { - _impl_._oneof_case_[0] = kSetHealth; +inline const ::std::string& SetHealthAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.player_uuid) + return _internal_player_uuid(); } -inline void Action::clear_set_health() { +template +PROTOBUF_ALWAYS_INLINE void SetHealthAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetHealth) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_health_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_health_); - } - clear_has_kind(); - } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.player_uuid) } -inline ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE Action::release_set_health() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_health) - if (kind_case() == kSetHealth) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_health_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::std::string* PROTOBUF_NONNULL SetHealthAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetHealthAction.player_uuid) + return _s; } -inline const ::df::plugin::SetHealthAction& Action::_internal_set_health() const { - return kind_case() == kSetHealth ? static_cast(*reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_)) - : reinterpret_cast(::df::plugin::_SetHealthAction_default_instance_); +inline const ::std::string& SetHealthAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline const ::df::plugin::SetHealthAction& Action::set_health() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_health) - return _internal_set_health(); +inline void SetHealthAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_health() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_health) - if (kind_case() == kSetHealth) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); - _impl_.kind_.set_health_ = nullptr; - return temp; - } else { +inline ::std::string* PROTOBUF_NONNULL SetHealthAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE SetHealthAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetHealthAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } -} -inline void Action::unsafe_arena_set_allocated_set_health( - ::df::plugin::SetHealthAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_health(); - _impl_.kind_.set_health_ = reinterpret_cast<::google::protobuf::Message*>(value); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_health) + return released; } -inline ::df::plugin::SetHealthAction* PROTOBUF_NONNULL Action::_internal_mutable_set_health() { - if (kind_case() != kSetHealth) { - clear_kind(); - set_has_set_health(); - _impl_.kind_.set_health_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetHealthAction>(GetArena())); +inline void SetHealthAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - return reinterpret_cast<::df::plugin::SetHealthAction*>(_impl_.kind_.set_health_); -} -inline ::df::plugin::SetHealthAction* PROTOBUF_NONNULL Action::mutable_set_health() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetHealthAction* _msg = _internal_mutable_set_health(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_health) - return _msg; + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHealthAction.player_uuid) } -// .df.plugin.SetFoodAction set_food = 21 [json_name = "setFood"]; -inline bool Action::has_set_food() const { - return kind_case() == kSetFood; +// double health = 2 [json_name = "health"]; +inline void SetHealthAction::clear_health() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.health_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline bool Action::_internal_has_set_food() const { - return kind_case() == kSetFood; +inline double SetHealthAction::health() const { + // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.health) + return _internal_health(); } -inline void Action::set_has_set_food() { - _impl_._oneof_case_[0] = kSetFood; +inline void SetHealthAction::set_health(double value) { + _internal_set_health(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.health) } -inline void Action::clear_set_food() { +inline double SetHealthAction::_internal_health() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.health_; +} +inline void SetHealthAction::_internal_set_health(double value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetFood) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_food_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_food_); - } - clear_has_kind(); - } + _impl_.health_ = value; } -inline ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE Action::release_set_food() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_food) - if (kind_case() == kSetFood) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_food_ = nullptr; - return temp; - } else { - return nullptr; - } + +// optional double max_health = 3 [json_name = "maxHealth"]; +inline bool SetHealthAction::has_max_health() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + return value; +} +inline void SetHealthAction::clear_max_health() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_health_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +inline double SetHealthAction::max_health() const { + // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.max_health) + return _internal_max_health(); } -inline const ::df::plugin::SetFoodAction& Action::_internal_set_food() const { - return kind_case() == kSetFood ? static_cast(*reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_)) - : reinterpret_cast(::df::plugin::_SetFoodAction_default_instance_); +inline void SetHealthAction::set_max_health(double value) { + _internal_set_max_health(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.max_health) } -inline const ::df::plugin::SetFoodAction& Action::set_food() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_food) - return _internal_set_food(); +inline double SetHealthAction::_internal_max_health() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.max_health_; } -inline ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_food() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_food) - if (kind_case() == kSetFood) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); - _impl_.kind_.set_food_ = nullptr; - return temp; - } else { - return nullptr; - } +inline void SetHealthAction::_internal_set_max_health(double value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.max_health_ = value; } -inline void Action::unsafe_arena_set_allocated_set_food( - ::df::plugin::SetFoodAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_food(); - _impl_.kind_.set_food_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_food) + +// ------------------------------------------------------------------- + +// SetFoodAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetFoodAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline ::df::plugin::SetFoodAction* PROTOBUF_NONNULL Action::_internal_mutable_set_food() { - if (kind_case() != kSetFood) { - clear_kind(); - set_has_set_food(); - _impl_.kind_.set_food_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetFoodAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::SetFoodAction*>(_impl_.kind_.set_food_); +inline const ::std::string& SetFoodAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetFoodAction.player_uuid) + return _internal_player_uuid(); } -inline ::df::plugin::SetFoodAction* PROTOBUF_NONNULL Action::mutable_set_food() +template +PROTOBUF_ALWAYS_INLINE void SetFoodAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetFoodAction.player_uuid) +} +inline ::std::string* PROTOBUF_NONNULL SetFoodAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetFoodAction* _msg = _internal_mutable_set_food(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_food) - return _msg; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetFoodAction.player_uuid) + return _s; } - -// .df.plugin.SetExperienceAction set_experience = 22 [json_name = "setExperience"]; -inline bool Action::has_set_experience() const { - return kind_case() == kSetExperience; +inline const ::std::string& SetFoodAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline bool Action::_internal_has_set_experience() const { - return kind_case() == kSetExperience; +inline void SetFoodAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline void Action::set_has_set_experience() { - _impl_._oneof_case_[0] = kSetExperience; +inline ::std::string* PROTOBUF_NONNULL SetFoodAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline void Action::clear_set_experience() { +inline ::std::string* PROTOBUF_NULLABLE SetFoodAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetExperience) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_experience_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_experience_); - } - clear_has_kind(); + // @@protoc_insertion_point(field_release:df.plugin.SetFoodAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } + return released; } -inline ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE Action::release_set_experience() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_experience) - if (kind_case() == kSetExperience) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_experience_ = nullptr; - return temp; +inline void SetFoodAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetFoodAction.player_uuid) } -inline const ::df::plugin::SetExperienceAction& Action::_internal_set_experience() const { - return kind_case() == kSetExperience ? static_cast(*reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_)) - : reinterpret_cast(::df::plugin::_SetExperienceAction_default_instance_); + +// int32 food = 2 [json_name = "food"]; +inline void SetFoodAction::clear_food() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.food_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const ::df::plugin::SetExperienceAction& Action::set_experience() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_experience) - return _internal_set_experience(); +inline ::int32_t SetFoodAction::food() const { + // @@protoc_insertion_point(field_get:df.plugin.SetFoodAction.food) + return _internal_food(); } -inline ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_experience() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_experience) - if (kind_case() == kSetExperience) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); - _impl_.kind_.set_experience_ = nullptr; - return temp; - } else { - return nullptr; - } +inline void SetFoodAction::set_food(::int32_t value) { + _internal_set_food(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.SetFoodAction.food) } -inline void Action::unsafe_arena_set_allocated_set_experience( - ::df::plugin::SetExperienceAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_experience(); - _impl_.kind_.set_experience_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_experience) +inline ::int32_t SetFoodAction::_internal_food() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.food_; } -inline ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL Action::_internal_mutable_set_experience() { - if (kind_case() != kSetExperience) { - clear_kind(); - set_has_set_experience(); - _impl_.kind_.set_experience_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetExperienceAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::SetExperienceAction*>(_impl_.kind_.set_experience_); +inline void SetFoodAction::_internal_set_food(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.food_ = value; } -inline ::df::plugin::SetExperienceAction* PROTOBUF_NONNULL Action::mutable_set_experience() + +// ------------------------------------------------------------------- + +// SetExperienceAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetExperienceAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& SetExperienceAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetExperienceAction* _msg = _internal_mutable_set_experience(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_experience) - return _msg; + // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.player_uuid) + return _internal_player_uuid(); } - -// .df.plugin.SetVelocityAction set_velocity = 23 [json_name = "setVelocity"]; -inline bool Action::has_set_velocity() const { - return kind_case() == kSetVelocity; +template +PROTOBUF_ALWAYS_INLINE void SetExperienceAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.player_uuid) } -inline bool Action::_internal_has_set_velocity() const { - return kind_case() == kSetVelocity; +inline ::std::string* PROTOBUF_NONNULL SetExperienceAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetExperienceAction.player_uuid) + return _s; } -inline void Action::set_has_set_velocity() { - _impl_._oneof_case_[0] = kSetVelocity; +inline const ::std::string& SetExperienceAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline void Action::clear_set_velocity() { +inline void SetExperienceAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSetVelocity) { - if (GetArena() == nullptr) { - delete _impl_.kind_.set_velocity_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.set_velocity_); - } - clear_has_kind(); + _impl_.player_uuid_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL SetExperienceAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE SetExperienceAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetExperienceAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } + return released; } -inline ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE Action::release_set_velocity() { - // @@protoc_insertion_point(field_release:df.plugin.Action.set_velocity) - if (kind_case() == kSetVelocity) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.set_velocity_ = nullptr; - return temp; +inline void SetExperienceAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetExperienceAction.player_uuid) } -inline const ::df::plugin::SetVelocityAction& Action::_internal_set_velocity() const { - return kind_case() == kSetVelocity ? static_cast(*reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_)) - : reinterpret_cast(::df::plugin::_SetVelocityAction_default_instance_); + +// optional int32 level = 2 [json_name = "level"]; +inline bool SetExperienceAction::has_level() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + return value; } -inline const ::df::plugin::SetVelocityAction& Action::set_velocity() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.set_velocity) - return _internal_set_velocity(); +inline void SetExperienceAction::clear_level() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.level_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_set_velocity() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.set_velocity) - if (kind_case() == kSetVelocity) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); - _impl_.kind_.set_velocity_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::int32_t SetExperienceAction::level() const { + // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.level) + return _internal_level(); } -inline void Action::unsafe_arena_set_allocated_set_velocity( - ::df::plugin::SetVelocityAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_set_velocity(); - _impl_.kind_.set_velocity_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.set_velocity) +inline void SetExperienceAction::set_level(::int32_t value) { + _internal_set_level(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.level) } -inline ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL Action::_internal_mutable_set_velocity() { - if (kind_case() != kSetVelocity) { - clear_kind(); - set_has_set_velocity(); - _impl_.kind_.set_velocity_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SetVelocityAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::SetVelocityAction*>(_impl_.kind_.set_velocity_); +inline ::int32_t SetExperienceAction::_internal_level() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.level_; } -inline ::df::plugin::SetVelocityAction* PROTOBUF_NONNULL Action::mutable_set_velocity() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SetVelocityAction* _msg = _internal_mutable_set_velocity(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.set_velocity) - return _msg; +inline void SetExperienceAction::_internal_set_level(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.level_ = value; } -// .df.plugin.AddEffectAction add_effect = 30 [json_name = "addEffect"]; -inline bool Action::has_add_effect() const { - return kind_case() == kAddEffect; +// optional float progress = 3 [json_name = "progress"]; +inline bool SetExperienceAction::has_progress() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + return value; } -inline bool Action::_internal_has_add_effect() const { - return kind_case() == kAddEffect; +inline void SetExperienceAction::clear_progress() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.progress_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline void Action::set_has_add_effect() { - _impl_._oneof_case_[0] = kAddEffect; +inline float SetExperienceAction::progress() const { + // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.progress) + return _internal_progress(); } -inline void Action::clear_add_effect() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kAddEffect) { - if (GetArena() == nullptr) { - delete _impl_.kind_.add_effect_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.add_effect_); - } - clear_has_kind(); - } +inline void SetExperienceAction::set_progress(float value) { + _internal_set_progress(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.progress) } -inline ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE Action::release_add_effect() { - // @@protoc_insertion_point(field_release:df.plugin.Action.add_effect) - if (kind_case() == kAddEffect) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.add_effect_ = nullptr; - return temp; - } else { - return nullptr; - } +inline float SetExperienceAction::_internal_progress() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.progress_; } -inline const ::df::plugin::AddEffectAction& Action::_internal_add_effect() const { - return kind_case() == kAddEffect ? static_cast(*reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_)) - : reinterpret_cast(::df::plugin::_AddEffectAction_default_instance_); +inline void SetExperienceAction::_internal_set_progress(float value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.progress_ = value; } -inline const ::df::plugin::AddEffectAction& Action::add_effect() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.add_effect) - return _internal_add_effect(); + +// optional int32 amount = 4 [json_name = "amount"]; +inline bool SetExperienceAction::has_amount() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); + return value; } -inline ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_add_effect() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.add_effect) - if (kind_case() == kAddEffect) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); - _impl_.kind_.add_effect_ = nullptr; - return temp; - } else { - return nullptr; - } +inline void SetExperienceAction::clear_amount() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.amount_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline void Action::unsafe_arena_set_allocated_add_effect( - ::df::plugin::AddEffectAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_add_effect(); - _impl_.kind_.add_effect_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.add_effect) +inline ::int32_t SetExperienceAction::amount() const { + // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.amount) + return _internal_amount(); } -inline ::df::plugin::AddEffectAction* PROTOBUF_NONNULL Action::_internal_mutable_add_effect() { - if (kind_case() != kAddEffect) { - clear_kind(); - set_has_add_effect(); - _impl_.kind_.add_effect_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::AddEffectAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::AddEffectAction*>(_impl_.kind_.add_effect_); +inline void SetExperienceAction::set_amount(::int32_t value) { + _internal_set_amount(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.amount) } -inline ::df::plugin::AddEffectAction* PROTOBUF_NONNULL Action::mutable_add_effect() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::AddEffectAction* _msg = _internal_mutable_add_effect(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.add_effect) - return _msg; +inline ::int32_t SetExperienceAction::_internal_amount() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.amount_; } - -// .df.plugin.RemoveEffectAction remove_effect = 31 [json_name = "removeEffect"]; -inline bool Action::has_remove_effect() const { - return kind_case() == kRemoveEffect; +inline void SetExperienceAction::_internal_set_amount(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.amount_ = value; } -inline bool Action::_internal_has_remove_effect() const { - return kind_case() == kRemoveEffect; + +// ------------------------------------------------------------------- + +// SetVelocityAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SetVelocityAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline void Action::set_has_remove_effect() { - _impl_._oneof_case_[0] = kRemoveEffect; +inline const ::std::string& SetVelocityAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetVelocityAction.player_uuid) + return _internal_player_uuid(); } -inline void Action::clear_remove_effect() { +template +PROTOBUF_ALWAYS_INLINE void SetVelocityAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kRemoveEffect) { - if (GetArena() == nullptr) { - delete _impl_.kind_.remove_effect_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.remove_effect_); - } - clear_has_kind(); - } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SetVelocityAction.player_uuid) } -inline ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE Action::release_remove_effect() { - // @@protoc_insertion_point(field_release:df.plugin.Action.remove_effect) - if (kind_case() == kRemoveEffect) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.remove_effect_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::std::string* PROTOBUF_NONNULL SetVelocityAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetVelocityAction.player_uuid) + return _s; +} +inline const ::std::string& SetVelocityAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline const ::df::plugin::RemoveEffectAction& Action::_internal_remove_effect() const { - return kind_case() == kRemoveEffect ? static_cast(*reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_)) - : reinterpret_cast(::df::plugin::_RemoveEffectAction_default_instance_); +inline void SetVelocityAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline const ::df::plugin::RemoveEffectAction& Action::remove_effect() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.remove_effect) - return _internal_remove_effect(); +inline ::std::string* PROTOBUF_NONNULL SetVelocityAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_remove_effect() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.remove_effect) - if (kind_case() == kRemoveEffect) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); - _impl_.kind_.remove_effect_ = nullptr; - return temp; - } else { +inline ::std::string* PROTOBUF_NULLABLE SetVelocityAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetVelocityAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } -} -inline void Action::unsafe_arena_set_allocated_remove_effect( - ::df::plugin::RemoveEffectAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_remove_effect(); - _impl_.kind_.remove_effect_ = reinterpret_cast<::google::protobuf::Message*>(value); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.remove_effect) + return released; } -inline ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL Action::_internal_mutable_remove_effect() { - if (kind_case() != kRemoveEffect) { - clear_kind(); - set_has_remove_effect(); - _impl_.kind_.remove_effect_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::RemoveEffectAction>(GetArena())); +inline void SetVelocityAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - return reinterpret_cast<::df::plugin::RemoveEffectAction*>(_impl_.kind_.remove_effect_); -} -inline ::df::plugin::RemoveEffectAction* PROTOBUF_NONNULL Action::mutable_remove_effect() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::RemoveEffectAction* _msg = _internal_mutable_remove_effect(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.remove_effect) - return _msg; + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetVelocityAction.player_uuid) } -// .df.plugin.SendTitleAction send_title = 40 [json_name = "sendTitle"]; -inline bool Action::has_send_title() const { - return kind_case() == kSendTitle; +// .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; +inline bool SetVelocityAction::has_velocity() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.velocity_ != nullptr); + return value; } -inline bool Action::_internal_has_send_title() const { - return kind_case() == kSendTitle; +inline const ::df::plugin::Vec3& SetVelocityAction::_internal_velocity() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.velocity_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); } -inline void Action::set_has_send_title() { - _impl_._oneof_case_[0] = kSendTitle; +inline const ::df::plugin::Vec3& SetVelocityAction::velocity() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SetVelocityAction.velocity) + return _internal_velocity(); } -inline void Action::clear_send_title() { +inline void SetVelocityAction::unsafe_arena_set_allocated_velocity( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSendTitle) { - if (GetArena() == nullptr) { - delete _impl_.kind_.send_title_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_title_); - } - clear_has_kind(); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.velocity_); } -} -inline ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE Action::release_send_title() { - // @@protoc_insertion_point(field_release:df.plugin.Action.send_title) - if (kind_case() == kSendTitle) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.send_title_ = nullptr; - return temp; + _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetVelocityAction.velocity) } -inline const ::df::plugin::SendTitleAction& Action::_internal_send_title() const { - return kind_case() == kSendTitle ? static_cast(*reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_)) - : reinterpret_cast(::df::plugin::_SendTitleAction_default_instance_); -} -inline const ::df::plugin::SendTitleAction& Action::send_title() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.send_title) - return _internal_send_title(); -} -inline ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_title() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_title) - if (kind_case() == kSendTitle) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); - _impl_.kind_.send_title_ = nullptr; - return temp; +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE SetVelocityAction::release_velocity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* released = _impl_.velocity_; + _impl_.velocity_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } } else { - return nullptr; + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } + return released; } -inline void Action::unsafe_arena_set_allocated_send_title( - ::df::plugin::SendTitleAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_send_title(); - _impl_.kind_.send_title_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_title) +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE SetVelocityAction::unsafe_arena_release_velocity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SetVelocityAction.velocity) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* temp = _impl_.velocity_; + _impl_.velocity_ = nullptr; + return temp; } -inline ::df::plugin::SendTitleAction* PROTOBUF_NONNULL Action::_internal_mutable_send_title() { - if (kind_case() != kSendTitle) { - clear_kind(); - set_has_send_title(); - _impl_.kind_.send_title_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendTitleAction>(GetArena())); +inline ::df::plugin::Vec3* PROTOBUF_NONNULL SetVelocityAction::_internal_mutable_velocity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.velocity_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(p); } - return reinterpret_cast<::df::plugin::SendTitleAction*>(_impl_.kind_.send_title_); + return _impl_.velocity_; } -inline ::df::plugin::SendTitleAction* PROTOBUF_NONNULL Action::mutable_send_title() +inline ::df::plugin::Vec3* PROTOBUF_NONNULL SetVelocityAction::mutable_velocity() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SendTitleAction* _msg = _internal_mutable_send_title(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_title) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* _msg = _internal_mutable_velocity(); + // @@protoc_insertion_point(field_mutable:df.plugin.SetVelocityAction.velocity) return _msg; } - -// .df.plugin.SendPopupAction send_popup = 41 [json_name = "sendPopup"]; -inline bool Action::has_send_popup() const { - return kind_case() == kSendPopup; -} -inline bool Action::_internal_has_send_popup() const { - return kind_case() == kSendPopup; -} -inline void Action::set_has_send_popup() { - _impl_._oneof_case_[0] = kSendPopup; -} -inline void Action::clear_send_popup() { +inline void SetVelocityAction::set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSendPopup) { - if (GetArena() == nullptr) { - delete _impl_.kind_.send_popup_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_popup_); - } - clear_has_kind(); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.velocity_); } -} -inline ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE Action::release_send_popup() { - // @@protoc_insertion_point(field_release:df.plugin.Action.send_popup) - if (kind_case() == kSendPopup) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - _impl_.kind_.send_popup_ = nullptr; - return temp; + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } + + _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.SetVelocityAction.velocity) } -inline const ::df::plugin::SendPopupAction& Action::_internal_send_popup() const { - return kind_case() == kSendPopup ? static_cast(*reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_)) - : reinterpret_cast(::df::plugin::_SendPopupAction_default_instance_); -} -inline const ::df::plugin::SendPopupAction& Action::send_popup() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.send_popup) - return _internal_send_popup(); -} -inline ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_popup() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_popup) - if (kind_case() == kSendPopup) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); - _impl_.kind_.send_popup_ = nullptr; - return temp; - } else { - return nullptr; - } + +// ------------------------------------------------------------------- + +// AddEffectAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void AddEffectAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); } -inline void Action::unsafe_arena_set_allocated_send_popup( - ::df::plugin::SendPopupAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_send_popup(); - _impl_.kind_.send_popup_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_popup) +inline const ::std::string& AddEffectAction::player_uuid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.player_uuid) + return _internal_player_uuid(); } -inline ::df::plugin::SendPopupAction* PROTOBUF_NONNULL Action::_internal_mutable_send_popup() { - if (kind_case() != kSendPopup) { - clear_kind(); - set_has_send_popup(); - _impl_.kind_.send_popup_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendPopupAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::SendPopupAction*>(_impl_.kind_.send_popup_); +template +PROTOBUF_ALWAYS_INLINE void AddEffectAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.player_uuid) } -inline ::df::plugin::SendPopupAction* PROTOBUF_NONNULL Action::mutable_send_popup() +inline ::std::string* PROTOBUF_NONNULL AddEffectAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SendPopupAction* _msg = _internal_mutable_send_popup(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_popup) - return _msg; + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.AddEffectAction.player_uuid) + return _s; } - -// .df.plugin.SendTipAction send_tip = 42 [json_name = "sendTip"]; -inline bool Action::has_send_tip() const { - return kind_case() == kSendTip; +inline const ::std::string& AddEffectAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline bool Action::_internal_has_send_tip() const { - return kind_case() == kSendTip; +inline void AddEffectAction::_internal_set_player_uuid(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.Set(value, GetArena()); } -inline void Action::set_has_send_tip() { - _impl_._oneof_case_[0] = kSendTip; +inline ::std::string* PROTOBUF_NONNULL AddEffectAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline void Action::clear_send_tip() { +inline ::std::string* PROTOBUF_NULLABLE AddEffectAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kSendTip) { - if (GetArena() == nullptr) { - delete _impl_.kind_.send_tip_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.send_tip_); - } - clear_has_kind(); + // @@protoc_insertion_point(field_release:df.plugin.AddEffectAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); } + return released; } -inline ::df::plugin::SendTipAction* PROTOBUF_NULLABLE Action::release_send_tip() { - // @@protoc_insertion_point(field_release:df.plugin.Action.send_tip) - if (kind_case() == kSendTip) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.send_tip_ = nullptr; - return temp; +inline void AddEffectAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.AddEffectAction.player_uuid) } -inline const ::df::plugin::SendTipAction& Action::_internal_send_tip() const { - return kind_case() == kSendTip ? static_cast(*reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_)) - : reinterpret_cast(::df::plugin::_SendTipAction_default_instance_); -} -inline const ::df::plugin::SendTipAction& Action::send_tip() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.send_tip) - return _internal_send_tip(); + +// .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; +inline void AddEffectAction::clear_effect_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.effect_type_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline ::df::plugin::SendTipAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_send_tip() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.send_tip) - if (kind_case() == kSendTip) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); - _impl_.kind_.send_tip_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::df::plugin::EffectType AddEffectAction::effect_type() const { + // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.effect_type) + return _internal_effect_type(); } -inline void Action::unsafe_arena_set_allocated_send_tip( - ::df::plugin::SendTipAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_send_tip(); - _impl_.kind_.send_tip_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.send_tip) +inline void AddEffectAction::set_effect_type(::df::plugin::EffectType value) { + _internal_set_effect_type(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.effect_type) } -inline ::df::plugin::SendTipAction* PROTOBUF_NONNULL Action::_internal_mutable_send_tip() { - if (kind_case() != kSendTip) { - clear_kind(); - set_has_send_tip(); - _impl_.kind_.send_tip_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::SendTipAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::SendTipAction*>(_impl_.kind_.send_tip_); +inline ::df::plugin::EffectType AddEffectAction::_internal_effect_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::EffectType>(_impl_.effect_type_); } -inline ::df::plugin::SendTipAction* PROTOBUF_NONNULL Action::mutable_send_tip() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::SendTipAction* _msg = _internal_mutable_send_tip(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.send_tip) - return _msg; +inline void AddEffectAction::_internal_set_effect_type(::df::plugin::EffectType value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.effect_type_ = value; } -// .df.plugin.PlaySoundAction play_sound = 43 [json_name = "playSound"]; -inline bool Action::has_play_sound() const { - return kind_case() == kPlaySound; +// int32 level = 3 [json_name = "level"]; +inline void AddEffectAction::clear_level() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.level_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); } -inline bool Action::_internal_has_play_sound() const { - return kind_case() == kPlaySound; +inline ::int32_t AddEffectAction::level() const { + // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.level) + return _internal_level(); } -inline void Action::set_has_play_sound() { - _impl_._oneof_case_[0] = kPlaySound; +inline void AddEffectAction::set_level(::int32_t value) { + _internal_set_level(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.level) } -inline void Action::clear_play_sound() { +inline ::int32_t AddEffectAction::_internal_level() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.level_; +} +inline void AddEffectAction::_internal_set_level(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kPlaySound) { - if (GetArena() == nullptr) { - delete _impl_.kind_.play_sound_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.play_sound_); - } - clear_has_kind(); - } + _impl_.level_ = value; } -inline ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE Action::release_play_sound() { - // @@protoc_insertion_point(field_release:df.plugin.Action.play_sound) - if (kind_case() == kPlaySound) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.play_sound_ = nullptr; - return temp; - } else { - return nullptr; - } + +// int64 duration_ms = 4 [json_name = "durationMs"]; +inline void AddEffectAction::clear_duration_ms() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_ms_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline const ::df::plugin::PlaySoundAction& Action::_internal_play_sound() const { - return kind_case() == kPlaySound ? static_cast(*reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_)) - : reinterpret_cast(::df::plugin::_PlaySoundAction_default_instance_); +inline ::int64_t AddEffectAction::duration_ms() const { + // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.duration_ms) + return _internal_duration_ms(); } -inline const ::df::plugin::PlaySoundAction& Action::play_sound() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.play_sound) - return _internal_play_sound(); +inline void AddEffectAction::set_duration_ms(::int64_t value) { + _internal_set_duration_ms(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.duration_ms) } -inline ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_play_sound() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.play_sound) - if (kind_case() == kPlaySound) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); - _impl_.kind_.play_sound_ = nullptr; - return temp; - } else { - return nullptr; - } +inline ::int64_t AddEffectAction::_internal_duration_ms() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.duration_ms_; +} +inline void AddEffectAction::_internal_set_duration_ms(::int64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_ms_ = value; +} + +// bool show_particles = 5 [json_name = "showParticles"]; +inline void AddEffectAction::clear_show_particles() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.show_particles_ = false; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); +} +inline bool AddEffectAction::show_particles() const { + // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.show_particles) + return _internal_show_particles(); +} +inline void AddEffectAction::set_show_particles(bool value) { + _internal_set_show_particles(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.show_particles) } -inline void Action::unsafe_arena_set_allocated_play_sound( - ::df::plugin::PlaySoundAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_play_sound(); - _impl_.kind_.play_sound_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.play_sound) +inline bool AddEffectAction::_internal_show_particles() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.show_particles_; } -inline ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL Action::_internal_mutable_play_sound() { - if (kind_case() != kPlaySound) { - clear_kind(); - set_has_play_sound(); - _impl_.kind_.play_sound_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::PlaySoundAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::PlaySoundAction*>(_impl_.kind_.play_sound_); +inline void AddEffectAction::_internal_set_show_particles(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.show_particles_ = value; } -inline ::df::plugin::PlaySoundAction* PROTOBUF_NONNULL Action::mutable_play_sound() + +// ------------------------------------------------------------------- + +// RemoveEffectAction + +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void RemoveEffectAction::clear_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_uuid_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::std::string& RemoveEffectAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::PlaySoundAction* _msg = _internal_mutable_play_sound(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.play_sound) - return _msg; + // @@protoc_insertion_point(field_get:df.plugin.RemoveEffectAction.player_uuid) + return _internal_player_uuid(); } - -// .df.plugin.ExecuteCommandAction execute_command = 50 [json_name = "executeCommand"]; -inline bool Action::has_execute_command() const { - return kind_case() == kExecuteCommand; +template +PROTOBUF_ALWAYS_INLINE void RemoveEffectAction::set_player_uuid(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.RemoveEffectAction.player_uuid) } -inline bool Action::_internal_has_execute_command() const { - return kind_case() == kExecuteCommand; +inline ::std::string* PROTOBUF_NONNULL RemoveEffectAction::mutable_player_uuid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.RemoveEffectAction.player_uuid) + return _s; } -inline void Action::set_has_execute_command() { - _impl_._oneof_case_[0] = kExecuteCommand; +inline const ::std::string& RemoveEffectAction::_internal_player_uuid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_uuid_.Get(); } -inline void Action::clear_execute_command() { +inline void RemoveEffectAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kExecuteCommand) { - if (GetArena() == nullptr) { - delete _impl_.kind_.execute_command_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.execute_command_); - } - clear_has_kind(); - } + _impl_.player_uuid_.Set(value, GetArena()); } -inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE Action::release_execute_command() { - // @@protoc_insertion_point(field_release:df.plugin.Action.execute_command) - if (kind_case() == kExecuteCommand) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.execute_command_ = nullptr; - return temp; - } else { +inline ::std::string* PROTOBUF_NONNULL RemoveEffectAction::_internal_mutable_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.player_uuid_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE RemoveEffectAction::release_player_uuid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.RemoveEffectAction.player_uuid) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + auto* released = _impl_.player_uuid_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.player_uuid_.Set("", GetArena()); + } + return released; } -inline const ::df::plugin::ExecuteCommandAction& Action::_internal_execute_command() const { - return kind_case() == kExecuteCommand ? static_cast(*reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_)) - : reinterpret_cast(::df::plugin::_ExecuteCommandAction_default_instance_); -} -inline const ::df::plugin::ExecuteCommandAction& Action::execute_command() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.execute_command) - return _internal_execute_command(); -} -inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_execute_command() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.execute_command) - if (kind_case() == kExecuteCommand) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); - _impl_.kind_.execute_command_ = nullptr; - return temp; +inline void RemoveEffectAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - return nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -} -inline void Action::unsafe_arena_set_allocated_execute_command( - ::df::plugin::ExecuteCommandAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_execute_command(); - _impl_.kind_.execute_command_ = reinterpret_cast<::google::protobuf::Message*>(value); + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.execute_command) + // @@protoc_insertion_point(field_set_allocated:df.plugin.RemoveEffectAction.player_uuid) } -inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL Action::_internal_mutable_execute_command() { - if (kind_case() != kExecuteCommand) { - clear_kind(); - set_has_execute_command(); - _impl_.kind_.execute_command_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::ExecuteCommandAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::ExecuteCommandAction*>(_impl_.kind_.execute_command_); + +// .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; +inline void RemoveEffectAction::clear_effect_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.effect_type_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline ::df::plugin::ExecuteCommandAction* PROTOBUF_NONNULL Action::mutable_execute_command() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::ExecuteCommandAction* _msg = _internal_mutable_execute_command(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.execute_command) - return _msg; +inline ::df::plugin::EffectType RemoveEffectAction::effect_type() const { + // @@protoc_insertion_point(field_get:df.plugin.RemoveEffectAction.effect_type) + return _internal_effect_type(); } - -inline bool Action::has_kind() const { - return kind_case() != KIND_NOT_SET; +inline void RemoveEffectAction::set_effect_type(::df::plugin::EffectType value) { + _internal_set_effect_type(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.RemoveEffectAction.effect_type) } -inline void Action::clear_has_kind() { - _impl_._oneof_case_[0] = KIND_NOT_SET; +inline ::df::plugin::EffectType RemoveEffectAction::_internal_effect_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::EffectType>(_impl_.effect_type_); } -inline Action::KindCase Action::kind_case() const { - return Action::KindCase(_impl_._oneof_case_[0]); +inline void RemoveEffectAction::_internal_set_effect_type(::df::plugin::EffectType value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.effect_type_ = value; } + // ------------------------------------------------------------------- -// SendChatAction +// SendTitleAction -// string target_uuid = 1 [json_name = "targetUuid"]; -inline void SendChatAction::clear_target_uuid() { +// string player_uuid = 1 [json_name = "playerUuid"]; +inline void SendTitleAction::clear_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.target_uuid_.ClearToEmpty(); + _impl_.player_uuid_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& SendChatAction::target_uuid() const +inline const ::std::string& SendTitleAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendChatAction.target_uuid) - return _internal_target_uuid(); + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.player_uuid) + return _internal_player_uuid(); } template -PROTOBUF_ALWAYS_INLINE void SendChatAction::set_target_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.target_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendChatAction.target_uuid) + _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.player_uuid) } -inline ::std::string* PROTOBUF_NONNULL SendChatAction::mutable_target_uuid() +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_target_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendChatAction.target_uuid) + ::std::string* _s = _internal_mutable_player_uuid(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.player_uuid) return _s; } -inline const ::std::string& SendChatAction::_internal_target_uuid() const { +inline const ::std::string& SendTitleAction::_internal_player_uuid() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.target_uuid_.Get(); + return _impl_.player_uuid_.Get(); } -inline void SendChatAction::_internal_set_target_uuid(const ::std::string& value) { +inline void SendTitleAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.target_uuid_.Set(value, GetArena()); + _impl_.player_uuid_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL SendChatAction::_internal_mutable_target_uuid() { +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.target_uuid_.Mutable( GetArena()); + return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE SendChatAction::release_target_uuid() { +inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendChatAction.target_uuid) + // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.player_uuid) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.target_uuid_.Release(); + auto* released = _impl_.player_uuid_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.target_uuid_.Set("", GetArena()); + _impl_.player_uuid_.Set("", GetArena()); } return released; } -inline void SendChatAction::set_allocated_target_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void SendTitleAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.target_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.target_uuid_.IsDefault()) { - _impl_.target_uuid_.Set("", GetArena()); + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendChatAction.target_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.player_uuid) } -// string message = 2 [json_name = "message"]; -inline void SendChatAction::clear_message() { +// string title = 2 [json_name = "title"]; +inline void SendTitleAction::clear_title() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.ClearToEmpty(); + _impl_.title_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline const ::std::string& SendChatAction::message() const +inline const ::std::string& SendTitleAction::title() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendChatAction.message) - return _internal_message(); + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.title) + return _internal_title(); } template -PROTOBUF_ALWAYS_INLINE void SendChatAction::set_message(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_title(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.message_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendChatAction.message) + _impl_.title_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.title) } -inline ::std::string* PROTOBUF_NONNULL SendChatAction::mutable_message() +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_title() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendChatAction.message) + ::std::string* _s = _internal_mutable_title(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.title) return _s; } -inline const ::std::string& SendChatAction::_internal_message() const { +inline const ::std::string& SendTitleAction::_internal_title() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.message_.Get(); + return _impl_.title_.Get(); } -inline void SendChatAction::_internal_set_message(const ::std::string& value) { +inline void SendTitleAction::_internal_set_title(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.Set(value, GetArena()); + _impl_.title_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL SendChatAction::_internal_mutable_message() { +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_title() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.message_.Mutable( GetArena()); + return _impl_.title_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE SendChatAction::release_message() { +inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_title() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendChatAction.message) + // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.title) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.message_.Release(); + auto* released = _impl_.title_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.message_.Set("", GetArena()); + _impl_.title_.Set("", GetArena()); } return released; } -inline void SendChatAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { +inline void SendTitleAction::set_allocated_title(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.message_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArena()); + _impl_.title_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.title_.IsDefault()) { + _impl_.title_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendChatAction.message) + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.title) } -// ------------------------------------------------------------------- - -// TeleportAction - -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void TeleportAction::clear_player_uuid() { +// optional string subtitle = 3 [json_name = "subtitle"]; +inline bool SendTitleAction::has_subtitle() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + return value; +} +inline void SendTitleAction::clear_subtitle() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); + _impl_.subtitle_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + 0x00000004U); } -inline const ::std::string& TeleportAction::player_uuid() const +inline const ::std::string& SendTitleAction::subtitle() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.player_uuid) - return _internal_player_uuid(); + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.subtitle) + return _internal_subtitle(); } template -PROTOBUF_ALWAYS_INLINE void TeleportAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_subtitle(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.TeleportAction.player_uuid) + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + _impl_.subtitle_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.subtitle) } -inline ::std::string* PROTOBUF_NONNULL TeleportAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_subtitle() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.player_uuid) + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::std::string* _s = _internal_mutable_subtitle(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.subtitle) return _s; } -inline const ::std::string& TeleportAction::_internal_player_uuid() const { +inline const ::std::string& SendTitleAction::_internal_subtitle() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + return _impl_.subtitle_.Get(); } -inline void TeleportAction::_internal_set_player_uuid(const ::std::string& value) { +inline void SendTitleAction::_internal_set_subtitle(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + _impl_.subtitle_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL TeleportAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_subtitle() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + return _impl_.subtitle_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE TeleportAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_subtitle() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { + // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.subtitle) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + auto* released = _impl_.subtitle_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.subtitle_.Set("", GetArena()); } return released; } -inline void TeleportAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void SendTitleAction::set_allocated_subtitle(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.subtitle_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.subtitle_.IsDefault()) { + _impl_.subtitle_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.subtitle) } -// .df.plugin.Vec3 position = 2 [json_name = "position"]; -inline bool TeleportAction::has_position() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); +// optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; +inline bool SendTitleAction::has_fade_in_ms() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); return value; } -inline const ::df::plugin::Vec3& TeleportAction::_internal_position() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::Vec3* p = _impl_.position_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); -} -inline const ::df::plugin::Vec3& TeleportAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.position) - return _internal_position(); -} -inline void TeleportAction::unsafe_arena_set_allocated_position( - ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); - } - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.TeleportAction.position) -} -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::release_position() { +inline void SendTitleAction::clear_fade_in_ms() { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* released = _impl_.position_; - _impl_.position_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; + _impl_.fade_in_ms_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000008U); } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::unsafe_arena_release_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.position) - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* temp = _impl_.position_; - _impl_.position_ = nullptr; - return temp; +inline ::int64_t SendTitleAction::fade_in_ms() const { + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.fade_in_ms) + return _internal_fade_in_ms(); } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::_internal_mutable_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); - } - return _impl_.position_; +inline void SendTitleAction::set_fade_in_ms(::int64_t value) { + _internal_set_fade_in_ms(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.fade_in_ms) } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::mutable_position() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* _msg = _internal_mutable_position(); - // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.position) - return _msg; +inline ::int64_t SendTitleAction::_internal_fade_in_ms() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.fade_in_ms_; } -inline void TeleportAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline void SendTitleAction::_internal_set_fade_in_ms(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.position) + _impl_.fade_in_ms_ = value; } -// .df.plugin.Vec3 rotation = 3 [json_name = "rotation"]; -inline bool TeleportAction::has_rotation() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); - PROTOBUF_ASSUME(!value || _impl_.rotation_ != nullptr); +// optional int64 duration_ms = 5 [json_name = "durationMs"]; +inline bool SendTitleAction::has_duration_ms() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); return value; } -inline const ::df::plugin::Vec3& TeleportAction::_internal_rotation() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::Vec3* p = _impl_.rotation_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +inline void SendTitleAction::clear_duration_ms() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.duration_ms_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -inline const ::df::plugin::Vec3& TeleportAction::rotation() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.TeleportAction.rotation) - return _internal_rotation(); +inline ::int64_t SendTitleAction::duration_ms() const { + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.duration_ms) + return _internal_duration_ms(); } -inline void TeleportAction::unsafe_arena_set_allocated_rotation( - ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rotation_); - } - _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.TeleportAction.rotation) +inline void SendTitleAction::set_duration_ms(::int64_t value) { + _internal_set_duration_ms(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.duration_ms) +} +inline ::int64_t SendTitleAction::_internal_duration_ms() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.duration_ms_; } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::release_rotation() { +inline void SendTitleAction::_internal_set_duration_ms(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* released = _impl_.rotation_; - _impl_.rotation_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; + _impl_.duration_ms_ = value; } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE TeleportAction::unsafe_arena_release_rotation() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.TeleportAction.rotation) - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* temp = _impl_.rotation_; - _impl_.rotation_ = nullptr; - return temp; +// optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; +inline bool SendTitleAction::has_fade_out_ms() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); + return value; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::_internal_mutable_rotation() { +inline void SendTitleAction::clear_fade_out_ms() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.rotation_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); - _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(p); - } - return _impl_.rotation_; + _impl_.fade_out_ms_ = ::int64_t{0}; + ClearHasBit(_impl_._has_bits_[0], + 0x00000020U); } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL TeleportAction::mutable_rotation() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* _msg = _internal_mutable_rotation(); - // @@protoc_insertion_point(field_mutable:df.plugin.TeleportAction.rotation) - return _msg; +inline ::int64_t SendTitleAction::fade_out_ms() const { + // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.fade_out_ms) + return _internal_fade_out_ms(); } -inline void TeleportAction::set_allocated_rotation(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline void SendTitleAction::set_fade_out_ms(::int64_t value) { + _internal_set_fade_out_ms(value); + SetHasBit(_impl_._has_bits_[0], 0x00000020U); + // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.fade_out_ms) +} +inline ::int64_t SendTitleAction::_internal_fade_out_ms() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.fade_out_ms_; +} +inline void SendTitleAction::_internal_set_fade_out_ms(::int64_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.rotation_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - - _impl_.rotation_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.TeleportAction.rotation) + _impl_.fade_out_ms_ = value; } // ------------------------------------------------------------------- -// KickAction +// SendPopupAction // string player_uuid = 1 [json_name = "playerUuid"]; -inline void KickAction::clear_player_uuid() { +inline void SendPopupAction::clear_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& KickAction::player_uuid() const +inline const ::std::string& SendPopupAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.KickAction.player_uuid) + // @@protoc_insertion_point(field_get:df.plugin.SendPopupAction.player_uuid) return _internal_player_uuid(); } template -PROTOBUF_ALWAYS_INLINE void KickAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendPopupAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.KickAction.player_uuid) + // @@protoc_insertion_point(field_set:df.plugin.SendPopupAction.player_uuid) } -inline ::std::string* PROTOBUF_NONNULL KickAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL SendPopupAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.KickAction.player_uuid) + // @@protoc_insertion_point(field_mutable:df.plugin.SendPopupAction.player_uuid) return _s; } -inline const ::std::string& KickAction::_internal_player_uuid() const { +inline const ::std::string& SendPopupAction::_internal_player_uuid() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.player_uuid_.Get(); } -inline void KickAction::_internal_set_player_uuid(const ::std::string& value) { +inline void SendPopupAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL KickAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL SendPopupAction::_internal_mutable_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE KickAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE SendPopupAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.KickAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.SendPopupAction.player_uuid) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } @@ -7016,7 +13552,7 @@ inline ::std::string* PROTOBUF_NULLABLE KickAction::release_player_uuid() { } return released; } -inline void KickAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void SendPopupAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); @@ -7027,213 +13563,253 @@ inline void KickAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLAB if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.KickAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendPopupAction.player_uuid) } -// string reason = 2 [json_name = "reason"]; -inline void KickAction::clear_reason() { +// string message = 2 [json_name = "message"]; +inline void SendPopupAction::clear_message() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.reason_.ClearToEmpty(); + _impl_.message_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline const ::std::string& KickAction::reason() const +inline const ::std::string& SendPopupAction::message() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.KickAction.reason) - return _internal_reason(); + // @@protoc_insertion_point(field_get:df.plugin.SendPopupAction.message) + return _internal_message(); } template -PROTOBUF_ALWAYS_INLINE void KickAction::set_reason(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendPopupAction::set_message(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.reason_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.KickAction.reason) + _impl_.message_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendPopupAction.message) } -inline ::std::string* PROTOBUF_NONNULL KickAction::mutable_reason() +inline ::std::string* PROTOBUF_NONNULL SendPopupAction::mutable_message() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_reason(); - // @@protoc_insertion_point(field_mutable:df.plugin.KickAction.reason) + ::std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendPopupAction.message) return _s; } -inline const ::std::string& KickAction::_internal_reason() const { +inline const ::std::string& SendPopupAction::_internal_message() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.reason_.Get(); + return _impl_.message_.Get(); } -inline void KickAction::_internal_set_reason(const ::std::string& value) { +inline void SendPopupAction::_internal_set_message(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.reason_.Set(value, GetArena()); + _impl_.message_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL KickAction::_internal_mutable_reason() { +inline ::std::string* PROTOBUF_NONNULL SendPopupAction::_internal_mutable_message() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.reason_.Mutable( GetArena()); + return _impl_.message_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE KickAction::release_reason() { +inline ::std::string* PROTOBUF_NULLABLE SendPopupAction::release_message() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.KickAction.reason) + // @@protoc_insertion_point(field_release:df.plugin.SendPopupAction.message) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.reason_.Release(); + auto* released = _impl_.message_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.reason_.Set("", GetArena()); + _impl_.message_.Set("", GetArena()); } return released; } -inline void KickAction::set_allocated_reason(::std::string* PROTOBUF_NULLABLE value) { +inline void SendPopupAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.reason_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.reason_.IsDefault()) { - _impl_.reason_.Set("", GetArena()); + _impl_.message_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.KickAction.reason) + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendPopupAction.message) } // ------------------------------------------------------------------- -// SetGameModeAction +// SendTipAction // string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetGameModeAction::clear_player_uuid() { +inline void SendTipAction::clear_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& SetGameModeAction::player_uuid() const +inline const ::std::string& SendTipAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetGameModeAction.player_uuid) + // @@protoc_insertion_point(field_get:df.plugin.SendTipAction.player_uuid) return _internal_player_uuid(); } template -PROTOBUF_ALWAYS_INLINE void SetGameModeAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void SendTipAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetGameModeAction.player_uuid) + // @@protoc_insertion_point(field_set:df.plugin.SendTipAction.player_uuid) } -inline ::std::string* PROTOBUF_NONNULL SetGameModeAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL SendTipAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetGameModeAction.player_uuid) + // @@protoc_insertion_point(field_mutable:df.plugin.SendTipAction.player_uuid) return _s; } -inline const ::std::string& SetGameModeAction::_internal_player_uuid() const { +inline const ::std::string& SendTipAction::_internal_player_uuid() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.player_uuid_.Get(); } -inline void SetGameModeAction::_internal_set_player_uuid(const ::std::string& value) { +inline void SendTipAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL SetGameModeAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL SendTipAction::_internal_mutable_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE SetGameModeAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE SendTipAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetGameModeAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.SendTipAction.player_uuid) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000001U); auto* released = _impl_.player_uuid_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.player_uuid_.Set("", GetArena()); + } + return released; +} +inline void SendTipAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + _impl_.player_uuid_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { + _impl_.player_uuid_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTipAction.player_uuid) +} + +// string message = 2 [json_name = "message"]; +inline void SendTipAction::clear_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.message_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +inline const ::std::string& SendTipAction::message() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.SendTipAction.message) + return _internal_message(); +} +template +PROTOBUF_ALWAYS_INLINE void SendTipAction::set_message(Arg_&& arg, Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + _impl_.message_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.SendTipAction.message) +} +inline ::std::string* PROTOBUF_NONNULL SendTipAction::mutable_message() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_message(); + // @@protoc_insertion_point(field_mutable:df.plugin.SendTipAction.message) + return _s; +} +inline const ::std::string& SendTipAction::_internal_message() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.message_.Get(); +} +inline void SendTipAction::_internal_set_message(const ::std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.message_.Set(value, GetArena()); +} +inline ::std::string* PROTOBUF_NONNULL SendTipAction::_internal_mutable_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.message_.Mutable( GetArena()); +} +inline ::std::string* PROTOBUF_NULLABLE SendTipAction::release_message() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.SendTipAction.message) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; + } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.message_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.message_.Set("", GetArena()); } return released; } -inline void SetGameModeAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void SendTipAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.message_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { + _impl_.message_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetGameModeAction.player_uuid) -} - -// .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; -inline void SetGameModeAction::clear_game_mode() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.game_mode_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); -} -inline ::df::plugin::GameMode SetGameModeAction::game_mode() const { - // @@protoc_insertion_point(field_get:df.plugin.SetGameModeAction.game_mode) - return _internal_game_mode(); -} -inline void SetGameModeAction::set_game_mode(::df::plugin::GameMode value) { - _internal_set_game_mode(value); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.SetGameModeAction.game_mode) -} -inline ::df::plugin::GameMode SetGameModeAction::_internal_game_mode() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::df::plugin::GameMode>(_impl_.game_mode_); -} -inline void SetGameModeAction::_internal_set_game_mode(::df::plugin::GameMode value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.game_mode_ = value; + // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTipAction.message) } // ------------------------------------------------------------------- -// GiveItemAction +// PlaySoundAction // string player_uuid = 1 [json_name = "playerUuid"]; -inline void GiveItemAction::clear_player_uuid() { +inline void PlaySoundAction::clear_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& GiveItemAction::player_uuid() const +inline const ::std::string& PlaySoundAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.GiveItemAction.player_uuid) + // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.player_uuid) return _internal_player_uuid(); } template -PROTOBUF_ALWAYS_INLINE void GiveItemAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void PlaySoundAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.GiveItemAction.player_uuid) + // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.player_uuid) } -inline ::std::string* PROTOBUF_NONNULL GiveItemAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL PlaySoundAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.GiveItemAction.player_uuid) + // @@protoc_insertion_point(field_mutable:df.plugin.PlaySoundAction.player_uuid) return _s; } -inline const ::std::string& GiveItemAction::_internal_player_uuid() const { +inline const ::std::string& PlaySoundAction::_internal_player_uuid() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.player_uuid_.Get(); } -inline void GiveItemAction::_internal_set_player_uuid(const ::std::string& value) { +inline void PlaySoundAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL GiveItemAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL PlaySoundAction::_internal_mutable_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE GiveItemAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE PlaySoundAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.GiveItemAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.PlaySoundAction.player_uuid) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } @@ -7244,7 +13820,7 @@ inline ::std::string* PROTOBUF_NULLABLE GiveItemAction::release_player_uuid() { } return released; } -inline void GiveItemAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void PlaySoundAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); @@ -7255,44 +13831,69 @@ inline void GiveItemAction::set_allocated_player_uuid(::std::string* PROTOBUF_NU if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.GiveItemAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.PlaySoundAction.player_uuid) } -// .df.plugin.ItemStack item = 2 [json_name = "item"]; -inline bool GiveItemAction::has_item() const { +// .df.plugin.Sound sound = 2 [json_name = "sound"]; +inline void PlaySoundAction::clear_sound() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sound_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +inline ::df::plugin::Sound PlaySoundAction::sound() const { + // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.sound) + return _internal_sound(); +} +inline void PlaySoundAction::set_sound(::df::plugin::Sound value) { + _internal_set_sound(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.sound) +} +inline ::df::plugin::Sound PlaySoundAction::_internal_sound() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::Sound>(_impl_.sound_); +} +inline void PlaySoundAction::_internal_set_sound(::df::plugin::Sound value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sound_ = value; +} + +// optional .df.plugin.Vec3 position = 3 [json_name = "position"]; +inline bool PlaySoundAction::has_position() const { bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.item_ != nullptr); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); return value; } -inline const ::df::plugin::ItemStack& GiveItemAction::_internal_item() const { +inline const ::df::plugin::Vec3& PlaySoundAction::_internal_position() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::ItemStack* p = _impl_.item_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); + const ::df::plugin::Vec3* p = _impl_.position_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); } -inline const ::df::plugin::ItemStack& GiveItemAction::item() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.GiveItemAction.item) - return _internal_item(); +inline const ::df::plugin::Vec3& PlaySoundAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.position) + return _internal_position(); } -inline void GiveItemAction::unsafe_arena_set_allocated_item( - ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { +inline void PlaySoundAction::unsafe_arena_set_allocated_position( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.item_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); } - _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.GiveItemAction.item) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.PlaySoundAction.position) } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE GiveItemAction::release_item() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE PlaySoundAction::release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* released = _impl_.item_; - _impl_.item_ = nullptr; + ::df::plugin::Vec3* released = _impl_.position_; + _impl_.position_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); @@ -7306,35 +13907,35 @@ inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE GiveItemAction::release_item() } return released; } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE GiveItemAction::unsafe_arena_release_item() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE PlaySoundAction::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.GiveItemAction.item) + // @@protoc_insertion_point(field_release:df.plugin.PlaySoundAction.position) ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* temp = _impl_.item_; - _impl_.item_ = nullptr; + ::df::plugin::Vec3* temp = _impl_.position_; + _impl_.position_ = nullptr; return temp; } -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL GiveItemAction::_internal_mutable_item() { +inline ::df::plugin::Vec3* PROTOBUF_NONNULL PlaySoundAction::_internal_mutable_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.item_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); - _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(p); + if (_impl_.position_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); } - return _impl_.item_; + return _impl_.position_; } -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL GiveItemAction::mutable_item() +inline ::df::plugin::Vec3* PROTOBUF_NONNULL PlaySoundAction::mutable_position() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* _msg = _internal_mutable_item(); - // @@protoc_insertion_point(field_mutable:df.plugin.GiveItemAction.item) + ::df::plugin::Vec3* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.PlaySoundAction.position) return _msg; } -inline void GiveItemAction::set_allocated_item(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { +inline void PlaySoundAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.item_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); } if (value != nullptr) { @@ -7347,124 +13948,113 @@ inline void GiveItemAction::set_allocated_item(::df::plugin::ItemStack* PROTOBUF ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.item_ = reinterpret_cast<::df::plugin::ItemStack*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.GiveItemAction.item) + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.PlaySoundAction.position) } -// ------------------------------------------------------------------- - -// ClearInventoryAction - -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void ClearInventoryAction::clear_player_uuid() { +// optional float volume = 4 [json_name = "volume"]; +inline bool PlaySoundAction::has_volume() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); + return value; +} +inline void PlaySoundAction::clear_volume() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); + _impl_.volume_ = 0; ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -inline const ::std::string& ClearInventoryAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.ClearInventoryAction.player_uuid) - return _internal_player_uuid(); + 0x00000008U); } -template -PROTOBUF_ALWAYS_INLINE void ClearInventoryAction::set_player_uuid(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.ClearInventoryAction.player_uuid) +inline float PlaySoundAction::volume() const { + // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.volume) + return _internal_volume(); } -inline ::std::string* PROTOBUF_NONNULL ClearInventoryAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.ClearInventoryAction.player_uuid) - return _s; +inline void PlaySoundAction::set_volume(float value) { + _internal_set_volume(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.volume) } -inline const ::std::string& ClearInventoryAction::_internal_player_uuid() const { +inline float PlaySoundAction::_internal_volume() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + return _impl_.volume_; } -inline void ClearInventoryAction::_internal_set_player_uuid(const ::std::string& value) { +inline void PlaySoundAction::_internal_set_volume(float value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + _impl_.volume_ = value; } -inline ::std::string* PROTOBUF_NONNULL ClearInventoryAction::_internal_mutable_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + +// optional float pitch = 5 [json_name = "pitch"]; +inline bool PlaySoundAction::has_pitch() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); + return value; } -inline ::std::string* PROTOBUF_NULLABLE ClearInventoryAction::release_player_uuid() { +inline void PlaySoundAction::clear_pitch() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.ClearInventoryAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); - } - return released; + _impl_.pitch_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000010U); } -inline void ClearInventoryAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.ClearInventoryAction.player_uuid) +inline float PlaySoundAction::pitch() const { + // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.pitch) + return _internal_pitch(); +} +inline void PlaySoundAction::set_pitch(float value) { + _internal_set_pitch(value); + SetHasBit(_impl_._has_bits_[0], 0x00000010U); + // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.pitch) +} +inline float PlaySoundAction::_internal_pitch() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pitch_; +} +inline void PlaySoundAction::_internal_set_pitch(float value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pitch_ = value; } // ------------------------------------------------------------------- -// SetHeldItemAction +// ExecuteCommandAction // string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetHeldItemAction::clear_player_uuid() { +inline void ExecuteCommandAction::clear_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& SetHeldItemAction::player_uuid() const +inline const ::std::string& ExecuteCommandAction::player_uuid() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.player_uuid) + // @@protoc_insertion_point(field_get:df.plugin.ExecuteCommandAction.player_uuid) return _internal_player_uuid(); } template -PROTOBUF_ALWAYS_INLINE void SetHeldItemAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void ExecuteCommandAction::set_player_uuid(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetHeldItemAction.player_uuid) + // @@protoc_insertion_point(field_set:df.plugin.ExecuteCommandAction.player_uuid) } -inline ::std::string* PROTOBUF_NONNULL SetHeldItemAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::mutable_player_uuid() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.player_uuid) + // @@protoc_insertion_point(field_mutable:df.plugin.ExecuteCommandAction.player_uuid) return _s; } -inline const ::std::string& SetHeldItemAction::_internal_player_uuid() const { +inline const ::std::string& ExecuteCommandAction::_internal_player_uuid() const { ::google::protobuf::internal::TSanRead(&_impl_); return _impl_.player_uuid_.Get(); } -inline void SetHeldItemAction::_internal_set_player_uuid(const ::std::string& value) { +inline void ExecuteCommandAction::_internal_set_player_uuid(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.player_uuid_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::_internal_mutable_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); return _impl_.player_uuid_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE SetHeldItemAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE ExecuteCommandAction::release_player_uuid() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.ExecuteCommandAction.player_uuid) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } @@ -7475,7 +14065,7 @@ inline ::std::string* PROTOBUF_NULLABLE SetHeldItemAction::release_player_uuid() } return released; } -inline void SetHeldItemAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void ExecuteCommandAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); @@ -7486,137 +14076,113 @@ inline void SetHeldItemAction::set_allocated_player_uuid(::std::string* PROTOBUF if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { _impl_.player_uuid_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.ExecuteCommandAction.player_uuid) } -// optional .df.plugin.ItemStack main = 2 [json_name = "main"]; -inline bool SetHeldItemAction::has_main() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.main_ != nullptr); - return value; -} -inline const ::df::plugin::ItemStack& SetHeldItemAction::_internal_main() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::ItemStack* p = _impl_.main_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); +// string command = 2 [json_name = "command"]; +inline void ExecuteCommandAction::clear_command() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.command_.ClearToEmpty(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); } -inline const ::df::plugin::ItemStack& SetHeldItemAction::main() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.main) - return _internal_main(); +inline const ::std::string& ExecuteCommandAction::command() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ExecuteCommandAction.command) + return _internal_command(); } -inline void SetHeldItemAction::unsafe_arena_set_allocated_main( - ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { +template +PROTOBUF_ALWAYS_INLINE void ExecuteCommandAction::set_command(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.main_); - } - _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetHeldItemAction.main) + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + _impl_.command_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.ExecuteCommandAction.command) } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::release_main() { +inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::mutable_command() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::std::string* _s = _internal_mutable_command(); + // @@protoc_insertion_point(field_mutable:df.plugin.ExecuteCommandAction.command) + return _s; +} +inline const ::std::string& ExecuteCommandAction::_internal_command() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.command_.Get(); +} +inline void ExecuteCommandAction::_internal_set_command(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* released = _impl_.main_; - _impl_.main_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; + _impl_.command_.Set(value, GetArena()); } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::unsafe_arena_release_main() { +inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::_internal_mutable_command() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.main) - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* temp = _impl_.main_; - _impl_.main_ = nullptr; - return temp; + return _impl_.command_.Mutable( GetArena()); } -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_main() { +inline ::std::string* PROTOBUF_NULLABLE ExecuteCommandAction::release_command() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.main_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); - _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(p); + // @@protoc_insertion_point(field_release:df.plugin.ExecuteCommandAction.command) + if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + return nullptr; } - return _impl_.main_; -} -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::mutable_main() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::ItemStack* _msg = _internal_mutable_main(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.main) - return _msg; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + auto* released = _impl_.command_.Release(); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { + _impl_.command_.Set("", GetArena()); + } + return released; } -inline void SetHeldItemAction::set_allocated_main(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); +inline void ExecuteCommandAction::set_allocated_command(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.main_); - } - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - - _impl_.main_ = reinterpret_cast<::df::plugin::ItemStack*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.main) + _impl_.command_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.command_.IsDefault()) { + _impl_.command_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.ExecuteCommandAction.command) } -// optional .df.plugin.ItemStack offhand = 3 [json_name = "offhand"]; -inline bool SetHeldItemAction::has_offhand() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); - PROTOBUF_ASSUME(!value || _impl_.offhand_ != nullptr); +// ------------------------------------------------------------------- + +// WorldSetDefaultGameModeAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldSetDefaultGameModeAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); return value; } -inline const ::df::plugin::ItemStack& SetHeldItemAction::_internal_offhand() const { +inline const ::df::plugin::WorldRef& WorldSetDefaultGameModeAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::ItemStack* p = _impl_.offhand_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ItemStack_default_instance_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline const ::df::plugin::ItemStack& SetHeldItemAction::offhand() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetHeldItemAction.offhand) - return _internal_offhand(); +inline const ::df::plugin::WorldRef& WorldSetDefaultGameModeAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetDefaultGameModeAction.world) + return _internal_world(); } -inline void SetHeldItemAction::unsafe_arena_set_allocated_offhand( - ::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { +inline void WorldSetDefaultGameModeAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.offhand_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } - _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(value); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetHeldItemAction.offhand) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetDefaultGameModeAction.world) } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::release_offhand() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetDefaultGameModeAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::ItemStack* released = _impl_.offhand_; - _impl_.offhand_ = nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); @@ -7630,35 +14196,35 @@ inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::release_off } return released; } -inline ::df::plugin::ItemStack* PROTOBUF_NULLABLE SetHeldItemAction::unsafe_arena_release_offhand() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetDefaultGameModeAction::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetHeldItemAction.offhand) + // @@protoc_insertion_point(field_release:df.plugin.WorldSetDefaultGameModeAction.world) - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::ItemStack* temp = _impl_.offhand_; - _impl_.offhand_ = nullptr; + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; return temp; } -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::_internal_mutable_offhand() { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetDefaultGameModeAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.offhand_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ItemStack>(GetArena()); - _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(p); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); } - return _impl_.offhand_; + return _impl_.world_; } -inline ::df::plugin::ItemStack* PROTOBUF_NONNULL SetHeldItemAction::mutable_offhand() +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetDefaultGameModeAction::mutable_world() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::ItemStack* _msg = _internal_mutable_offhand(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetHeldItemAction.offhand) + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetDefaultGameModeAction.world) return _msg; } -inline void SetHeldItemAction::set_allocated_offhand(::df::plugin::ItemStack* PROTOBUF_NULLABLE value) { +inline void WorldSetDefaultGameModeAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.offhand_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } if (value != nullptr) { @@ -7666,492 +14232,724 @@ inline void SetHeldItemAction::set_allocated_offhand(::df::plugin::ItemStack* PR if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[0], 0x00000004U); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.offhand_ = reinterpret_cast<::df::plugin::ItemStack*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHeldItemAction.offhand) + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetDefaultGameModeAction.world) } -// ------------------------------------------------------------------- - -// SetHealthAction - -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetHealthAction::clear_player_uuid() { +// .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; +inline void WorldSetDefaultGameModeAction::clear_game_mode() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); + _impl_.game_mode_ = 0; ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + 0x00000002U); } -inline const ::std::string& SetHealthAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.player_uuid) - return _internal_player_uuid(); +inline ::df::plugin::GameMode WorldSetDefaultGameModeAction::game_mode() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetDefaultGameModeAction.game_mode) + return _internal_game_mode(); } -template -PROTOBUF_ALWAYS_INLINE void SetHealthAction::set_player_uuid(Arg_&& arg, Args_... args) { +inline void WorldSetDefaultGameModeAction::set_game_mode(::df::plugin::GameMode value) { + _internal_set_game_mode(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.WorldSetDefaultGameModeAction.game_mode) +} +inline ::df::plugin::GameMode WorldSetDefaultGameModeAction::_internal_game_mode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::GameMode>(_impl_.game_mode_); +} +inline void WorldSetDefaultGameModeAction::_internal_set_game_mode(::df::plugin::GameMode value) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.player_uuid) + _impl_.game_mode_ = value; } -inline ::std::string* PROTOBUF_NONNULL SetHealthAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetHealthAction.player_uuid) - return _s; + +// ------------------------------------------------------------------- + +// WorldSetDifficultyAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldSetDifficultyAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& SetHealthAction::_internal_player_uuid() const { +inline const ::df::plugin::WorldRef& WorldSetDifficultyAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); +} +inline const ::df::plugin::WorldRef& WorldSetDifficultyAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetDifficultyAction.world) + return _internal_world(); +} +inline void WorldSetDifficultyAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetDifficultyAction.world) } -inline void SetHealthAction::_internal_set_player_uuid(const ::std::string& value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetDifficultyAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline ::std::string* PROTOBUF_NONNULL SetHealthAction::_internal_mutable_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetDifficultyAction::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + // @@protoc_insertion_point(field_release:df.plugin.WorldSetDifficultyAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -inline ::std::string* PROTOBUF_NULLABLE SetHealthAction::release_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetDifficultyAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetHealthAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); } - return released; + return _impl_.world_; } -inline void SetHealthAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetDifficultyAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetDifficultyAction.world) + return _msg; +} +inline void WorldSetDifficultyAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetHealthAction.player_uuid) + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetDifficultyAction.world) } -// double health = 2 [json_name = "health"]; -inline void SetHealthAction::clear_health() { +// .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; +inline void WorldSetDifficultyAction::clear_difficulty() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.health_ = 0; + _impl_.difficulty_ = 0; ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline double SetHealthAction::health() const { - // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.health) - return _internal_health(); +inline ::df::plugin::Difficulty WorldSetDifficultyAction::difficulty() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetDifficultyAction.difficulty) + return _internal_difficulty(); } -inline void SetHealthAction::set_health(double value) { - _internal_set_health(value); +inline void WorldSetDifficultyAction::set_difficulty(::df::plugin::Difficulty value) { + _internal_set_difficulty(value); SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.health) + // @@protoc_insertion_point(field_set:df.plugin.WorldSetDifficultyAction.difficulty) } -inline double SetHealthAction::_internal_health() const { +inline ::df::plugin::Difficulty WorldSetDifficultyAction::_internal_difficulty() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.health_; + return static_cast<::df::plugin::Difficulty>(_impl_.difficulty_); } -inline void SetHealthAction::_internal_set_health(double value) { +inline void WorldSetDifficultyAction::_internal_set_difficulty(::df::plugin::Difficulty value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.health_ = value; + _impl_.difficulty_ = value; } -// optional double max_health = 3 [json_name = "maxHealth"]; -inline bool SetHealthAction::has_max_health() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); +// ------------------------------------------------------------------- + +// WorldSetTickRangeAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldSetTickRangeAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); return value; } -inline void SetHealthAction::clear_max_health() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.max_health_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); -} -inline double SetHealthAction::max_health() const { - // @@protoc_insertion_point(field_get:df.plugin.SetHealthAction.max_health) - return _internal_max_health(); -} -inline void SetHealthAction::set_max_health(double value) { - _internal_set_max_health(value); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - // @@protoc_insertion_point(field_set:df.plugin.SetHealthAction.max_health) -} -inline double SetHealthAction::_internal_max_health() const { +inline const ::df::plugin::WorldRef& WorldSetTickRangeAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.max_health_; + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline void SetHealthAction::_internal_set_max_health(double value) { +inline const ::df::plugin::WorldRef& WorldSetTickRangeAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetTickRangeAction.world) + return _internal_world(); +} +inline void WorldSetTickRangeAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.max_health_ = value; + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetTickRangeAction.world) } - -// ------------------------------------------------------------------- - -// SetFoodAction - -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetFoodAction::clear_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetTickRangeAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline const ::std::string& SetFoodAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetFoodAction.player_uuid) - return _internal_player_uuid(); +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetTickRangeAction::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldSetTickRangeAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -template -PROTOBUF_ALWAYS_INLINE void SetFoodAction::set_player_uuid(Arg_&& arg, Args_... args) { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetTickRangeAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetFoodAction.player_uuid) + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline ::std::string* PROTOBUF_NONNULL SetFoodAction::mutable_player_uuid() +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetTickRangeAction::mutable_world() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetFoodAction.player_uuid) - return _s; -} -inline const ::std::string& SetFoodAction::_internal_player_uuid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); -} -inline void SetFoodAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); -} -inline ::std::string* PROTOBUF_NONNULL SetFoodAction::_internal_mutable_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetTickRangeAction.world) + return _msg; } -inline ::std::string* PROTOBUF_NULLABLE SetFoodAction::release_player_uuid() { +inline void WorldSetTickRangeAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetFoodAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } - return released; -} -inline void SetFoodAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetFoodAction.player_uuid) + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetTickRangeAction.world) } -// int32 food = 2 [json_name = "food"]; -inline void SetFoodAction::clear_food() { +// int32 tick_range = 2 [json_name = "tickRange"]; +inline void WorldSetTickRangeAction::clear_tick_range() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.food_ = 0; + _impl_.tick_range_ = 0; ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline ::int32_t SetFoodAction::food() const { - // @@protoc_insertion_point(field_get:df.plugin.SetFoodAction.food) - return _internal_food(); +inline ::int32_t WorldSetTickRangeAction::tick_range() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetTickRangeAction.tick_range) + return _internal_tick_range(); } -inline void SetFoodAction::set_food(::int32_t value) { - _internal_set_food(value); +inline void WorldSetTickRangeAction::set_tick_range(::int32_t value) { + _internal_set_tick_range(value); SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.SetFoodAction.food) + // @@protoc_insertion_point(field_set:df.plugin.WorldSetTickRangeAction.tick_range) } -inline ::int32_t SetFoodAction::_internal_food() const { +inline ::int32_t WorldSetTickRangeAction::_internal_tick_range() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.food_; + return _impl_.tick_range_; } -inline void SetFoodAction::_internal_set_food(::int32_t value) { +inline void WorldSetTickRangeAction::_internal_set_tick_range(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.food_ = value; + _impl_.tick_range_ = value; } // ------------------------------------------------------------------- -// SetExperienceAction +// WorldSetBlockAction -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetExperienceAction::clear_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -inline const ::std::string& SetExperienceAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.player_uuid) - return _internal_player_uuid(); -} -template -PROTOBUF_ALWAYS_INLINE void SetExperienceAction::set_player_uuid(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.player_uuid) -} -inline ::std::string* PROTOBUF_NONNULL SetExperienceAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetExperienceAction.player_uuid) - return _s; +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldSetBlockAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& SetExperienceAction::_internal_player_uuid() const { +inline const ::df::plugin::WorldRef& WorldSetBlockAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline void SetExperienceAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); +inline const ::df::plugin::WorldRef& WorldSetBlockAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetBlockAction.world) + return _internal_world(); } -inline ::std::string* PROTOBUF_NONNULL SetExperienceAction::_internal_mutable_player_uuid() { +inline void WorldSetBlockAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetBlockAction.world) } -inline ::std::string* PROTOBUF_NULLABLE SetExperienceAction::release_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetBlockAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetExperienceAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } + return released; +} +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldSetBlockAction::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldSetBlockAction.world) + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetBlockAction::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); } - return released; + return _impl_.world_; } -inline void SetExperienceAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldSetBlockAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetBlockAction.world) + return _msg; +} +inline void WorldSetBlockAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetExperienceAction.player_uuid) + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetBlockAction.world) } -// optional int32 level = 2 [json_name = "level"]; -inline bool SetExperienceAction::has_level() const { +// .df.plugin.BlockPos position = 2 [json_name = "position"]; +inline bool WorldSetBlockAction::has_position() const { bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); return value; } -inline void SetExperienceAction::clear_level() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.level_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); -} -inline ::int32_t SetExperienceAction::level() const { - // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.level) - return _internal_level(); -} -inline void SetExperienceAction::set_level(::int32_t value) { - _internal_set_level(value); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.level) -} -inline ::int32_t SetExperienceAction::_internal_level() const { +inline const ::df::plugin::BlockPos& WorldSetBlockAction::_internal_position() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.level_; + const ::df::plugin::BlockPos* p = _impl_.position_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_BlockPos_default_instance_); } -inline void SetExperienceAction::_internal_set_level(::int32_t value) { +inline const ::df::plugin::BlockPos& WorldSetBlockAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetBlockAction.position) + return _internal_position(); +} +inline void WorldSetBlockAction::unsafe_arena_set_allocated_position( + ::df::plugin::BlockPos* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.level_ = value; + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + _impl_.position_ = reinterpret_cast<::df::plugin::BlockPos*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetBlockAction.position) } +inline ::df::plugin::BlockPos* PROTOBUF_NULLABLE WorldSetBlockAction::release_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); -// optional float progress = 3 [json_name = "progress"]; -inline bool SetExperienceAction::has_progress() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); - return value; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::BlockPos* released = _impl_.position_; + _impl_.position_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline void SetExperienceAction::clear_progress() { +inline ::df::plugin::BlockPos* PROTOBUF_NULLABLE WorldSetBlockAction::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.progress_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); -} -inline float SetExperienceAction::progress() const { - // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.progress) - return _internal_progress(); + // @@protoc_insertion_point(field_release:df.plugin.WorldSetBlockAction.position) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::BlockPos* temp = _impl_.position_; + _impl_.position_ = nullptr; + return temp; } -inline void SetExperienceAction::set_progress(float value) { - _internal_set_progress(value); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.progress) +inline ::df::plugin::BlockPos* PROTOBUF_NONNULL WorldSetBlockAction::_internal_mutable_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BlockPos>(GetArena()); + _impl_.position_ = reinterpret_cast<::df::plugin::BlockPos*>(p); + } + return _impl_.position_; } -inline float SetExperienceAction::_internal_progress() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.progress_; +inline ::df::plugin::BlockPos* PROTOBUF_NONNULL WorldSetBlockAction::mutable_position() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::BlockPos* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetBlockAction.position) + return _msg; } -inline void SetExperienceAction::_internal_set_progress(float value) { +inline void WorldSetBlockAction::set_allocated_position(::df::plugin::BlockPos* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.progress_ = value; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.position_ = reinterpret_cast<::df::plugin::BlockPos*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetBlockAction.position) } -// optional int32 amount = 4 [json_name = "amount"]; -inline bool SetExperienceAction::has_amount() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); +// optional .df.plugin.BlockState block = 3 [json_name = "block"]; +inline bool WorldSetBlockAction::has_block() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + PROTOBUF_ASSUME(!value || _impl_.block_ != nullptr); return value; } -inline void SetExperienceAction::clear_amount() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.amount_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000008U); -} -inline ::int32_t SetExperienceAction::amount() const { - // @@protoc_insertion_point(field_get:df.plugin.SetExperienceAction.amount) - return _internal_amount(); -} -inline void SetExperienceAction::set_amount(::int32_t value) { - _internal_set_amount(value); - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - // @@protoc_insertion_point(field_set:df.plugin.SetExperienceAction.amount) -} -inline ::int32_t SetExperienceAction::_internal_amount() const { +inline const ::df::plugin::BlockState& WorldSetBlockAction::_internal_block() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.amount_; + const ::df::plugin::BlockState* p = _impl_.block_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_BlockState_default_instance_); } -inline void SetExperienceAction::_internal_set_amount(::int32_t value) { +inline const ::df::plugin::BlockState& WorldSetBlockAction::block() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldSetBlockAction.block) + return _internal_block(); +} +inline void WorldSetBlockAction::unsafe_arena_set_allocated_block( + ::df::plugin::BlockState* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.amount_ = value; + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_); + } + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldSetBlockAction.block) } +inline ::df::plugin::BlockState* PROTOBUF_NULLABLE WorldSetBlockAction::release_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); -// ------------------------------------------------------------------- - -// SetVelocityAction + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* released = _impl_.block_; + _impl_.block_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::BlockState* PROTOBUF_NULLABLE WorldSetBlockAction::unsafe_arena_release_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldSetBlockAction.block) -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SetVelocityAction::clear_player_uuid() { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* temp = _impl_.block_; + _impl_.block_ = nullptr; + return temp; +} +inline ::df::plugin::BlockState* PROTOBUF_NONNULL WorldSetBlockAction::_internal_mutable_block() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + if (_impl_.block_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BlockState>(GetArena()); + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(p); + } + return _impl_.block_; } -inline const ::std::string& SetVelocityAction::player_uuid() const +inline ::df::plugin::BlockState* PROTOBUF_NONNULL WorldSetBlockAction::mutable_block() ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetVelocityAction.player_uuid) - return _internal_player_uuid(); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* _msg = _internal_mutable_block(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldSetBlockAction.block) + return _msg; } -template -PROTOBUF_ALWAYS_INLINE void SetVelocityAction::set_player_uuid(Arg_&& arg, Args_... args) { +inline void WorldSetBlockAction::set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SetVelocityAction.player_uuid) + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldSetBlockAction.block) } -inline ::std::string* PROTOBUF_NONNULL SetVelocityAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetVelocityAction.player_uuid) - return _s; + +// ------------------------------------------------------------------- + +// WorldPlaySoundAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldPlaySoundAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& SetVelocityAction::_internal_player_uuid() const { +inline const ::df::plugin::WorldRef& WorldPlaySoundAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline void SetVelocityAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); +inline const ::df::plugin::WorldRef& WorldPlaySoundAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldPlaySoundAction.world) + return _internal_world(); } -inline ::std::string* PROTOBUF_NONNULL SetVelocityAction::_internal_mutable_player_uuid() { +inline void WorldPlaySoundAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldPlaySoundAction.world) } -inline ::std::string* PROTOBUF_NULLABLE SetVelocityAction::release_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldPlaySoundAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetVelocityAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } return released; } -inline void SetVelocityAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldPlaySoundAction::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldPlaySoundAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldPlaySoundAction::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldPlaySoundAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldPlaySoundAction.world) + return _msg; +} +inline void WorldPlaySoundAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetVelocityAction.player_uuid) + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldPlaySoundAction.world) } -// .df.plugin.Vec3 velocity = 2 [json_name = "velocity"]; -inline bool SetVelocityAction::has_velocity() const { +// .df.plugin.Sound sound = 2 [json_name = "sound"]; +inline void WorldPlaySoundAction::clear_sound() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sound_ = 0; + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +inline ::df::plugin::Sound WorldPlaySoundAction::sound() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldPlaySoundAction.sound) + return _internal_sound(); +} +inline void WorldPlaySoundAction::set_sound(::df::plugin::Sound value) { + _internal_set_sound(value); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + // @@protoc_insertion_point(field_set:df.plugin.WorldPlaySoundAction.sound) +} +inline ::df::plugin::Sound WorldPlaySoundAction::_internal_sound() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return static_cast<::df::plugin::Sound>(_impl_.sound_); +} +inline void WorldPlaySoundAction::_internal_set_sound(::df::plugin::Sound value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sound_ = value; +} + +// .df.plugin.Vec3 position = 3 [json_name = "position"]; +inline bool WorldPlaySoundAction::has_position() const { bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.velocity_ != nullptr); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); return value; } -inline const ::df::plugin::Vec3& SetVelocityAction::_internal_velocity() const { +inline const ::df::plugin::Vec3& WorldPlaySoundAction::_internal_position() const { ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::Vec3* p = _impl_.velocity_; + const ::df::plugin::Vec3* p = _impl_.position_; return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); } -inline const ::df::plugin::Vec3& SetVelocityAction::velocity() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SetVelocityAction.velocity) - return _internal_velocity(); +inline const ::df::plugin::Vec3& WorldPlaySoundAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldPlaySoundAction.position) + return _internal_position(); } -inline void SetVelocityAction::unsafe_arena_set_allocated_velocity( +inline void WorldPlaySoundAction::unsafe_arena_set_allocated_position( ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.velocity_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); } - _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(value); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.SetVelocityAction.velocity) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldPlaySoundAction.position) } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE SetVelocityAction::release_velocity() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldPlaySoundAction::release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* released = _impl_.velocity_; - _impl_.velocity_ = nullptr; + ::df::plugin::Vec3* released = _impl_.position_; + _impl_.position_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); released = ::google::protobuf::internal::DuplicateIfNonNull(released); @@ -8165,35 +14963,35 @@ inline ::df::plugin::Vec3* PROTOBUF_NULLABLE SetVelocityAction::release_velocity } return released; } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE SetVelocityAction::unsafe_arena_release_velocity() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldPlaySoundAction::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SetVelocityAction.velocity) + // @@protoc_insertion_point(field_release:df.plugin.WorldPlaySoundAction.position) ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* temp = _impl_.velocity_; - _impl_.velocity_ = nullptr; + ::df::plugin::Vec3* temp = _impl_.position_; + _impl_.position_ = nullptr; return temp; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL SetVelocityAction::_internal_mutable_velocity() { +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldPlaySoundAction::_internal_mutable_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.velocity_ == nullptr) { + if (_impl_.position_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); - _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(p); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); } - return _impl_.velocity_; + return _impl_.position_; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL SetVelocityAction::mutable_velocity() +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldPlaySoundAction::mutable_position() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* _msg = _internal_mutable_velocity(); - // @@protoc_insertion_point(field_mutable:df.plugin.SetVelocityAction.velocity) + ::df::plugin::Vec3* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldPlaySoundAction.position) return _msg; } -inline void SetVelocityAction::set_allocated_velocity(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { +inline void WorldPlaySoundAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.velocity_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); } if (value != nullptr) { @@ -8206,941 +15004,1666 @@ inline void SetVelocityAction::set_allocated_velocity(::df::plugin::Vec3* PROTOB ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.velocity_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.SetVelocityAction.velocity) + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldPlaySoundAction.position) } // ------------------------------------------------------------------- -// AddEffectAction +// WorldAddParticleAction -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void AddEffectAction::clear_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -inline const ::std::string& AddEffectAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.player_uuid) - return _internal_player_uuid(); -} -template -PROTOBUF_ALWAYS_INLINE void AddEffectAction::set_player_uuid(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.player_uuid) -} -inline ::std::string* PROTOBUF_NONNULL AddEffectAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.AddEffectAction.player_uuid) - return _s; +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldAddParticleAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& AddEffectAction::_internal_player_uuid() const { +inline const ::df::plugin::WorldRef& WorldAddParticleAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline void AddEffectAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); +inline const ::df::plugin::WorldRef& WorldAddParticleAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldAddParticleAction.world) + return _internal_world(); } -inline ::std::string* PROTOBUF_NONNULL AddEffectAction::_internal_mutable_player_uuid() { +inline void WorldAddParticleAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldAddParticleAction.world) } -inline ::std::string* PROTOBUF_NULLABLE AddEffectAction::release_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldAddParticleAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.AddEffectAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } return released; } -inline void AddEffectAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldAddParticleAction::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldAddParticleAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldAddParticleAction::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldAddParticleAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldAddParticleAction.world) + return _msg; +} +inline void WorldAddParticleAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldAddParticleAction.world) +} + +// .df.plugin.Vec3 position = 2 [json_name = "position"]; +inline bool WorldAddParticleAction::has_position() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); + return value; +} +inline const ::df::plugin::Vec3& WorldAddParticleAction::_internal_position() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.position_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +} +inline const ::df::plugin::Vec3& WorldAddParticleAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldAddParticleAction.position) + return _internal_position(); +} +inline void WorldAddParticleAction::unsafe_arena_set_allocated_position( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.AddEffectAction.player_uuid) + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldAddParticleAction.position) } +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldAddParticleAction::release_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); -// .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; -inline void AddEffectAction::clear_effect_type() { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* released = _impl_.position_; + _impl_.position_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldAddParticleAction::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.effect_type_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + // @@protoc_insertion_point(field_release:df.plugin.WorldAddParticleAction.position) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* temp = _impl_.position_; + _impl_.position_ = nullptr; + return temp; } -inline ::df::plugin::EffectType AddEffectAction::effect_type() const { - // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.effect_type) - return _internal_effect_type(); +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldAddParticleAction::_internal_mutable_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.position_; } -inline void AddEffectAction::set_effect_type(::df::plugin::EffectType value) { - _internal_set_effect_type(value); +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldAddParticleAction::mutable_position() + ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.effect_type) -} -inline ::df::plugin::EffectType AddEffectAction::_internal_effect_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::df::plugin::EffectType>(_impl_.effect_type_); + ::df::plugin::Vec3* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldAddParticleAction.position) + return _msg; } -inline void AddEffectAction::_internal_set_effect_type(::df::plugin::EffectType value) { +inline void WorldAddParticleAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.effect_type_ = value; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldAddParticleAction.position) } -// int32 level = 3 [json_name = "level"]; -inline void AddEffectAction::clear_level() { +// .df.plugin.ParticleType particle = 3 [json_name = "particle"]; +inline void WorldAddParticleAction::clear_particle() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.level_ = 0; + _impl_.particle_ = 0; ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); + 0x00000008U); } -inline ::int32_t AddEffectAction::level() const { - // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.level) - return _internal_level(); +inline ::df::plugin::ParticleType WorldAddParticleAction::particle() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldAddParticleAction.particle) + return _internal_particle(); } -inline void AddEffectAction::set_level(::int32_t value) { - _internal_set_level(value); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.level) +inline void WorldAddParticleAction::set_particle(::df::plugin::ParticleType value) { + _internal_set_particle(value); + SetHasBit(_impl_._has_bits_[0], 0x00000008U); + // @@protoc_insertion_point(field_set:df.plugin.WorldAddParticleAction.particle) } -inline ::int32_t AddEffectAction::_internal_level() const { +inline ::df::plugin::ParticleType WorldAddParticleAction::_internal_particle() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.level_; + return static_cast<::df::plugin::ParticleType>(_impl_.particle_); } -inline void AddEffectAction::_internal_set_level(::int32_t value) { +inline void WorldAddParticleAction::_internal_set_particle(::df::plugin::ParticleType value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.level_ = value; + _impl_.particle_ = value; } -// int64 duration_ms = 4 [json_name = "durationMs"]; -inline void AddEffectAction::clear_duration_ms() { +// optional .df.plugin.BlockState block = 4 [json_name = "block"]; +inline bool WorldAddParticleAction::has_block() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + PROTOBUF_ASSUME(!value || _impl_.block_ != nullptr); + return value; +} +inline const ::df::plugin::BlockState& WorldAddParticleAction::_internal_block() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::BlockState* p = _impl_.block_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_BlockState_default_instance_); +} +inline const ::df::plugin::BlockState& WorldAddParticleAction::block() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldAddParticleAction.block) + return _internal_block(); +} +inline void WorldAddParticleAction::unsafe_arena_set_allocated_block( + ::df::plugin::BlockState* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.duration_ms_ = ::int64_t{0}; - ClearHasBit(_impl_._has_bits_[0], - 0x00000008U); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_); + } + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldAddParticleAction.block) } -inline ::int64_t AddEffectAction::duration_ms() const { - // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.duration_ms) - return _internal_duration_ms(); +inline ::df::plugin::BlockState* PROTOBUF_NULLABLE WorldAddParticleAction::release_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* released = _impl_.block_; + _impl_.block_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline void AddEffectAction::set_duration_ms(::int64_t value) { - _internal_set_duration_ms(value); - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.duration_ms) +inline ::df::plugin::BlockState* PROTOBUF_NULLABLE WorldAddParticleAction::unsafe_arena_release_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldAddParticleAction.block) + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* temp = _impl_.block_; + _impl_.block_ = nullptr; + return temp; } -inline ::int64_t AddEffectAction::_internal_duration_ms() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.duration_ms_; +inline ::df::plugin::BlockState* PROTOBUF_NONNULL WorldAddParticleAction::_internal_mutable_block() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.block_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BlockState>(GetArena()); + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(p); + } + return _impl_.block_; } -inline void AddEffectAction::_internal_set_duration_ms(::int64_t value) { +inline ::df::plugin::BlockState* PROTOBUF_NONNULL WorldAddParticleAction::mutable_block() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BlockState* _msg = _internal_mutable_block(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldAddParticleAction.block) + return _msg; +} +inline void WorldAddParticleAction::set_allocated_block(::df::plugin::BlockState* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.duration_ms_ = value; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.block_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + + _impl_.block_ = reinterpret_cast<::df::plugin::BlockState*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldAddParticleAction.block) } -// bool show_particles = 5 [json_name = "showParticles"]; -inline void AddEffectAction::clear_show_particles() { +// optional int32 face = 5 [json_name = "face"]; +inline bool WorldAddParticleAction::has_face() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); + return value; +} +inline void WorldAddParticleAction::clear_face() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.show_particles_ = false; + _impl_.face_ = 0; ClearHasBit(_impl_._has_bits_[0], 0x00000010U); } -inline bool AddEffectAction::show_particles() const { - // @@protoc_insertion_point(field_get:df.plugin.AddEffectAction.show_particles) - return _internal_show_particles(); +inline ::int32_t WorldAddParticleAction::face() const { + // @@protoc_insertion_point(field_get:df.plugin.WorldAddParticleAction.face) + return _internal_face(); } -inline void AddEffectAction::set_show_particles(bool value) { - _internal_set_show_particles(value); +inline void WorldAddParticleAction::set_face(::int32_t value) { + _internal_set_face(value); SetHasBit(_impl_._has_bits_[0], 0x00000010U); - // @@protoc_insertion_point(field_set:df.plugin.AddEffectAction.show_particles) + // @@protoc_insertion_point(field_set:df.plugin.WorldAddParticleAction.face) } -inline bool AddEffectAction::_internal_show_particles() const { +inline ::int32_t WorldAddParticleAction::_internal_face() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.show_particles_; + return _impl_.face_; } -inline void AddEffectAction::_internal_set_show_particles(bool value) { +inline void WorldAddParticleAction::_internal_set_face(::int32_t value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.show_particles_ = value; + _impl_.face_ = value; } // ------------------------------------------------------------------- -// RemoveEffectAction +// WorldQueryEntitiesAction -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void RemoveEffectAction::clear_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldQueryEntitiesAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& RemoveEffectAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.RemoveEffectAction.player_uuid) - return _internal_player_uuid(); +inline const ::df::plugin::WorldRef& WorldQueryEntitiesAction::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -template -PROTOBUF_ALWAYS_INLINE void RemoveEffectAction::set_player_uuid(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.RemoveEffectAction.player_uuid) +inline const ::df::plugin::WorldRef& WorldQueryEntitiesAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryEntitiesAction.world) + return _internal_world(); } -inline ::std::string* PROTOBUF_NONNULL RemoveEffectAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.RemoveEffectAction.player_uuid) - return _s; +inline void WorldQueryEntitiesAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryEntitiesAction.world) } -inline const ::std::string& RemoveEffectAction::_internal_player_uuid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryEntitiesAction::release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline void RemoveEffectAction::_internal_set_player_uuid(const ::std::string& value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryEntitiesAction::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryEntitiesAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -inline ::std::string* PROTOBUF_NONNULL RemoveEffectAction::_internal_mutable_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryEntitiesAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline ::std::string* PROTOBUF_NULLABLE RemoveEffectAction::release_player_uuid() { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryEntitiesAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryEntitiesAction.world) + return _msg; +} +inline void WorldQueryEntitiesAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.RemoveEffectAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - return released; + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryEntitiesAction.world) } -inline void RemoveEffectAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { + +// ------------------------------------------------------------------- + +// WorldQueryPlayersAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldQueryPlayersAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; +} +inline const ::df::plugin::WorldRef& WorldQueryPlayersAction::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); +} +inline const ::df::plugin::WorldRef& WorldQueryPlayersAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryPlayersAction.world) + return _internal_world(); +} +inline void WorldQueryPlayersAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.RemoveEffectAction.player_uuid) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryPlayersAction.world) } - -// .df.plugin.EffectType effect_type = 2 [json_name = "effectType"]; -inline void RemoveEffectAction::clear_effect_type() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryPlayersAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.effect_type_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline ::df::plugin::EffectType RemoveEffectAction::effect_type() const { - // @@protoc_insertion_point(field_get:df.plugin.RemoveEffectAction.effect_type) - return _internal_effect_type(); +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryPlayersAction::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryPlayersAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -inline void RemoveEffectAction::set_effect_type(::df::plugin::EffectType value) { - _internal_set_effect_type(value); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - // @@protoc_insertion_point(field_set:df.plugin.RemoveEffectAction.effect_type) +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryPlayersAction::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline ::df::plugin::EffectType RemoveEffectAction::_internal_effect_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::df::plugin::EffectType>(_impl_.effect_type_); +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryPlayersAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryPlayersAction.world) + return _msg; } -inline void RemoveEffectAction::_internal_set_effect_type(::df::plugin::EffectType value) { +inline void WorldQueryPlayersAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.effect_type_ = value; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryPlayersAction.world) } // ------------------------------------------------------------------- -// SendTitleAction +// WorldQueryEntitiesWithinAction -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SendTitleAction::clear_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -inline const ::std::string& SendTitleAction::player_uuid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.player_uuid) - return _internal_player_uuid(); -} -template -PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_player_uuid(Arg_&& arg, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.player_uuid) -} -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.player_uuid) - return _s; +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldQueryEntitiesWithinAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline const ::std::string& SendTitleAction::_internal_player_uuid() const { +inline const ::df::plugin::WorldRef& WorldQueryEntitiesWithinAction::_internal_world() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); -} -inline void SendTitleAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); +inline const ::df::plugin::WorldRef& WorldQueryEntitiesWithinAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryEntitiesWithinAction.world) + return _internal_world(); } -inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_player_uuid() { +inline void WorldQueryEntitiesWithinAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } - return released; -} -inline void SendTitleAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.world) +} +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryEntitiesWithinAction::release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.player_uuid) + return released; } +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryEntitiesWithinAction::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryEntitiesWithinAction.world) -// string title = 2 [json_name = "title"]; -inline void SendTitleAction::clear_title() { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.title_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline const ::std::string& SendTitleAction::title() const +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::mutable_world() ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.title) - return _internal_title(); + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryEntitiesWithinAction.world) + return _msg; } -template -PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_title(Arg_&& arg, Args_... args) { +inline void WorldQueryEntitiesWithinAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.title_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.title) + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.world) } -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_title() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_title(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.title) - return _s; + +// .df.plugin.BBox box = 2 [json_name = "box"]; +inline bool WorldQueryEntitiesWithinAction::has_box() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.box_ != nullptr); + return value; } -inline const ::std::string& SendTitleAction::_internal_title() const { +inline const ::df::plugin::BBox& WorldQueryEntitiesWithinAction::_internal_box() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.title_.Get(); + const ::df::plugin::BBox* p = _impl_.box_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_BBox_default_instance_); } -inline void SendTitleAction::_internal_set_title(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.title_.Set(value, GetArena()); +inline const ::df::plugin::BBox& WorldQueryEntitiesWithinAction::box() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryEntitiesWithinAction.box) + return _internal_box(); } -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_title() { +inline void WorldQueryEntitiesWithinAction::unsafe_arena_set_allocated_box( + ::df::plugin::BBox* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.title_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); + } + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.box) } -inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_title() { +inline ::df::plugin::BBox* PROTOBUF_NULLABLE WorldQueryEntitiesWithinAction::release_box() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.title) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { - return nullptr; - } + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.title_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.title_.Set("", GetArena()); + ::df::plugin::BBox* released = _impl_.box_; + _impl_.box_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } return released; } -inline void SendTitleAction::set_allocated_title(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::BBox* PROTOBUF_NULLABLE WorldQueryEntitiesWithinAction::unsafe_arena_release_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryEntitiesWithinAction.box) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::BBox* temp = _impl_.box_; + _impl_.box_ = nullptr; + return temp; +} +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_internal_mutable_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.box_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BBox>(GetArena()); + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(p); + } + return _impl_.box_; +} +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::mutable_box() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::BBox* _msg = _internal_mutable_box(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryEntitiesWithinAction.box) + return _msg; +} +inline void WorldQueryEntitiesWithinAction::set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.title_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.title_.IsDefault()) { - _impl_.title_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.title) + + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.box) } -// optional string subtitle = 3 [json_name = "subtitle"]; -inline bool SendTitleAction::has_subtitle() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); +// ------------------------------------------------------------------- + +// WorldQueryViewersAction + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldQueryViewersAction::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); return value; } -inline void SendTitleAction::clear_subtitle() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.subtitle_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); +inline const ::df::plugin::WorldRef& WorldQueryViewersAction::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline const ::std::string& SendTitleAction::subtitle() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.subtitle) - return _internal_subtitle(); +inline const ::df::plugin::WorldRef& WorldQueryViewersAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryViewersAction.world) + return _internal_world(); } -template -PROTOBUF_ALWAYS_INLINE void SendTitleAction::set_subtitle(Arg_&& arg, Args_... args) { +inline void WorldQueryViewersAction::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - _impl_.subtitle_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.subtitle) -} -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::mutable_subtitle() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - ::std::string* _s = _internal_mutable_subtitle(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendTitleAction.subtitle) - return _s; -} -inline const ::std::string& SendTitleAction::_internal_subtitle() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.subtitle_.Get(); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryViewersAction.world) } -inline void SendTitleAction::_internal_set_subtitle(const ::std::string& value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryViewersAction::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.subtitle_.Set(value, GetArena()); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline ::std::string* PROTOBUF_NONNULL SendTitleAction::_internal_mutable_subtitle() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryViewersAction::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.subtitle_.Mutable( GetArena()); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryViewersAction.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -inline ::std::string* PROTOBUF_NULLABLE SendTitleAction::release_subtitle() { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryViewersAction::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendTitleAction.subtitle) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000004U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - auto* released = _impl_.subtitle_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.subtitle_.Set("", GetArena()); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); } - return released; + return _impl_.world_; } -inline void SendTitleAction::set_allocated_subtitle(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryViewersAction::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryViewersAction.world) + return _msg; +} +inline void WorldQueryViewersAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - _impl_.subtitle_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.subtitle_.IsDefault()) { - _impl_.subtitle_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTitleAction.subtitle) + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryViewersAction.world) } -// optional int64 fade_in_ms = 4 [json_name = "fadeInMs"]; -inline bool SendTitleAction::has_fade_in_ms() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); +// .df.plugin.Vec3 position = 2 [json_name = "position"]; +inline bool WorldQueryViewersAction::has_position() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); return value; } -inline void SendTitleAction::clear_fade_in_ms() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fade_in_ms_ = ::int64_t{0}; - ClearHasBit(_impl_._has_bits_[0], - 0x00000008U); -} -inline ::int64_t SendTitleAction::fade_in_ms() const { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.fade_in_ms) - return _internal_fade_in_ms(); -} -inline void SendTitleAction::set_fade_in_ms(::int64_t value) { - _internal_set_fade_in_ms(value); - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.fade_in_ms) -} -inline ::int64_t SendTitleAction::_internal_fade_in_ms() const { +inline const ::df::plugin::Vec3& WorldQueryViewersAction::_internal_position() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.fade_in_ms_; + const ::df::plugin::Vec3* p = _impl_.position_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); } -inline void SendTitleAction::_internal_set_fade_in_ms(::int64_t value) { +inline const ::df::plugin::Vec3& WorldQueryViewersAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldQueryViewersAction.position) + return _internal_position(); +} +inline void WorldQueryViewersAction::unsafe_arena_set_allocated_position( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fade_in_ms_ = value; + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryViewersAction.position) } +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldQueryViewersAction::release_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); -// optional int64 duration_ms = 5 [json_name = "durationMs"]; -inline bool SendTitleAction::has_duration_ms() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); - return value; + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* released = _impl_.position_; + _impl_.position_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; } -inline void SendTitleAction::clear_duration_ms() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldQueryViewersAction::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.duration_ms_ = ::int64_t{0}; - ClearHasBit(_impl_._has_bits_[0], - 0x00000010U); -} -inline ::int64_t SendTitleAction::duration_ms() const { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.duration_ms) - return _internal_duration_ms(); + // @@protoc_insertion_point(field_release:df.plugin.WorldQueryViewersAction.position) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* temp = _impl_.position_; + _impl_.position_ = nullptr; + return temp; } -inline void SendTitleAction::set_duration_ms(::int64_t value) { - _internal_set_duration_ms(value); - SetHasBit(_impl_._has_bits_[0], 0x00000010U); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.duration_ms) +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldQueryViewersAction::_internal_mutable_position() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.position_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.position_; } -inline ::int64_t SendTitleAction::_internal_duration_ms() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.duration_ms_; +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldQueryViewersAction::mutable_position() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* _msg = _internal_mutable_position(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryViewersAction.position) + return _msg; } -inline void SendTitleAction::_internal_set_duration_ms(::int64_t value) { +inline void WorldQueryViewersAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.duration_ms_ = value; -} + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + } -// optional int64 fade_out_ms = 6 [json_name = "fadeOutMs"]; -inline bool SendTitleAction::has_fade_out_ms() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000020U); - return value; + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryViewersAction.position) } -inline void SendTitleAction::clear_fade_out_ms() { + +// ------------------------------------------------------------------- + +// ActionStatus + +// bool ok = 1 [json_name = "ok"]; +inline void ActionStatus::clear_ok() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fade_out_ms_ = ::int64_t{0}; + _impl_.ok_ = false; ClearHasBit(_impl_._has_bits_[0], - 0x00000020U); + 0x00000002U); } -inline ::int64_t SendTitleAction::fade_out_ms() const { - // @@protoc_insertion_point(field_get:df.plugin.SendTitleAction.fade_out_ms) - return _internal_fade_out_ms(); +inline bool ActionStatus::ok() const { + // @@protoc_insertion_point(field_get:df.plugin.ActionStatus.ok) + return _internal_ok(); } -inline void SendTitleAction::set_fade_out_ms(::int64_t value) { - _internal_set_fade_out_ms(value); - SetHasBit(_impl_._has_bits_[0], 0x00000020U); - // @@protoc_insertion_point(field_set:df.plugin.SendTitleAction.fade_out_ms) +inline void ActionStatus::set_ok(bool value) { + _internal_set_ok(value); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + // @@protoc_insertion_point(field_set:df.plugin.ActionStatus.ok) } -inline ::int64_t SendTitleAction::_internal_fade_out_ms() const { +inline bool ActionStatus::_internal_ok() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.fade_out_ms_; + return _impl_.ok_; } -inline void SendTitleAction::_internal_set_fade_out_ms(::int64_t value) { +inline void ActionStatus::_internal_set_ok(bool value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fade_out_ms_ = value; + _impl_.ok_ = value; } -// ------------------------------------------------------------------- - -// SendPopupAction - -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SendPopupAction::clear_player_uuid() { +// optional string error = 2 [json_name = "error"]; +inline bool ActionStatus::has_error() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + return value; +} +inline void ActionStatus::clear_error() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); + _impl_.error_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& SendPopupAction::player_uuid() const +inline const ::std::string& ActionStatus::error() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendPopupAction.player_uuid) - return _internal_player_uuid(); + // @@protoc_insertion_point(field_get:df.plugin.ActionStatus.error) + return _internal_error(); } template -PROTOBUF_ALWAYS_INLINE void SendPopupAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void ActionStatus::set_error(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendPopupAction.player_uuid) + _impl_.error_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.ActionStatus.error) } -inline ::std::string* PROTOBUF_NONNULL SendPopupAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL ActionStatus::mutable_error() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendPopupAction.player_uuid) + ::std::string* _s = _internal_mutable_error(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionStatus.error) return _s; } -inline const ::std::string& SendPopupAction::_internal_player_uuid() const { +inline const ::std::string& ActionStatus::_internal_error() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + return _impl_.error_.Get(); } -inline void SendPopupAction::_internal_set_player_uuid(const ::std::string& value) { +inline void ActionStatus::_internal_set_error(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + _impl_.error_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL SendPopupAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL ActionStatus::_internal_mutable_error() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + return _impl_.error_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE SendPopupAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE ActionStatus::release_error() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendPopupAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.ActionStatus.error) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); + auto* released = _impl_.error_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.error_.Set("", GetArena()); } return released; } -inline void SendPopupAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void ActionStatus::set_allocated_error(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.error_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.error_.IsDefault()) { + _impl_.error_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendPopupAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionStatus.error) } -// string message = 2 [json_name = "message"]; -inline void SendPopupAction::clear_message() { +// ------------------------------------------------------------------- + +// WorldEntitiesResult + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldEntitiesResult::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; +} +inline const ::df::plugin::WorldRef& WorldEntitiesResult::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); +} +inline const ::df::plugin::WorldRef& WorldEntitiesResult::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldEntitiesResult.world) + return _internal_world(); +} +inline void WorldEntitiesResult::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldEntitiesResult.world) } -inline const ::std::string& SendPopupAction::message() const +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldEntitiesResult::release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldEntitiesResult::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldEntitiesResult.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldEntitiesResult::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldEntitiesResult::mutable_world() ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendPopupAction.message) - return _internal_message(); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldEntitiesResult.world) + return _msg; +} +inline void WorldEntitiesResult::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldEntitiesResult.world) +} + +// repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; +inline int WorldEntitiesResult::_internal_entities_size() const { + return _internal_entities().size(); +} +inline int WorldEntitiesResult::entities_size() const { + return _internal_entities_size(); +} +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldEntitiesResult::mutable_entities(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:df.plugin.WorldEntitiesResult.entities) + return _internal_mutable_entities()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL WorldEntitiesResult::mutable_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:df.plugin.WorldEntitiesResult.entities) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_entities(); +} +inline const ::df::plugin::EntityRef& WorldEntitiesResult::entities(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldEntitiesResult.entities) + return _internal_entities().Get(index); } -template -PROTOBUF_ALWAYS_INLINE void SendPopupAction::set_message(Arg_&& arg, Args_... args) { +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldEntitiesResult::add_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.message_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendPopupAction.message) + ::df::plugin::EntityRef* _add = + _internal_mutable_entities()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:df.plugin.WorldEntitiesResult.entities) + return _add; } -inline ::std::string* PROTOBUF_NONNULL SendPopupAction::mutable_message() +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& WorldEntitiesResult::entities() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendPopupAction.message) - return _s; + // @@protoc_insertion_point(field_list:df.plugin.WorldEntitiesResult.entities) + return _internal_entities(); } -inline const ::std::string& SendPopupAction::_internal_message() const { +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& +WorldEntitiesResult::_internal_entities() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.message_.Get(); + return _impl_.entities_; } -inline void SendPopupAction::_internal_set_message(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.Set(value, GetArena()); +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL +WorldEntitiesResult::_internal_mutable_entities() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.entities_; } -inline ::std::string* PROTOBUF_NONNULL SendPopupAction::_internal_mutable_message() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.message_.Mutable( GetArena()); + +// ------------------------------------------------------------------- + +// WorldEntitiesWithinResult + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldEntitiesWithinResult::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline ::std::string* PROTOBUF_NULLABLE SendPopupAction::release_message() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendPopupAction.message) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.message_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.message_.Set("", GetArena()); - } - return released; +inline const ::df::plugin::WorldRef& WorldEntitiesWithinResult::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); } -inline void SendPopupAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { +inline const ::df::plugin::WorldRef& WorldEntitiesWithinResult::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldEntitiesWithinResult.world) + return _internal_world(); +} +inline void WorldEntitiesWithinResult::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.message_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendPopupAction.message) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldEntitiesWithinResult.world) } +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldEntitiesWithinResult::release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); -// ------------------------------------------------------------------- - -// SendTipAction + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldEntitiesWithinResult::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldEntitiesWithinResult.world) -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void SendTipAction::clear_player_uuid() { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldEntitiesWithinResult::_internal_mutable_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline const ::std::string& SendTipAction::player_uuid() const +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldEntitiesWithinResult::mutable_world() ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendTipAction.player_uuid) - return _internal_player_uuid(); + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldEntitiesWithinResult.world) + return _msg; } -template -PROTOBUF_ALWAYS_INLINE void SendTipAction::set_player_uuid(Arg_&& arg, Args_... args) { +inline void WorldEntitiesWithinResult::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendTipAction.player_uuid) + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldEntitiesWithinResult.world) } -inline ::std::string* PROTOBUF_NONNULL SendTipAction::mutable_player_uuid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendTipAction.player_uuid) - return _s; + +// .df.plugin.BBox box = 2 [json_name = "box"]; +inline bool WorldEntitiesWithinResult::has_box() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); + PROTOBUF_ASSUME(!value || _impl_.box_ != nullptr); + return value; } -inline const ::std::string& SendTipAction::_internal_player_uuid() const { +inline const ::df::plugin::BBox& WorldEntitiesWithinResult::_internal_box() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + const ::df::plugin::BBox* p = _impl_.box_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_BBox_default_instance_); } -inline void SendTipAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); +inline const ::df::plugin::BBox& WorldEntitiesWithinResult::box() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldEntitiesWithinResult.box) + return _internal_box(); } -inline ::std::string* PROTOBUF_NONNULL SendTipAction::_internal_mutable_player_uuid() { +inline void WorldEntitiesWithinResult::unsafe_arena_set_allocated_box( + ::df::plugin::BBox* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); + } + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldEntitiesWithinResult.box) } -inline ::std::string* PROTOBUF_NULLABLE SendTipAction::release_player_uuid() { +inline ::df::plugin::BBox* PROTOBUF_NULLABLE WorldEntitiesWithinResult::release_box() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendTipAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; - } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BBox* released = _impl_.box_; + _impl_.box_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } return released; } -inline void SendTipAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::BBox* PROTOBUF_NULLABLE WorldEntitiesWithinResult::unsafe_arena_release_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldEntitiesWithinResult.box) + + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BBox* temp = _impl_.box_; + _impl_.box_ = nullptr; + return temp; +} +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldEntitiesWithinResult::_internal_mutable_box() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.box_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BBox>(GetArena()); + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(p); + } + return _impl_.box_; +} +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldEntitiesWithinResult::mutable_box() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000004U); + ::df::plugin::BBox* _msg = _internal_mutable_box(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldEntitiesWithinResult.box) + return _msg; +} +inline void WorldEntitiesWithinResult::set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); + } + if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTipAction.player_uuid) + + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldEntitiesWithinResult.box) } -// string message = 2 [json_name = "message"]; -inline void SendTipAction::clear_message() { +// repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; +inline int WorldEntitiesWithinResult::_internal_entities_size() const { + return _internal_entities().size(); +} +inline int WorldEntitiesWithinResult::entities_size() const { + return _internal_entities_size(); +} +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldEntitiesWithinResult::mutable_entities(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:df.plugin.WorldEntitiesWithinResult.entities) + return _internal_mutable_entities()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL WorldEntitiesWithinResult::mutable_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:df.plugin.WorldEntitiesWithinResult.entities) ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); + return _internal_mutable_entities(); } -inline const ::std::string& SendTipAction::message() const +inline const ::df::plugin::EntityRef& WorldEntitiesWithinResult::entities(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.SendTipAction.message) - return _internal_message(); + // @@protoc_insertion_point(field_get:df.plugin.WorldEntitiesWithinResult.entities) + return _internal_entities().Get(index); } -template -PROTOBUF_ALWAYS_INLINE void SendTipAction::set_message(Arg_&& arg, Args_... args) { +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldEntitiesWithinResult::add_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.message_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.SendTipAction.message) + ::df::plugin::EntityRef* _add = + _internal_mutable_entities()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:df.plugin.WorldEntitiesWithinResult.entities) + return _add; } -inline ::std::string* PROTOBUF_NONNULL SendTipAction::mutable_message() +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& WorldEntitiesWithinResult::entities() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_message(); - // @@protoc_insertion_point(field_mutable:df.plugin.SendTipAction.message) - return _s; + // @@protoc_insertion_point(field_list:df.plugin.WorldEntitiesWithinResult.entities) + return _internal_entities(); } -inline const ::std::string& SendTipAction::_internal_message() const { +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& +WorldEntitiesWithinResult::_internal_entities() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.message_.Get(); + return _impl_.entities_; } -inline void SendTipAction::_internal_set_message(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.message_.Set(value, GetArena()); +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL +WorldEntitiesWithinResult::_internal_mutable_entities() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.entities_; } -inline ::std::string* PROTOBUF_NONNULL SendTipAction::_internal_mutable_message() { + +// ------------------------------------------------------------------- + +// WorldPlayersResult + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldPlayersResult::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; +} +inline const ::df::plugin::WorldRef& WorldPlayersResult::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); +} +inline const ::df::plugin::WorldRef& WorldPlayersResult::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldPlayersResult.world) + return _internal_world(); +} +inline void WorldPlayersResult::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.message_.Mutable( GetArena()); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldPlayersResult.world) } -inline ::std::string* PROTOBUF_NULLABLE SendTipAction::release_message() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldPlayersResult::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.SendTipAction.message) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { - return nullptr; + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } + return released; +} +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldPlayersResult::unsafe_arena_release_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.WorldPlayersResult.world) + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.message_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.message_.Set("", GetArena()); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; +} +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldPlayersResult::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); } - return released; + return _impl_.world_; } -inline void SendTipAction::set_allocated_message(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldPlayersResult::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldPlayersResult.world) + return _msg; +} +inline void WorldPlayersResult::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } SetHasBit(_impl_._has_bits_[0], 0x00000002U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.message_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.message_.IsDefault()) { - _impl_.message_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.SendTipAction.message) -} - -// ------------------------------------------------------------------- -// PlaySoundAction + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldPlayersResult.world) +} -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void PlaySoundAction::clear_player_uuid() { +// repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; +inline int WorldPlayersResult::_internal_players_size() const { + return _internal_players().size(); +} +inline int WorldPlayersResult::players_size() const { + return _internal_players_size(); +} +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldPlayersResult::mutable_players(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:df.plugin.WorldPlayersResult.players) + return _internal_mutable_players()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL WorldPlayersResult::mutable_players() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:df.plugin.WorldPlayersResult.players) ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); + return _internal_mutable_players(); } -inline const ::std::string& PlaySoundAction::player_uuid() const +inline const ::df::plugin::EntityRef& WorldPlayersResult::players(int index) const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.player_uuid) - return _internal_player_uuid(); + // @@protoc_insertion_point(field_get:df.plugin.WorldPlayersResult.players) + return _internal_players().Get(index); } -template -PROTOBUF_ALWAYS_INLINE void PlaySoundAction::set_player_uuid(Arg_&& arg, Args_... args) { +inline ::df::plugin::EntityRef* PROTOBUF_NONNULL WorldPlayersResult::add_players() + ABSL_ATTRIBUTE_LIFETIME_BOUND { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.player_uuid) + ::df::plugin::EntityRef* _add = + _internal_mutable_players()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:df.plugin.WorldPlayersResult.players) + return _add; } -inline ::std::string* PROTOBUF_NONNULL PlaySoundAction::mutable_player_uuid() +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& WorldPlayersResult::players() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.PlaySoundAction.player_uuid) - return _s; + // @@protoc_insertion_point(field_list:df.plugin.WorldPlayersResult.players) + return _internal_players(); } -inline const ::std::string& PlaySoundAction::_internal_player_uuid() const { +inline const ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>& +WorldPlayersResult::_internal_players() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + return _impl_.players_; } -inline void PlaySoundAction::_internal_set_player_uuid(const ::std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); +inline ::google::protobuf::RepeatedPtrField<::df::plugin::EntityRef>* PROTOBUF_NONNULL +WorldPlayersResult::_internal_mutable_players() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.players_; } -inline ::std::string* PROTOBUF_NONNULL PlaySoundAction::_internal_mutable_player_uuid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + +// ------------------------------------------------------------------- + +// WorldViewersResult + +// .df.plugin.WorldRef world = 1 [json_name = "world"]; +inline bool WorldViewersResult::has_world() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); + return value; } -inline ::std::string* PROTOBUF_NULLABLE PlaySoundAction::release_player_uuid() { +inline const ::df::plugin::WorldRef& WorldViewersResult::_internal_world() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::WorldRef* p = _impl_.world_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); +} +inline const ::df::plugin::WorldRef& WorldViewersResult::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.world) + return _internal_world(); +} +inline void WorldViewersResult::unsafe_arena_set_allocated_world( + ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.PlaySoundAction.player_uuid) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { - return nullptr; + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); } - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - return released; + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldViewersResult.world) } -inline void PlaySoundAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldViewersResult::release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* released = _impl_.world_; + _impl_.world_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } } - // @@protoc_insertion_point(field_set_allocated:df.plugin.PlaySoundAction.player_uuid) + return released; } - -// .df.plugin.Sound sound = 2 [json_name = "sound"]; -inline void PlaySoundAction::clear_sound() { +inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldViewersResult::unsafe_arena_release_world() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sound_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); -} -inline ::df::plugin::Sound PlaySoundAction::sound() const { - // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.sound) - return _internal_sound(); + // @@protoc_insertion_point(field_release:df.plugin.WorldViewersResult.world) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* temp = _impl_.world_; + _impl_.world_ = nullptr; + return temp; } -inline void PlaySoundAction::set_sound(::df::plugin::Sound value) { - _internal_set_sound(value); - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.sound) +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldViewersResult::_internal_mutable_world() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.world_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); + } + return _impl_.world_; } -inline ::df::plugin::Sound PlaySoundAction::_internal_sound() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return static_cast<::df::plugin::Sound>(_impl_.sound_); +inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldViewersResult::mutable_world() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::WorldRef* _msg = _internal_mutable_world(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.world) + return _msg; } -inline void PlaySoundAction::_internal_set_sound(::df::plugin::Sound value) { +inline void WorldViewersResult::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sound_ = value; + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldViewersResult.world) } -// optional .df.plugin.Vec3 position = 3 [json_name = "position"]; -inline bool PlaySoundAction::has_position() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); +// .df.plugin.Vec3 position = 2 [json_name = "position"]; +inline bool WorldViewersResult::has_position() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); return value; } -inline const ::df::plugin::Vec3& PlaySoundAction::_internal_position() const { +inline const ::df::plugin::Vec3& WorldViewersResult::_internal_position() const { ::google::protobuf::internal::TSanRead(&_impl_); const ::df::plugin::Vec3* p = _impl_.position_; return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); } -inline const ::df::plugin::Vec3& PlaySoundAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.position) +inline const ::df::plugin::Vec3& WorldViewersResult::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.position) return _internal_position(); } -inline void PlaySoundAction::unsafe_arena_set_allocated_position( +inline void WorldViewersResult::unsafe_arena_set_allocated_position( ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (GetArena() == nullptr) { @@ -9148,16 +16671,16 @@ inline void PlaySoundAction::unsafe_arena_set_allocated_position( } _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.PlaySoundAction.position) + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldViewersResult.position) } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE PlaySoundAction::release_position() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldViewersResult::release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::df::plugin::Vec3* released = _impl_.position_; _impl_.position_ = nullptr; if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { @@ -9173,16 +16696,16 @@ inline ::df::plugin::Vec3* PROTOBUF_NULLABLE PlaySoundAction::release_position() } return released; } -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE PlaySoundAction::unsafe_arena_release_position() { +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldViewersResult::unsafe_arena_release_position() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.PlaySoundAction.position) + // @@protoc_insertion_point(field_release:df.plugin.WorldViewersResult.position) - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); ::df::plugin::Vec3* temp = _impl_.position_; _impl_.position_ = nullptr; return temp; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL PlaySoundAction::_internal_mutable_position() { +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldViewersResult::_internal_mutable_position() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.position_ == nullptr) { auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); @@ -9190,14 +16713,14 @@ inline ::df::plugin::Vec3* PROTOBUF_NONNULL PlaySoundAction::_internal_mutable_p } return _impl_.position_; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL PlaySoundAction::mutable_position() +inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldViewersResult::mutable_position() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); ::df::plugin::Vec3* _msg = _internal_mutable_position(); - // @@protoc_insertion_point(field_mutable:df.plugin.PlaySoundAction.position) + // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.position) return _msg; } -inline void PlaySoundAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { +inline void WorldViewersResult::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { @@ -9209,207 +16732,592 @@ inline void PlaySoundAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF if (message_arena != submessage_arena) { value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); } - SetHasBit(_impl_._has_bits_[0], 0x00000002U); + SetHasBit(_impl_._has_bits_[0], 0x00000004U); } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ClearHasBit(_impl_._has_bits_[0], 0x00000004U); } _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.PlaySoundAction.position) + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldViewersResult.position) } -// optional float volume = 4 [json_name = "volume"]; -inline bool PlaySoundAction::has_volume() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000008U); - return value; +// repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; +inline int WorldViewersResult::_internal_viewer_uuids_size() const { + return _internal_viewer_uuids().size(); } -inline void PlaySoundAction::clear_volume() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.volume_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000008U); +inline int WorldViewersResult::viewer_uuids_size() const { + return _internal_viewer_uuids_size(); } -inline float PlaySoundAction::volume() const { - // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.volume) - return _internal_volume(); +inline void WorldViewersResult::clear_viewer_uuids() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.viewer_uuids_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -inline void PlaySoundAction::set_volume(float value) { - _internal_set_volume(value); - SetHasBit(_impl_._has_bits_[0], 0x00000008U); - // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.volume) +inline ::std::string* PROTOBUF_NONNULL WorldViewersResult::add_viewer_uuids() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::std::string* _s = + _internal_mutable_viewer_uuids()->InternalAddWithArena( + ::google::protobuf::MessageLite::internal_visibility(), GetArena()); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add_mutable:df.plugin.WorldViewersResult.viewer_uuids) + return _s; } -inline float PlaySoundAction::_internal_volume() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.volume_; +inline const ::std::string& WorldViewersResult::viewer_uuids(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.viewer_uuids) + return _internal_viewer_uuids().Get(index); } -inline void PlaySoundAction::_internal_set_volume(float value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.volume_ = value; +inline ::std::string* PROTOBUF_NONNULL WorldViewersResult::mutable_viewer_uuids(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.viewer_uuids) + return _internal_mutable_viewer_uuids()->Mutable(index); } - -// optional float pitch = 5 [json_name = "pitch"]; -inline bool PlaySoundAction::has_pitch() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000010U); - return value; +template +inline void WorldViewersResult::set_viewer_uuids(int index, Arg_&& value, Args_... args) { + ::google::protobuf::internal::AssignToString(*_internal_mutable_viewer_uuids()->Mutable(index), ::std::forward(value), + args... ); + // @@protoc_insertion_point(field_set:df.plugin.WorldViewersResult.viewer_uuids) } -inline void PlaySoundAction::clear_pitch() { +template +inline void WorldViewersResult::add_viewer_uuids(Arg_&& value, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pitch_ = 0; - ClearHasBit(_impl_._has_bits_[0], - 0x00000010U); + ::google::protobuf::internal::AddToRepeatedPtrField( + ::google::protobuf::MessageLite::internal_visibility(), GetArena(), + *_internal_mutable_viewer_uuids(), ::std::forward(value), + args... ); + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_add:df.plugin.WorldViewersResult.viewer_uuids) } -inline float PlaySoundAction::pitch() const { - // @@protoc_insertion_point(field_get:df.plugin.PlaySoundAction.pitch) - return _internal_pitch(); +inline const ::google::protobuf::RepeatedPtrField<::std::string>& WorldViewersResult::viewer_uuids() + const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:df.plugin.WorldViewersResult.viewer_uuids) + return _internal_viewer_uuids(); } -inline void PlaySoundAction::set_pitch(float value) { - _internal_set_pitch(value); - SetHasBit(_impl_._has_bits_[0], 0x00000010U); - // @@protoc_insertion_point(field_set:df.plugin.PlaySoundAction.pitch) +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL +WorldViewersResult::mutable_viewer_uuids() ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); + // @@protoc_insertion_point(field_mutable_list:df.plugin.WorldViewersResult.viewer_uuids) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_viewer_uuids(); } -inline float PlaySoundAction::_internal_pitch() const { +inline const ::google::protobuf::RepeatedPtrField<::std::string>& +WorldViewersResult::_internal_viewer_uuids() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pitch_; + return _impl_.viewer_uuids_; } -inline void PlaySoundAction::_internal_set_pitch(float value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pitch_ = value; +inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL +WorldViewersResult::_internal_mutable_viewer_uuids() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.viewer_uuids_; } // ------------------------------------------------------------------- -// ExecuteCommandAction +// ActionResult -// string player_uuid = 1 [json_name = "playerUuid"]; -inline void ExecuteCommandAction::clear_player_uuid() { +// string correlation_id = 1 [json_name = "correlationId"]; +inline void ActionResult::clear_correlation_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.ClearToEmpty(); + _impl_.correlation_id_.ClearToEmpty(); ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } -inline const ::std::string& ExecuteCommandAction::player_uuid() const +inline const ::std::string& ActionResult::correlation_id() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.ExecuteCommandAction.player_uuid) - return _internal_player_uuid(); + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.correlation_id) + return _internal_correlation_id(); } template -PROTOBUF_ALWAYS_INLINE void ExecuteCommandAction::set_player_uuid(Arg_&& arg, Args_... args) { +PROTOBUF_ALWAYS_INLINE void ActionResult::set_correlation_id(Arg_&& arg, Args_... args) { ::google::protobuf::internal::TSanWrite(&_impl_); SetHasBit(_impl_._has_bits_[0], 0x00000001U); - _impl_.player_uuid_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.ExecuteCommandAction.player_uuid) + _impl_.correlation_id_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:df.plugin.ActionResult.correlation_id) } -inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::mutable_player_uuid() +inline ::std::string* PROTOBUF_NONNULL ActionResult::mutable_correlation_id() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::std::string* _s = _internal_mutable_player_uuid(); - // @@protoc_insertion_point(field_mutable:df.plugin.ExecuteCommandAction.player_uuid) + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::std::string* _s = _internal_mutable_correlation_id(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.correlation_id) return _s; } -inline const ::std::string& ExecuteCommandAction::_internal_player_uuid() const { +inline const ::std::string& ActionResult::_internal_correlation_id() const { ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_uuid_.Get(); + return _impl_.correlation_id_.Get(); } -inline void ExecuteCommandAction::_internal_set_player_uuid(const ::std::string& value) { +inline void ActionResult::_internal_set_correlation_id(const ::std::string& value) { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_uuid_.Set(value, GetArena()); + _impl_.correlation_id_.Set(value, GetArena()); } -inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::_internal_mutable_player_uuid() { +inline ::std::string* PROTOBUF_NONNULL ActionResult::_internal_mutable_correlation_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.player_uuid_.Mutable( GetArena()); + return _impl_.correlation_id_.Mutable( GetArena()); } -inline ::std::string* PROTOBUF_NULLABLE ExecuteCommandAction::release_player_uuid() { +inline ::std::string* PROTOBUF_NULLABLE ActionResult::release_correlation_id() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.ExecuteCommandAction.player_uuid) + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.correlation_id) if (!CheckHasBit(_impl_._has_bits_[0], 0x00000001U)) { return nullptr; } ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - auto* released = _impl_.player_uuid_.Release(); + auto* released = _impl_.correlation_id_.Release(); if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.correlation_id_.Set("", GetArena()); } return released; } -inline void ExecuteCommandAction::set_allocated_player_uuid(::std::string* PROTOBUF_NULLABLE value) { +inline void ActionResult::set_allocated_correlation_id(::std::string* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); if (value != nullptr) { SetHasBit(_impl_._has_bits_[0], 0x00000001U); } else { ClearHasBit(_impl_._has_bits_[0], 0x00000001U); } - _impl_.player_uuid_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.player_uuid_.IsDefault()) { - _impl_.player_uuid_.Set("", GetArena()); + _impl_.correlation_id_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.correlation_id_.IsDefault()) { + _impl_.correlation_id_.Set("", GetArena()); } - // @@protoc_insertion_point(field_set_allocated:df.plugin.ExecuteCommandAction.player_uuid) + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.correlation_id) } -// string command = 2 [json_name = "command"]; -inline void ExecuteCommandAction::clear_command() { +// optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; +inline bool ActionResult::has_status() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.status_ != nullptr); + return value; +} +inline void ActionResult::clear_status() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.command_.ClearToEmpty(); + if (_impl_.status_ != nullptr) _impl_.status_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -inline const ::std::string& ExecuteCommandAction::command() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.ExecuteCommandAction.command) - return _internal_command(); +inline const ::df::plugin::ActionStatus& ActionResult::_internal_status() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::ActionStatus* p = _impl_.status_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_ActionStatus_default_instance_); } -template -PROTOBUF_ALWAYS_INLINE void ExecuteCommandAction::set_command(Arg_&& arg, Args_... args) { +inline const ::df::plugin::ActionStatus& ActionResult::status() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.status) + return _internal_status(); +} +inline void ActionResult::unsafe_arena_set_allocated_status( + ::df::plugin::ActionStatus* PROTOBUF_NULLABLE value) { ::google::protobuf::internal::TSanWrite(&_impl_); - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - _impl_.command_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:df.plugin.ExecuteCommandAction.command) + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.status_); + } + _impl_.status_ = reinterpret_cast<::df::plugin::ActionStatus*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.status) } -inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::mutable_command() +inline ::df::plugin::ActionStatus* PROTOBUF_NULLABLE ActionResult::release_status() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ActionStatus* released = _impl_.status_; + _impl_.status_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::ActionStatus* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_status() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.status) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::ActionStatus* temp = _impl_.status_; + _impl_.status_ = nullptr; + return temp; +} +inline ::df::plugin::ActionStatus* PROTOBUF_NONNULL ActionResult::_internal_mutable_status() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.status_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::ActionStatus>(GetArena()); + _impl_.status_ = reinterpret_cast<::df::plugin::ActionStatus*>(p); + } + return _impl_.status_; +} +inline ::df::plugin::ActionStatus* PROTOBUF_NONNULL ActionResult::mutable_status() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::std::string* _s = _internal_mutable_command(); - // @@protoc_insertion_point(field_mutable:df.plugin.ExecuteCommandAction.command) - return _s; + ::df::plugin::ActionStatus* _msg = _internal_mutable_status(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.status) + return _msg; } -inline const ::std::string& ExecuteCommandAction::_internal_command() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.command_.Get(); +inline void ActionResult::set_allocated_status(::df::plugin::ActionStatus* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.status_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.status_ = reinterpret_cast<::df::plugin::ActionStatus*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.status) } -inline void ExecuteCommandAction::_internal_set_command(const ::std::string& value) { + +// .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; +inline bool ActionResult::has_world_entities() const { + return result_case() == kWorldEntities; +} +inline bool ActionResult::_internal_has_world_entities() const { + return result_case() == kWorldEntities; +} +inline void ActionResult::set_has_world_entities() { + _impl_._oneof_case_[0] = kWorldEntities; +} +inline void ActionResult::clear_world_entities() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.command_.Set(value, GetArena()); + if (result_case() == kWorldEntities) { + if (GetArena() == nullptr) { + delete _impl_.result_.world_entities_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_entities_); + } + clear_has_result(); + } } -inline ::std::string* PROTOBUF_NONNULL ExecuteCommandAction::_internal_mutable_command() { +inline ::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE ActionResult::release_world_entities() { + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.world_entities) + if (result_case() == kWorldEntities) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldEntitiesResult*>(_impl_.result_.world_entities_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.result_.world_entities_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldEntitiesResult& ActionResult::_internal_world_entities() const { + return result_case() == kWorldEntities ? static_cast(*reinterpret_cast<::df::plugin::WorldEntitiesResult*>(_impl_.result_.world_entities_)) + : reinterpret_cast(::df::plugin::_WorldEntitiesResult_default_instance_); +} +inline const ::df::plugin::WorldEntitiesResult& ActionResult::world_entities() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.world_entities) + return _internal_world_entities(); +} +inline ::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_world_entities() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.ActionResult.world_entities) + if (result_case() == kWorldEntities) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldEntitiesResult*>(_impl_.result_.world_entities_); + _impl_.result_.world_entities_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ActionResult::unsafe_arena_set_allocated_world_entities( + ::df::plugin::WorldEntitiesResult* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_result(); + if (value) { + set_has_world_entities(); + _impl_.result_.world_entities_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.world_entities) +} +inline ::df::plugin::WorldEntitiesResult* PROTOBUF_NONNULL ActionResult::_internal_mutable_world_entities() { + if (result_case() != kWorldEntities) { + clear_result(); + set_has_world_entities(); + _impl_.result_.world_entities_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldEntitiesResult>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldEntitiesResult*>(_impl_.result_.world_entities_); +} +inline ::df::plugin::WorldEntitiesResult* PROTOBUF_NONNULL ActionResult::mutable_world_entities() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldEntitiesResult* _msg = _internal_mutable_world_entities(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.world_entities) + return _msg; +} + +// .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; +inline bool ActionResult::has_world_players() const { + return result_case() == kWorldPlayers; +} +inline bool ActionResult::_internal_has_world_players() const { + return result_case() == kWorldPlayers; +} +inline void ActionResult::set_has_world_players() { + _impl_._oneof_case_[0] = kWorldPlayers; +} +inline void ActionResult::clear_world_players() { ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.command_.Mutable( GetArena()); + if (result_case() == kWorldPlayers) { + if (GetArena() == nullptr) { + delete _impl_.result_.world_players_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_players_); + } + clear_has_result(); + } } -inline ::std::string* PROTOBUF_NULLABLE ExecuteCommandAction::release_command() { +inline ::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE ActionResult::release_world_players() { + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.world_players) + if (result_case() == kWorldPlayers) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldPlayersResult*>(_impl_.result_.world_players_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.result_.world_players_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::WorldPlayersResult& ActionResult::_internal_world_players() const { + return result_case() == kWorldPlayers ? static_cast(*reinterpret_cast<::df::plugin::WorldPlayersResult*>(_impl_.result_.world_players_)) + : reinterpret_cast(::df::plugin::_WorldPlayersResult_default_instance_); +} +inline const ::df::plugin::WorldPlayersResult& ActionResult::world_players() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.world_players) + return _internal_world_players(); +} +inline ::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_world_players() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.ActionResult.world_players) + if (result_case() == kWorldPlayers) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldPlayersResult*>(_impl_.result_.world_players_); + _impl_.result_.world_players_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void ActionResult::unsafe_arena_set_allocated_world_players( + ::df::plugin::WorldPlayersResult* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_result(); + if (value) { + set_has_world_players(); + _impl_.result_.world_players_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.world_players) +} +inline ::df::plugin::WorldPlayersResult* PROTOBUF_NONNULL ActionResult::_internal_mutable_world_players() { + if (result_case() != kWorldPlayers) { + clear_result(); + set_has_world_players(); + _impl_.result_.world_players_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldPlayersResult>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldPlayersResult*>(_impl_.result_.world_players_); +} +inline ::df::plugin::WorldPlayersResult* PROTOBUF_NONNULL ActionResult::mutable_world_players() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldPlayersResult* _msg = _internal_mutable_world_players(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.world_players) + return _msg; +} + +// .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; +inline bool ActionResult::has_world_entities_within() const { + return result_case() == kWorldEntitiesWithin; +} +inline bool ActionResult::_internal_has_world_entities_within() const { + return result_case() == kWorldEntitiesWithin; +} +inline void ActionResult::set_has_world_entities_within() { + _impl_._oneof_case_[0] = kWorldEntitiesWithin; +} +inline void ActionResult::clear_world_entities_within() { ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.ExecuteCommandAction.command) - if (!CheckHasBit(_impl_._has_bits_[0], 0x00000002U)) { + if (result_case() == kWorldEntitiesWithin) { + if (GetArena() == nullptr) { + delete _impl_.result_.world_entities_within_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_entities_within_); + } + clear_has_result(); + } +} +inline ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE ActionResult::release_world_entities_within() { + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.world_entities_within) + if (result_case() == kWorldEntitiesWithin) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldEntitiesWithinResult*>(_impl_.result_.world_entities_within_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.result_.world_entities_within_ = nullptr; + return temp; + } else { return nullptr; } - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - auto* released = _impl_.command_.Release(); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString()) { - _impl_.command_.Set("", GetArena()); +} +inline const ::df::plugin::WorldEntitiesWithinResult& ActionResult::_internal_world_entities_within() const { + return result_case() == kWorldEntitiesWithin ? static_cast(*reinterpret_cast<::df::plugin::WorldEntitiesWithinResult*>(_impl_.result_.world_entities_within_)) + : reinterpret_cast(::df::plugin::_WorldEntitiesWithinResult_default_instance_); +} +inline const ::df::plugin::WorldEntitiesWithinResult& ActionResult::world_entities_within() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.world_entities_within) + return _internal_world_entities_within(); +} +inline ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_world_entities_within() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.ActionResult.world_entities_within) + if (result_case() == kWorldEntitiesWithin) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldEntitiesWithinResult*>(_impl_.result_.world_entities_within_); + _impl_.result_.world_entities_within_ = nullptr; + return temp; + } else { + return nullptr; } - return released; } -inline void ExecuteCommandAction::set_allocated_command(::std::string* PROTOBUF_NULLABLE value) { +inline void ActionResult::unsafe_arena_set_allocated_world_entities_within( + ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_result(); + if (value) { + set_has_world_entities_within(); + _impl_.result_.world_entities_within_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.world_entities_within) +} +inline ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL ActionResult::_internal_mutable_world_entities_within() { + if (result_case() != kWorldEntitiesWithin) { + clear_result(); + set_has_world_entities_within(); + _impl_.result_.world_entities_within_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldEntitiesWithinResult>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldEntitiesWithinResult*>(_impl_.result_.world_entities_within_); +} +inline ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL ActionResult::mutable_world_entities_within() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldEntitiesWithinResult* _msg = _internal_mutable_world_entities_within(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.world_entities_within) + return _msg; +} + +// .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; +inline bool ActionResult::has_world_viewers() const { + return result_case() == kWorldViewers; +} +inline bool ActionResult::_internal_has_world_viewers() const { + return result_case() == kWorldViewers; +} +inline void ActionResult::set_has_world_viewers() { + _impl_._oneof_case_[0] = kWorldViewers; +} +inline void ActionResult::clear_world_viewers() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); + if (result_case() == kWorldViewers) { + if (GetArena() == nullptr) { + delete _impl_.result_.world_viewers_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_viewers_); + } + clear_has_result(); + } +} +inline ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE ActionResult::release_world_viewers() { + // @@protoc_insertion_point(field_release:df.plugin.ActionResult.world_viewers) + if (result_case() == kWorldViewers) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.result_.world_viewers_ = nullptr; + return temp; } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + return nullptr; } - _impl_.command_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.command_.IsDefault()) { - _impl_.command_.Set("", GetArena()); +} +inline const ::df::plugin::WorldViewersResult& ActionResult::_internal_world_viewers() const { + return result_case() == kWorldViewers ? static_cast(*reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_)) + : reinterpret_cast(::df::plugin::_WorldViewersResult_default_instance_); +} +inline const ::df::plugin::WorldViewersResult& ActionResult::world_viewers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.ActionResult.world_viewers) + return _internal_world_viewers(); +} +inline ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_world_viewers() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.ActionResult.world_viewers) + if (result_case() == kWorldViewers) { + clear_has_result(); + auto* temp = reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); + _impl_.result_.world_viewers_ = nullptr; + return temp; + } else { + return nullptr; } - // @@protoc_insertion_point(field_set_allocated:df.plugin.ExecuteCommandAction.command) +} +inline void ActionResult::unsafe_arena_set_allocated_world_viewers( + ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_result(); + if (value) { + set_has_world_viewers(); + _impl_.result_.world_viewers_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.world_viewers) +} +inline ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL ActionResult::_internal_mutable_world_viewers() { + if (result_case() != kWorldViewers) { + clear_result(); + set_has_world_viewers(); + _impl_.result_.world_viewers_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldViewersResult>(GetArena())); + } + return reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); +} +inline ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL ActionResult::mutable_world_viewers() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::WorldViewersResult* _msg = _internal_mutable_world_viewers(); + // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.world_viewers) + return _msg; } +inline bool ActionResult::has_result() const { + return result_case() != RESULT_NOT_SET; +} +inline void ActionResult::clear_has_result() { + _impl_._oneof_case_[0] = RESULT_NOT_SET; +} +inline ActionResult::ResultCase ActionResult::result_case() const { + return ActionResult::ResultCase(_impl_._oneof_case_[0]); +} #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -9419,6 +17327,19 @@ inline void ExecuteCommandAction::set_allocated_command(::std::string* PROTOBUF_ } // namespace df +namespace google { +namespace protobuf { + +template <> +struct is_proto_enum<::df::plugin::ParticleType> : std::true_type {}; +template <> +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::df::plugin::ParticleType>() { + return ::df::plugin::ParticleType_descriptor(); +} + +} // namespace protobuf +} // namespace google + // @@protoc_insertion_point(global_scope) #include "google/protobuf/port_undef.inc" diff --git a/packages/cpp/src/generated/common.pb.cc b/packages/cpp/src/generated/common.pb.cc index 36af735..81e6a3a 100644 --- a/packages/cpp/src/generated/common.pb.cc +++ b/packages/cpp/src/generated/common.pb.cc @@ -373,6 +373,32 @@ struct BlockStateDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BlockStateDefaultTypeInternal _BlockState_default_instance_; +inline constexpr BBox::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0}, + min_{nullptr}, + max_{nullptr} {} + +template +PROTOBUF_CONSTEXPR BBox::BBox(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(BBox_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct BBoxDefaultTypeInternal { + PROTOBUF_CONSTEXPR BBoxDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~BBoxDefaultTypeInternal() {} + union { + BBox _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BBoxDefaultTypeInternal _BBox_default_instance_; + inline constexpr LiquidState::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -405,7 +431,7 @@ PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT } // namespace plugin } // namespace df static const ::_pb::EnumDescriptor* PROTOBUF_NONNULL - file_level_enum_descriptors_common_2eproto[4]; + file_level_enum_descriptors_common_2eproto[5]; static constexpr const ::_pb::ServiceDescriptor* PROTOBUF_NONNULL* PROTOBUF_NULLABLE file_level_service_descriptors_common_2eproto = nullptr; const ::uint32_t @@ -428,6 +454,13 @@ const ::uint32_t 0, 1, 0x081, // bitmap + PROTOBUF_FIELD_OFFSET(::df::plugin::BBox, _impl_._has_bits_), + 5, // hasbit index offset + PROTOBUF_FIELD_OFFSET(::df::plugin::BBox, _impl_.min_), + PROTOBUF_FIELD_OFFSET(::df::plugin::BBox, _impl_.max_), + 0, + 1, + 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::BlockPos, _impl_._has_bits_), 6, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::BlockPos, _impl_.x_), @@ -532,21 +565,23 @@ static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::df::plugin::Vec3)}, {9, sizeof(::df::plugin::Rotation)}, - {16, sizeof(::df::plugin::BlockPos)}, - {25, sizeof(::df::plugin::ItemStack)}, - {34, sizeof(::df::plugin::BlockState_PropertiesEntry_DoNotUse)}, - {41, sizeof(::df::plugin::BlockState)}, - {48, sizeof(::df::plugin::LiquidState)}, - {59, sizeof(::df::plugin::WorldRef)}, - {66, sizeof(::df::plugin::EntityRef)}, - {79, sizeof(::df::plugin::DamageSource)}, - {86, sizeof(::df::plugin::HealingSource)}, - {93, sizeof(::df::plugin::Address)}, - {100, sizeof(::df::plugin::CustomItemDefinition)}, + {16, sizeof(::df::plugin::BBox)}, + {23, sizeof(::df::plugin::BlockPos)}, + {32, sizeof(::df::plugin::ItemStack)}, + {41, sizeof(::df::plugin::BlockState_PropertiesEntry_DoNotUse)}, + {48, sizeof(::df::plugin::BlockState)}, + {55, sizeof(::df::plugin::LiquidState)}, + {66, sizeof(::df::plugin::WorldRef)}, + {73, sizeof(::df::plugin::EntityRef)}, + {86, sizeof(::df::plugin::DamageSource)}, + {93, sizeof(::df::plugin::HealingSource)}, + {100, sizeof(::df::plugin::Address)}, + {107, sizeof(::df::plugin::CustomItemDefinition)}, }; static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::df::plugin::_Vec3_default_instance_._instance, &::df::plugin::_Rotation_default_instance_._instance, + &::df::plugin::_BBox_default_instance_._instance, &::df::plugin::_BlockPos_default_instance_._instance, &::df::plugin::_ItemStack_default_instance_._instance, &::df::plugin::_BlockState_PropertiesEntry_DoNotUse_default_instance_._instance, @@ -564,77 +599,81 @@ const char descriptor_table_protodef_common_2eproto[] ABSL_ATTRIBUTE_SECTION_VAR "\n\014common.proto\022\tdf.plugin\"0\n\004Vec3\022\014\n\001x\030\001" " \001(\001R\001x\022\014\n\001y\030\002 \001(\001R\001y\022\014\n\001z\030\003 \001(\001R\001z\"2\n\010R" "otation\022\020\n\003yaw\030\001 \001(\002R\003yaw\022\024\n\005pitch\030\002 \001(\002" - "R\005pitch\"4\n\010BlockPos\022\014\n\001x\030\001 \001(\005R\001x\022\014\n\001y\030\002" - " \001(\005R\001y\022\014\n\001z\030\003 \001(\005R\001z\"I\n\tItemStack\022\022\n\004na" - "me\030\001 \001(\tR\004name\022\022\n\004meta\030\002 \001(\005R\004meta\022\024\n\005co" - "unt\030\003 \001(\005R\005count\"\246\001\n\nBlockState\022\022\n\004name\030" - "\001 \001(\tR\004name\022E\n\nproperties\030\002 \003(\0132%.df.plu" - "gin.BlockState.PropertiesEntryR\nproperti" - "es\032=\n\017PropertiesEntry\022\020\n\003key\030\001 \001(\tR\003key\022" - "\024\n\005value\030\002 \001(\tR\005value:\0028\001\"\213\001\n\013LiquidStat" - "e\022+\n\005block\030\001 \001(\0132\025.df.plugin.BlockStateR" - "\005block\022\024\n\005depth\030\002 \001(\005R\005depth\022\030\n\007falling\030" - "\003 \001(\010R\007falling\022\037\n\013liquid_type\030\004 \001(\tR\nliq" - "uidType\"<\n\010WorldRef\022\022\n\004name\030\001 \001(\tR\004name\022" - "\034\n\tdimension\030\002 \001(\tR\tdimension\"\327\001\n\tEntity" - "Ref\022\022\n\004uuid\030\001 \001(\tR\004uuid\022\022\n\004type\030\002 \001(\tR\004t" - "ype\022\027\n\004name\030\003 \001(\tH\000R\004name\210\001\001\0220\n\010position" - "\030\004 \001(\0132\017.df.plugin.Vec3H\001R\010position\210\001\001\0224" - "\n\010rotation\030\005 \001(\0132\023.df.plugin.RotationH\002R" - "\010rotation\210\001\001B\007\n\005_nameB\013\n\t_positionB\013\n\t_r" - "otation\"Y\n\014DamageSource\022\022\n\004type\030\001 \001(\tR\004t" - "ype\022%\n\013description\030\002 \001(\tH\000R\013description\210" - "\001\001B\016\n\014_description\"Z\n\rHealingSource\022\022\n\004t" - "ype\030\001 \001(\tR\004type\022%\n\013description\030\002 \001(\tH\000R\013" - "description\210\001\001B\016\n\014_description\"1\n\007Addres" - "s\022\022\n\004host\030\001 \001(\tR\004host\022\022\n\004port\030\002 \001(\005R\004por" - "t\"\332\001\n\024CustomItemDefinition\022\016\n\002id\030\001 \001(\tR\002" - "id\022!\n\014display_name\030\002 \001(\tR\013displayName\022!\n" - "\014texture_data\030\003 \001(\014R\013textureData\0223\n\010cate" - "gory\030\004 \001(\0162\027.df.plugin.ItemCategoryR\010cat" - "egory\022\031\n\005group\030\005 \001(\tH\000R\005group\210\001\001\022\022\n\004meta" - "\030\006 \001(\005R\004metaB\010\n\006_group*D\n\010GameMode\022\014\n\010SU" - "RVIVAL\020\000\022\014\n\010CREATIVE\020\001\022\r\n\tADVENTURE\020\002\022\r\n" - "\tSPECTATOR\020\003*\342\003\n\nEffectType\022\022\n\016EFFECT_UN" - "KNOWN\020\000\022\t\n\005SPEED\020\001\022\014\n\010SLOWNESS\020\002\022\t\n\005HAST" - "E\020\003\022\022\n\016MINING_FATIGUE\020\004\022\014\n\010STRENGTH\020\005\022\022\n" - "\016INSTANT_HEALTH\020\006\022\022\n\016INSTANT_DAMAGE\020\007\022\016\n" - "\nJUMP_BOOST\020\010\022\n\n\006NAUSEA\020\t\022\020\n\014REGENERATIO" - "N\020\n\022\016\n\nRESISTANCE\020\013\022\023\n\017FIRE_RESISTANCE\020\014" - "\022\023\n\017WATER_BREATHING\020\r\022\020\n\014INVISIBILITY\020\016\022" - "\r\n\tBLINDNESS\020\017\022\020\n\014NIGHT_VISION\020\020\022\n\n\006HUNG" - "ER\020\021\022\014\n\010WEAKNESS\020\022\022\n\n\006POISON\020\023\022\n\n\006WITHER" - "\020\024\022\020\n\014HEALTH_BOOST\020\025\022\016\n\nABSORPTION\020\026\022\016\n\n" - "SATURATION\020\027\022\016\n\nLEVITATION\020\030\022\020\n\014FATAL_PO" - "ISON\020\031\022\021\n\rCONDUIT_POWER\020\032\022\020\n\014SLOW_FALLIN" - "G\020\033\022\014\n\010DARKNESS\020\036*\315\002\n\005Sound\022\021\n\rSOUND_UNK" - "NOWN\020\000\022\n\n\006ATTACK\020\001\022\014\n\010DROWNING\020\002\022\013\n\007BURN" - "ING\020\003\022\010\n\004FALL\020\004\022\010\n\004BURP\020\005\022\007\n\003POP\020\006\022\r\n\tEX" - "PLOSION\020\007\022\013\n\007THUNDER\020\010\022\014\n\010LEVEL_UP\020\t\022\016\n\n" - "EXPERIENCE\020\n\022\023\n\017FIREWORK_LAUNCH\020\013\022\027\n\023FIR" - "EWORK_HUGE_BLAST\020\014\022\022\n\016FIREWORK_BLAST\020\r\022\024" - "\n\020FIREWORK_TWINKLE\020\016\022\014\n\010TELEPORT\020\017\022\r\n\tAR" - "ROW_HIT\020\020\022\016\n\nITEM_BREAK\020\021\022\016\n\nITEM_THROW\020" - "\022\022\t\n\005TOTEM\020\023\022\023\n\017FIRE_EXTINGUISH\020\024*~\n\014Ite" - "mCategory\022\036\n\032ITEM_CATEGORY_CONSTRUCTION\020" - "\000\022\030\n\024ITEM_CATEGORY_NATURE\020\001\022\033\n\027ITEM_CATE" - "GORY_EQUIPMENT\020\002\022\027\n\023ITEM_CATEGORY_ITEMS\020" - "\003B\212\001\n\rcom.df.pluginB\013CommonProtoP\001Z\'gith" - "ub.com/secmc/plugin/proto/generated\242\002\003DP" - "X\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\GP" - "BMetadata\352\002\nDf::Pluginb\006proto3" + "R\005pitch\"L\n\004BBox\022!\n\003min\030\001 \001(\0132\017.df.plugin" + ".Vec3R\003min\022!\n\003max\030\002 \001(\0132\017.df.plugin.Vec3" + "R\003max\"4\n\010BlockPos\022\014\n\001x\030\001 \001(\005R\001x\022\014\n\001y\030\002 \001" + "(\005R\001y\022\014\n\001z\030\003 \001(\005R\001z\"I\n\tItemStack\022\022\n\004name" + "\030\001 \001(\tR\004name\022\022\n\004meta\030\002 \001(\005R\004meta\022\024\n\005coun" + "t\030\003 \001(\005R\005count\"\246\001\n\nBlockState\022\022\n\004name\030\001 " + "\001(\tR\004name\022E\n\nproperties\030\002 \003(\0132%.df.plugi" + "n.BlockState.PropertiesEntryR\nproperties" + "\032=\n\017PropertiesEntry\022\020\n\003key\030\001 \001(\tR\003key\022\024\n" + "\005value\030\002 \001(\tR\005value:\0028\001\"\213\001\n\013LiquidState\022" + "+\n\005block\030\001 \001(\0132\025.df.plugin.BlockStateR\005b" + "lock\022\024\n\005depth\030\002 \001(\005R\005depth\022\030\n\007falling\030\003 " + "\001(\010R\007falling\022\037\n\013liquid_type\030\004 \001(\tR\nliqui" + "dType\"<\n\010WorldRef\022\022\n\004name\030\001 \001(\tR\004name\022\034\n" + "\tdimension\030\002 \001(\tR\tdimension\"\327\001\n\tEntityRe" + "f\022\022\n\004uuid\030\001 \001(\tR\004uuid\022\022\n\004type\030\002 \001(\tR\004typ" + "e\022\027\n\004name\030\003 \001(\tH\000R\004name\210\001\001\0220\n\010position\030\004" + " \001(\0132\017.df.plugin.Vec3H\001R\010position\210\001\001\0224\n\010" + "rotation\030\005 \001(\0132\023.df.plugin.RotationH\002R\010r" + "otation\210\001\001B\007\n\005_nameB\013\n\t_positionB\013\n\t_rot" + "ation\"Y\n\014DamageSource\022\022\n\004type\030\001 \001(\tR\004typ" + "e\022%\n\013description\030\002 \001(\tH\000R\013description\210\001\001" + "B\016\n\014_description\"Z\n\rHealingSource\022\022\n\004typ" + "e\030\001 \001(\tR\004type\022%\n\013description\030\002 \001(\tH\000R\013de" + "scription\210\001\001B\016\n\014_description\"1\n\007Address\022" + "\022\n\004host\030\001 \001(\tR\004host\022\022\n\004port\030\002 \001(\005R\004port\"" + "\332\001\n\024CustomItemDefinition\022\016\n\002id\030\001 \001(\tR\002id" + "\022!\n\014display_name\030\002 \001(\tR\013displayName\022!\n\014t" + "exture_data\030\003 \001(\014R\013textureData\0223\n\010catego" + "ry\030\004 \001(\0162\027.df.plugin.ItemCategoryR\010categ" + "ory\022\031\n\005group\030\005 \001(\tH\000R\005group\210\001\001\022\022\n\004meta\030\006" + " \001(\005R\004metaB\010\n\006_group*D\n\010GameMode\022\014\n\010SURV" + "IVAL\020\000\022\014\n\010CREATIVE\020\001\022\r\n\tADVENTURE\020\002\022\r\n\tS" + "PECTATOR\020\003*:\n\nDifficulty\022\014\n\010PEACEFUL\020\000\022\010" + "\n\004EASY\020\001\022\n\n\006NORMAL\020\002\022\010\n\004HARD\020\003*\342\003\n\nEffec" + "tType\022\022\n\016EFFECT_UNKNOWN\020\000\022\t\n\005SPEED\020\001\022\014\n\010" + "SLOWNESS\020\002\022\t\n\005HASTE\020\003\022\022\n\016MINING_FATIGUE\020" + "\004\022\014\n\010STRENGTH\020\005\022\022\n\016INSTANT_HEALTH\020\006\022\022\n\016I" + "NSTANT_DAMAGE\020\007\022\016\n\nJUMP_BOOST\020\010\022\n\n\006NAUSE" + "A\020\t\022\020\n\014REGENERATION\020\n\022\016\n\nRESISTANCE\020\013\022\023\n" + "\017FIRE_RESISTANCE\020\014\022\023\n\017WATER_BREATHING\020\r\022" + "\020\n\014INVISIBILITY\020\016\022\r\n\tBLINDNESS\020\017\022\020\n\014NIGH" + "T_VISION\020\020\022\n\n\006HUNGER\020\021\022\014\n\010WEAKNESS\020\022\022\n\n\006" + "POISON\020\023\022\n\n\006WITHER\020\024\022\020\n\014HEALTH_BOOST\020\025\022\016" + "\n\nABSORPTION\020\026\022\016\n\nSATURATION\020\027\022\016\n\nLEVITA" + "TION\020\030\022\020\n\014FATAL_POISON\020\031\022\021\n\rCONDUIT_POWE" + "R\020\032\022\020\n\014SLOW_FALLING\020\033\022\014\n\010DARKNESS\020\036*\315\002\n\005" + "Sound\022\021\n\rSOUND_UNKNOWN\020\000\022\n\n\006ATTACK\020\001\022\014\n\010" + "DROWNING\020\002\022\013\n\007BURNING\020\003\022\010\n\004FALL\020\004\022\010\n\004BUR" + "P\020\005\022\007\n\003POP\020\006\022\r\n\tEXPLOSION\020\007\022\013\n\007THUNDER\020\010" + "\022\014\n\010LEVEL_UP\020\t\022\016\n\nEXPERIENCE\020\n\022\023\n\017FIREWO" + "RK_LAUNCH\020\013\022\027\n\023FIREWORK_HUGE_BLAST\020\014\022\022\n\016" + "FIREWORK_BLAST\020\r\022\024\n\020FIREWORK_TWINKLE\020\016\022\014" + "\n\010TELEPORT\020\017\022\r\n\tARROW_HIT\020\020\022\016\n\nITEM_BREA" + "K\020\021\022\016\n\nITEM_THROW\020\022\022\t\n\005TOTEM\020\023\022\023\n\017FIRE_E" + "XTINGUISH\020\024*~\n\014ItemCategory\022\036\n\032ITEM_CATE" + "GORY_CONSTRUCTION\020\000\022\030\n\024ITEM_CATEGORY_NAT" + "URE\020\001\022\033\n\027ITEM_CATEGORY_EQUIPMENT\020\002\022\027\n\023IT" + "EM_CATEGORY_ITEMS\020\003B\212\001\n\rcom.df.pluginB\013C" + "ommonProtoP\001Z\'github.com/secmc/plugin/pr" + "oto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plu" + "gin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin" + "b\006proto3" }; static ::absl::once_flag descriptor_table_common_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_common_2eproto = { false, false, - 2470, + 2608, descriptor_table_protodef_common_2eproto, "common.proto", &descriptor_table_common_2eproto_once, nullptr, 0, - 13, + 14, schemas, file_default_instances, TableStruct_common_2eproto::offsets, @@ -649,21 +688,27 @@ const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL GameMode_descriptor() } PROTOBUF_CONSTINIT const uint32_t GameMode_internal_data_[] = { 262144u, 0u, }; -const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL EffectType_descriptor() { +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Difficulty_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_common_2eproto); return file_level_enum_descriptors_common_2eproto[1]; } +PROTOBUF_CONSTINIT const uint32_t Difficulty_internal_data_[] = { + 262144u, 0u, }; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL EffectType_descriptor() { + ::google::protobuf::internal::AssignDescriptors(&descriptor_table_common_2eproto); + return file_level_enum_descriptors_common_2eproto[2]; +} PROTOBUF_CONSTINIT const uint32_t EffectType_internal_data_[] = { 1835008u, 32u, 4u, }; const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Sound_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_common_2eproto); - return file_level_enum_descriptors_common_2eproto[2]; + return file_level_enum_descriptors_common_2eproto[3]; } PROTOBUF_CONSTINIT const uint32_t Sound_internal_data_[] = { 1376256u, 0u, }; const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL ItemCategory_descriptor() { ::google::protobuf::internal::AssignDescriptors(&descriptor_table_common_2eproto); - return file_level_enum_descriptors_common_2eproto[3]; + return file_level_enum_descriptors_common_2eproto[4]; } PROTOBUF_CONSTINIT const uint32_t ItemCategory_internal_data_[] = { 262144u, 0u, }; @@ -1278,6 +1323,327 @@ ::google::protobuf::Metadata Rotation::GetMetadata() const { } // =================================================================== +class BBox::_Internal { + public: + using HasBits = + decltype(::std::declval()._impl_._has_bits_); + static constexpr ::int32_t kHasBitsOffset = + 8 * PROTOBUF_FIELD_OFFSET(BBox, _impl_._has_bits_); +}; + +BBox::BBox(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, BBox_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:df.plugin.BBox) +} +PROTOBUF_NDEBUG_INLINE BBox::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + [[maybe_unused]] const ::df::plugin::BBox& from_msg) + : _has_bits_{from._has_bits_}, + _cached_size_{0} {} + +BBox::BBox( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, + const BBox& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::Message(arena, BBox_class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::Message(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + BBox* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::uint32_t cached_has_bits = _impl_._has_bits_[0]; + _impl_.min_ = (CheckHasBit(cached_has_bits, 0x00000001U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.min_) + : nullptr; + _impl_.max_ = (CheckHasBit(cached_has_bits, 0x00000002U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.max_) + : nullptr; + + // @@protoc_insertion_point(copy_constructor:df.plugin.BBox) +} +PROTOBUF_NDEBUG_INLINE BBox::Impl_::Impl_( + [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, + [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) + : _cached_size_{0} {} + +inline void BBox::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, min_), + 0, + offsetof(Impl_, max_) - + offsetof(Impl_, min_) + + sizeof(Impl_::max_)); +} +BBox::~BBox() { + // @@protoc_insertion_point(destructor:df.plugin.BBox) + SharedDtor(*this); +} +inline void BBox::SharedDtor(MessageLite& self) { + BBox& this_ = static_cast(self); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); + ABSL_DCHECK(this_.GetArena() == nullptr); + delete this_._impl_.min_; + delete this_._impl_.max_; + this_._impl_.~Impl_(); +} + +inline void* PROTOBUF_NONNULL BBox::PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { + return ::new (mem) BBox(arena); +} +constexpr auto BBox::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BBox), + alignof(BBox)); +} +constexpr auto BBox::InternalGenerateClassData_() { + return ::google::protobuf::internal::ClassDataFull{ + ::google::protobuf::internal::ClassData{ + &_BBox_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &BBox::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &BBox::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &BBox::ByteSizeLong, + &BBox::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(BBox, _impl_._cached_size_), + false, + }, + &BBox::kDescriptorMethods, + &descriptor_table_common_2eproto, + nullptr, // tracker + }; +} + +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const + ::google::protobuf::internal::ClassDataFull BBox_class_data_ = + BBox::InternalGenerateClassData_(); + +PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL +BBox::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&BBox_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(BBox_class_data_.tc_table); + return BBox_class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +BBox::_table_ = { + { + PROTOBUF_FIELD_OFFSET(BBox, _impl_._has_bits_), + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 2, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + BBox_class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallback, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::df::plugin::BBox>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // .df.plugin.Vec3 max = 2 [json_name = "max"]; + {::_pbi::TcParser::FastMtS1, + {18, 1, 1, + PROTOBUF_FIELD_OFFSET(BBox, _impl_.max_)}}, + // .df.plugin.Vec3 min = 1 [json_name = "min"]; + {::_pbi::TcParser::FastMtS1, + {10, 0, 0, + PROTOBUF_FIELD_OFFSET(BBox, _impl_.min_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // .df.plugin.Vec3 min = 1 [json_name = "min"]; + {PROTOBUF_FIELD_OFFSET(BBox, _impl_.min_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.Vec3 max = 2 [json_name = "max"]; + {PROTOBUF_FIELD_OFFSET(BBox, _impl_.max_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, + {{ + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + }}, + {{ + }}, +}; +PROTOBUF_NOINLINE void BBox::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.BBox) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + cached_has_bits = _impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(_impl_.min_ != nullptr); + _impl_.min_->Clear(); + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(_impl_.max_ != nullptr); + _impl_.max_->Clear(); + } + } + _impl_._has_bits_.Clear(); + _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::uint8_t* PROTOBUF_NONNULL BBox::_InternalSerialize( + const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { + const BBox& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::uint8_t* PROTOBUF_NONNULL BBox::_InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + const BBox& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + this_.CheckHasBitConsistency(); + } + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.BBox) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = this_._impl_._has_bits_[0]; + // .df.plugin.Vec3 min = 1 [json_name = "min"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.min_, this_._impl_.min_->GetCachedSize(), target, + stream); + } + + // .df.plugin.Vec3 max = 2 [json_name = "max"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.max_, this_._impl_.max_->GetCachedSize(), target, + stream); + } + + if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = + ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( + this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); + } + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.BBox) + return target; +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) +::size_t BBox::ByteSizeLong(const MessageLite& base) { + const BBox& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE +::size_t BBox::ByteSizeLong() const { + const BBox& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:df.plugin.BBox) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + cached_has_bits = this_._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // .df.plugin.Vec3 min = 1 [json_name = "min"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.min_); + } + // .df.plugin.Vec3 max = 2 [json_name = "max"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.max_); + } + } + return this_.MaybeComputeUnknownFieldsSize(total_size, + &this_._impl_._cached_size_); +} + +void BBox::MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = + static_cast(&to_msg); + auto& from = static_cast(from_msg); + if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { + from.CheckHasBitConsistency(); + } + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.BBox) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + cached_has_bits = from._impl_._has_bits_[0]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + ABSL_DCHECK(from._impl_.min_ != nullptr); + if (_this->_impl_.min_ == nullptr) { + _this->_impl_.min_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.min_); + } else { + _this->_impl_.min_->MergeFrom(*from._impl_.min_); + } + } + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + ABSL_DCHECK(from._impl_.max_ != nullptr); + if (_this->_impl_.max_ == nullptr) { + _this->_impl_.max_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.max_); + } else { + _this->_impl_.max_->MergeFrom(*from._impl_.max_); + } + } + } + _this->_impl_._has_bits_[0] |= cached_has_bits; + _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( + from._internal_metadata_); +} + +void BBox::CopyFrom(const BBox& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.BBox) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void BBox::InternalSwap(BBox* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { + using ::std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(BBox, _impl_.max_) + + sizeof(BBox::_impl_.max_) + - PROTOBUF_FIELD_OFFSET(BBox, _impl_.min_)>( + reinterpret_cast(&_impl_.min_), + reinterpret_cast(&other->_impl_.min_)); +} + +::google::protobuf::Metadata BBox::GetMetadata() const { + return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); +} +// =================================================================== + class BlockPos::_Internal { public: using HasBits = diff --git a/packages/cpp/src/generated/common.pb.h b/packages/cpp/src/generated/common.pb.h index cba1dd3..d4a37fc 100644 --- a/packages/cpp/src/generated/common.pb.h +++ b/packages/cpp/src/generated/common.pb.h @@ -59,6 +59,8 @@ extern const ::google::protobuf::internal::DescriptorTable descriptor_table_comm } // extern "C" namespace df { namespace plugin { +enum Difficulty : int; +extern const uint32_t Difficulty_internal_data_[]; enum EffectType : int; extern const uint32_t EffectType_internal_data_[]; enum GameMode : int; @@ -71,6 +73,10 @@ class Address; struct AddressDefaultTypeInternal; extern AddressDefaultTypeInternal _Address_default_instance_; extern const ::google::protobuf::internal::ClassDataFull Address_class_data_; +class BBox; +struct BBoxDefaultTypeInternal; +extern BBoxDefaultTypeInternal _BBox_default_instance_; +extern const ::google::protobuf::internal::ClassDataFull BBox_class_data_; class BlockPos; struct BlockPosDefaultTypeInternal; extern BlockPosDefaultTypeInternal _BlockPos_default_instance_; @@ -124,6 +130,9 @@ extern const ::google::protobuf::internal::ClassDataFull WorldRef_class_data_; namespace google { namespace protobuf { template <> +internal::EnumTraitsT<::df::plugin::Difficulty_internal_data_> + internal::EnumTraitsImpl::value<::df::plugin::Difficulty>; +template <> internal::EnumTraitsT<::df::plugin::EffectType_internal_data_> internal::EnumTraitsImpl::value<::df::plugin::EffectType>; template <> @@ -178,6 +187,44 @@ inline bool GameMode_Parse( return ::google::protobuf::internal::ParseNamedEnum(GameMode_descriptor(), name, value); } +enum Difficulty : int { + PEACEFUL = 0, + EASY = 1, + NORMAL = 2, + HARD = 3, + Difficulty_INT_MIN_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::min(), + Difficulty_INT_MAX_SENTINEL_DO_NOT_USE_ = + ::std::numeric_limits<::int32_t>::max(), +}; + +extern const uint32_t Difficulty_internal_data_[]; +inline constexpr Difficulty Difficulty_MIN = + static_cast(0); +inline constexpr Difficulty Difficulty_MAX = + static_cast(3); +inline bool Difficulty_IsValid(int value) { + return 0 <= value && value <= 3; +} +inline constexpr int Difficulty_ARRAYSIZE = 3 + 1; +const ::google::protobuf::EnumDescriptor* PROTOBUF_NONNULL Difficulty_descriptor(); +template +const ::std::string& Difficulty_Name(T value) { + static_assert(::std::is_same::value || + ::std::is_integral::value, + "Incorrect type passed to Difficulty_Name()."); + return Difficulty_Name(static_cast(value)); +} +template <> +inline const ::std::string& Difficulty_Name(Difficulty value) { + return ::google::protobuf::internal::NameOfDenseEnum( + static_cast(value)); +} +inline bool Difficulty_Parse( + ::absl::string_view name, Difficulty* PROTOBUF_NONNULL value) { + return ::google::protobuf::internal::ParseNamedEnum(Difficulty_descriptor(), name, + value); +} enum EffectType : int { EFFECT_UNKNOWN = 0, SPEED = 1, @@ -395,7 +442,7 @@ class WorldRef final : public ::google::protobuf::Message return *reinterpret_cast( &_WorldRef_default_instance_); } - static constexpr int kIndexInFileMessages = 7; + static constexpr int kIndexInFileMessages = 8; friend void swap(WorldRef& a, WorldRef& b) { a.Swap(&b); } inline void Swap(WorldRef* PROTOBUF_NONNULL other) { if (other == this) return; @@ -1023,7 +1070,7 @@ class ItemStack final : public ::google::protobuf::Message return *reinterpret_cast( &_ItemStack_default_instance_); } - static constexpr int kIndexInFileMessages = 3; + static constexpr int kIndexInFileMessages = 4; friend void swap(ItemStack& a, ItemStack& b) { a.Swap(&b); } inline void Swap(ItemStack* PROTOBUF_NONNULL other) { if (other == this) return; @@ -1242,7 +1289,7 @@ class HealingSource final : public ::google::protobuf::Message return *reinterpret_cast( &_HealingSource_default_instance_); } - static constexpr int kIndexInFileMessages = 10; + static constexpr int kIndexInFileMessages = 11; friend void swap(HealingSource& a, HealingSource& b) { a.Swap(&b); } inline void Swap(HealingSource* PROTOBUF_NONNULL other) { if (other == this) return; @@ -1455,7 +1502,7 @@ class DamageSource final : public ::google::protobuf::Message return *reinterpret_cast( &_DamageSource_default_instance_); } - static constexpr int kIndexInFileMessages = 9; + static constexpr int kIndexInFileMessages = 10; friend void swap(DamageSource& a, DamageSource& b) { a.Swap(&b); } inline void Swap(DamageSource* PROTOBUF_NONNULL other) { if (other == this) return; @@ -1668,7 +1715,7 @@ class CustomItemDefinition final : public ::google::protobuf::Message return *reinterpret_cast( &_CustomItemDefinition_default_instance_); } - static constexpr int kIndexInFileMessages = 12; + static constexpr int kIndexInFileMessages = 13; friend void swap(CustomItemDefinition& a, CustomItemDefinition& b) { a.Swap(&b); } inline void Swap(CustomItemDefinition* PROTOBUF_NONNULL other) { if (other == this) return; @@ -1978,7 +2025,7 @@ class BlockPos final : public ::google::protobuf::Message return *reinterpret_cast( &_BlockPos_default_instance_); } - static constexpr int kIndexInFileMessages = 2; + static constexpr int kIndexInFileMessages = 3; friend void swap(BlockPos& a, BlockPos& b) { a.Swap(&b); } inline void Swap(BlockPos* PROTOBUF_NONNULL other) { if (other == this) return; @@ -2192,7 +2239,7 @@ class Address final : public ::google::protobuf::Message return *reinterpret_cast( &_Address_default_instance_); } - static constexpr int kIndexInFileMessages = 11; + static constexpr int kIndexInFileMessages = 12; friend void swap(Address& a, Address& b) { a.Swap(&b); } inline void Swap(Address* PROTOBUF_NONNULL other) { if (other == this) return; @@ -2399,7 +2446,7 @@ class EntityRef final : public ::google::protobuf::Message return *reinterpret_cast( &_EntityRef_default_instance_); } - static constexpr int kIndexInFileMessages = 8; + static constexpr int kIndexInFileMessages = 9; friend void swap(EntityRef& a, EntityRef& b) { a.Swap(&b); } inline void Swap(EntityRef* PROTOBUF_NONNULL other) { if (other == this) return; @@ -2663,7 +2710,7 @@ class BlockState final : public ::google::protobuf::Message return *reinterpret_cast( &_BlockState_default_instance_); } - static constexpr int kIndexInFileMessages = 5; + static constexpr int kIndexInFileMessages = 6; friend void swap(BlockState& a, BlockState& b) { a.Swap(&b); } inline void Swap(BlockState* PROTOBUF_NONNULL other) { if (other == this) return; @@ -2823,6 +2870,218 @@ class BlockState final : public ::google::protobuf::Message extern const ::google::protobuf::internal::ClassDataFull BlockState_class_data_; // ------------------------------------------------------------------- +class BBox final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.BBox) */ { + public: + inline BBox() : BBox(nullptr) {} + ~BBox() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(BBox* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(BBox)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR BBox(::google::protobuf::internal::ConstantInitialized); + + inline BBox(const BBox& from) : BBox(nullptr, from) {} + inline BBox(BBox&& from) noexcept + : BBox(nullptr, ::std::move(from)) {} + inline BBox& operator=(const BBox& from) { + CopyFrom(from); + return *this; + } + inline BBox& operator=(BBox&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } + + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const BBox& default_instance() { + return *reinterpret_cast( + &_BBox_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(BBox& a, BBox& b) { a.Swap(&b); } + inline void Swap(BBox* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BBox* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BBox* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const BBox& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const BBox& from) { BBox::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(BBox* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.BBox"; } + + explicit BBox(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + BBox(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const BBox& from); + BBox( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, BBox&& from) noexcept + : BBox(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); + + public: + static constexpr auto InternalGenerateClassData_(); + + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kMinFieldNumber = 1, + kMaxFieldNumber = 2, + }; + // .df.plugin.Vec3 min = 1 [json_name = "min"]; + bool has_min() const; + void clear_min() ; + const ::df::plugin::Vec3& min() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_min(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_min(); + void set_allocated_min(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_min(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_min(); + + private: + const ::df::plugin::Vec3& _internal_min() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_min(); + + public: + // .df.plugin.Vec3 max = 2 [json_name = "max"]; + bool has_max() const; + void clear_max() ; + const ::df::plugin::Vec3& max() const; + [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_max(); + ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_max(); + void set_allocated_max(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_max(::df::plugin::Vec3* PROTOBUF_NULLABLE value); + ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_max(); + + private: + const ::df::plugin::Vec3& _internal_max() const; + ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_max(); + + public: + // @@protoc_insertion_point(class_scope:df.plugin.BBox) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<1, 2, + 2, 0, + 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const BBox& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE min_; + ::df::plugin::Vec3* PROTOBUF_NULLABLE max_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_common_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull BBox_class_data_; +// ------------------------------------------------------------------- + class LiquidState final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:df.plugin.LiquidState) */ { public: @@ -2878,7 +3137,7 @@ class LiquidState final : public ::google::protobuf::Message return *reinterpret_cast( &_LiquidState_default_instance_); } - static constexpr int kIndexInFileMessages = 6; + static constexpr int kIndexInFileMessages = 7; friend void swap(LiquidState& a, LiquidState& b) { a.Swap(&b); } inline void Swap(LiquidState* PROTOBUF_NONNULL other) { if (other == this) return; @@ -3205,6 +3464,208 @@ inline void Rotation::_internal_set_pitch(float value) { // ------------------------------------------------------------------- +// BBox + +// .df.plugin.Vec3 min = 1 [json_name = "min"]; +inline bool BBox::has_min() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); + PROTOBUF_ASSUME(!value || _impl_.min_ != nullptr); + return value; +} +inline void BBox::clear_min() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.min_ != nullptr) _impl_.min_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000001U); +} +inline const ::df::plugin::Vec3& BBox::_internal_min() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.min_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +} +inline const ::df::plugin::Vec3& BBox::min() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.BBox.min) + return _internal_min(); +} +inline void BBox::unsafe_arena_set_allocated_min( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.min_); + } + _impl_.min_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.BBox.min) +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE BBox::release_min() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::Vec3* released = _impl_.min_; + _impl_.min_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE BBox::unsafe_arena_release_min() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.BBox.min) + + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::Vec3* temp = _impl_.min_; + _impl_.min_ = nullptr; + return temp; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL BBox::_internal_mutable_min() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.min_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.min_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.min_; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL BBox::mutable_min() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + ::df::plugin::Vec3* _msg = _internal_mutable_min(); + // @@protoc_insertion_point(field_mutable:df.plugin.BBox.min) + return _msg; +} +inline void BBox::set_allocated_min(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.min_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000001U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000001U); + } + + _impl_.min_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.BBox.min) +} + +// .df.plugin.Vec3 max = 2 [json_name = "max"]; +inline bool BBox::has_max() const { + bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); + PROTOBUF_ASSUME(!value || _impl_.max_ != nullptr); + return value; +} +inline void BBox::clear_max() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.max_ != nullptr) _impl_.max_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000002U); +} +inline const ::df::plugin::Vec3& BBox::_internal_max() const { + ::google::protobuf::internal::TSanRead(&_impl_); + const ::df::plugin::Vec3* p = _impl_.max_; + return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); +} +inline const ::df::plugin::Vec3& BBox::max() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.BBox.max) + return _internal_max(); +} +inline void BBox::unsafe_arena_set_allocated_max( + ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (GetArena() == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.max_); + } + _impl_.max_ = reinterpret_cast<::df::plugin::Vec3*>(value); + if (value != nullptr) { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.BBox.max) +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE BBox::release_max() { + ::google::protobuf::internal::TSanWrite(&_impl_); + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* released = _impl_.max_; + _impl_.max_ = nullptr; + if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { + auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + if (GetArena() == nullptr) { + delete old; + } + } else { + if (GetArena() != nullptr) { + released = ::google::protobuf::internal::DuplicateIfNonNull(released); + } + } + return released; +} +inline ::df::plugin::Vec3* PROTOBUF_NULLABLE BBox::unsafe_arena_release_max() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:df.plugin.BBox.max) + + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* temp = _impl_.max_; + _impl_.max_ = nullptr; + return temp; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL BBox::_internal_mutable_max() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (_impl_.max_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); + _impl_.max_ = reinterpret_cast<::df::plugin::Vec3*>(p); + } + return _impl_.max_; +} +inline ::df::plugin::Vec3* PROTOBUF_NONNULL BBox::mutable_max() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + ::df::plugin::Vec3* _msg = _internal_mutable_max(); + // @@protoc_insertion_point(field_mutable:df.plugin.BBox.max) + return _msg; +} +inline void BBox::set_allocated_max(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { + ::google::protobuf::Arena* message_arena = GetArena(); + ::google::protobuf::internal::TSanWrite(&_impl_); + if (message_arena == nullptr) { + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.max_); + } + + if (value != nullptr) { + ::google::protobuf::Arena* submessage_arena = value->GetArena(); + if (message_arena != submessage_arena) { + value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); + } + SetHasBit(_impl_._has_bits_[0], 0x00000002U); + } else { + ClearHasBit(_impl_._has_bits_[0], 0x00000002U); + } + + _impl_.max_ = reinterpret_cast<::df::plugin::Vec3*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.BBox.max) +} + +// ------------------------------------------------------------------- + // BlockPos // int32 x = 1 [json_name = "x"]; @@ -4964,6 +5425,12 @@ inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::df::plugin::Ga return ::df::plugin::GameMode_descriptor(); } template <> +struct is_proto_enum<::df::plugin::Difficulty> : std::true_type {}; +template <> +inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::df::plugin::Difficulty>() { + return ::df::plugin::Difficulty_descriptor(); +} +template <> struct is_proto_enum<::df::plugin::EffectType> : std::true_type {}; template <> inline const EnumDescriptor* PROTOBUF_NONNULL GetEnumDescriptor<::df::plugin::EffectType>() { diff --git a/packages/cpp/src/generated/plugin.pb.cc b/packages/cpp/src/generated/plugin.pb.cc index e7b7393..3a9cb6d 100644 --- a/packages/cpp/src/generated/plugin.pb.cc +++ b/packages/cpp/src/generated/plugin.pb.cc @@ -215,65 +215,65 @@ struct PluginHelloDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PluginHelloDefaultTypeInternal _PluginHello_default_instance_; -inline constexpr PluginToHost::Impl_::Impl_( +inline constexpr EventEnvelope::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - plugin_id_( + event_id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), + type_{static_cast< ::df::plugin::EventType >(0)}, + expects_response_{false}, payload_{}, _oneof_case_{} {} template -PROTOBUF_CONSTEXPR PluginToHost::PluginToHost(::_pbi::ConstantInitialized) +PROTOBUF_CONSTEXPR EventEnvelope::EventEnvelope(::_pbi::ConstantInitialized) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(PluginToHost_class_data_.base()), + : ::google::protobuf::Message(EventEnvelope_class_data_.base()), #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(), #endif // PROTOBUF_CUSTOM_VTABLE _impl_(::_pbi::ConstantInitialized()) { } -struct PluginToHostDefaultTypeInternal { - PROTOBUF_CONSTEXPR PluginToHostDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~PluginToHostDefaultTypeInternal() {} +struct EventEnvelopeDefaultTypeInternal { + PROTOBUF_CONSTEXPR EventEnvelopeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EventEnvelopeDefaultTypeInternal() {} union { - PluginToHost _instance; + EventEnvelope _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PluginToHostDefaultTypeInternal _PluginToHost_default_instance_; + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventEnvelopeDefaultTypeInternal _EventEnvelope_default_instance_; -inline constexpr EventEnvelope::Impl_::Impl_( +inline constexpr PluginToHost::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, - event_id_( + plugin_id_( &::google::protobuf::internal::fixed_address_empty_string, ::_pbi::ConstantInitialized()), - type_{static_cast< ::df::plugin::EventType >(0)}, - expects_response_{false}, payload_{}, _oneof_case_{} {} template -PROTOBUF_CONSTEXPR EventEnvelope::EventEnvelope(::_pbi::ConstantInitialized) +PROTOBUF_CONSTEXPR PluginToHost::PluginToHost(::_pbi::ConstantInitialized) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(EventEnvelope_class_data_.base()), + : ::google::protobuf::Message(PluginToHost_class_data_.base()), #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(), #endif // PROTOBUF_CUSTOM_VTABLE _impl_(::_pbi::ConstantInitialized()) { } -struct EventEnvelopeDefaultTypeInternal { - PROTOBUF_CONSTEXPR EventEnvelopeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~EventEnvelopeDefaultTypeInternal() {} +struct PluginToHostDefaultTypeInternal { + PROTOBUF_CONSTEXPR PluginToHostDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PluginToHostDefaultTypeInternal() {} union { - EventEnvelope _instance; + PluginToHost _instance; }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EventEnvelopeDefaultTypeInternal _EventEnvelope_default_instance_; + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PluginToHostDefaultTypeInternal _PluginToHost_default_instance_; inline constexpr HostToPlugin::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept @@ -315,18 +315,20 @@ const ::uint32_t 0x085, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_._oneof_case_[0]), - 10, // hasbit index offset + 11, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.plugin_id_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), + PROTOBUF_FIELD_OFFSET(::df::plugin::HostToPlugin, _impl_.payload_), 0, ~0u, ~0u, ~0u, ~0u, + ~0u, 0x000, // bitmap 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::ServerInformationResponse, _impl_._has_bits_), @@ -501,15 +503,15 @@ const ::uint32_t static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::df::plugin::HostToPlugin)}, - {15, sizeof(::df::plugin::ServerInformationRequest)}, - {16, sizeof(::df::plugin::ServerInformationResponse)}, - {21, sizeof(::df::plugin::HostHello)}, - {26, sizeof(::df::plugin::HostShutdown)}, - {31, sizeof(::df::plugin::EventEnvelope)}, - {140, sizeof(::df::plugin::PluginToHost)}, - {159, sizeof(::df::plugin::PluginHello)}, - {172, sizeof(::df::plugin::LogMessage)}, - {179, sizeof(::df::plugin::EventSubscribe)}, + {17, sizeof(::df::plugin::ServerInformationRequest)}, + {18, sizeof(::df::plugin::ServerInformationResponse)}, + {23, sizeof(::df::plugin::HostHello)}, + {28, sizeof(::df::plugin::HostShutdown)}, + {33, sizeof(::df::plugin::EventEnvelope)}, + {142, sizeof(::df::plugin::PluginToHost)}, + {161, sizeof(::df::plugin::PluginHello)}, + {174, sizeof(::df::plugin::LogMessage)}, + {181, sizeof(::df::plugin::EventSubscribe)}, }; static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::df::plugin::_HostToPlugin_default_instance_._instance, @@ -528,170 +530,171 @@ const char descriptor_table_protodef_plugin_2eproto[] ABSL_ATTRIBUTE_SECTION_VAR "\n\014plugin.proto\022\tdf.plugin\032\023player_events" ".proto\032\022world_events.proto\032\rcommand.prot" "o\032\ractions.proto\032\017mutations.proto\032\014commo" - "n.proto\"\226\002\n\014HostToPlugin\022\033\n\tplugin_id\030\001 " + "n.proto\"\326\002\n\014HostToPlugin\022\033\n\tplugin_id\030\001 " "\001(\tR\010pluginId\022,\n\005hello\030\n \001(\0132\024.df.plugin" ".HostHelloH\000R\005hello\0225\n\010shutdown\030\013 \001(\0132\027." "df.plugin.HostShutdownH\000R\010shutdown\022G\n\013se" "rver_info\030\014 \001(\0132$.df.plugin.ServerInform" "ationResponseH\000R\nserverInfo\0220\n\005event\030\024 \001" - "(\0132\030.df.plugin.EventEnvelopeH\000R\005eventB\t\n" - "\007payload\"\032\n\030ServerInformationRequest\"5\n\031" - "ServerInformationResponse\022\030\n\007plugins\030\001 \003" - "(\tR\007plugins\",\n\tHostHello\022\037\n\013api_version\030" - "\001 \001(\tR\napiVersion\"&\n\014HostShutdown\022\026\n\006rea" - "son\030\001 \001(\tR\006reason\"\346\036\n\rEventEnvelope\022\031\n\010e" - "vent_id\030\001 \001(\tR\007eventId\022(\n\004type\030\002 \001(\0162\024.d" - "f.plugin.EventTypeR\004type\022)\n\020expects_resp" - "onse\030\003 \001(\010R\017expectsResponse\022=\n\013player_jo" - "in\030\n \001(\0132\032.df.plugin.PlayerJoinEventH\000R\n" - "playerJoin\022=\n\013player_quit\030\013 \001(\0132\032.df.plu" - "gin.PlayerQuitEventH\000R\nplayerQuit\022=\n\013pla" - "yer_move\030\014 \001(\0132\032.df.plugin.PlayerMoveEve" - "ntH\000R\nplayerMove\022=\n\013player_jump\030\r \001(\0132\032." - "df.plugin.PlayerJumpEventH\000R\nplayerJump\022" - "I\n\017player_teleport\030\016 \001(\0132\036.df.plugin.Pla" - "yerTeleportEventH\000R\016playerTeleport\022S\n\023pl" - "ayer_change_world\030\017 \001(\0132!.df.plugin.Play" - "erChangeWorldEventH\000R\021playerChangeWorld\022" - "V\n\024player_toggle_sprint\030\020 \001(\0132\".df.plugi" - "n.PlayerToggleSprintEventH\000R\022playerToggl" - "eSprint\022S\n\023player_toggle_sneak\030\021 \001(\0132!.d" - "f.plugin.PlayerToggleSneakEventH\000R\021playe" - "rToggleSneak\022*\n\004chat\030\022 \001(\0132\024.df.plugin.C" - "hatEventH\000R\004chat\022J\n\020player_food_loss\030\023 \001" - "(\0132\036.df.plugin.PlayerFoodLossEventH\000R\016pl" - "ayerFoodLoss\022=\n\013player_heal\030\024 \001(\0132\032.df.p" - "lugin.PlayerHealEventH\000R\nplayerHeal\022=\n\013p" - "layer_hurt\030\025 \001(\0132\032.df.plugin.PlayerHurtE" - "ventH\000R\nplayerHurt\022@\n\014player_death\030\026 \001(\013" - "2\033.df.plugin.PlayerDeathEventH\000R\013playerD" - "eath\022F\n\016player_respawn\030\027 \001(\0132\035.df.plugin" - ".PlayerRespawnEventH\000R\rplayerRespawn\022P\n\022" - "player_skin_change\030\030 \001(\0132 .df.plugin.Pla" - "yerSkinChangeEventH\000R\020playerSkinChange\022\\" - "\n\026player_fire_extinguish\030\031 \001(\0132$.df.plug" - "in.PlayerFireExtinguishEventH\000R\024playerFi" - "reExtinguish\022P\n\022player_start_break\030\032 \001(\013" - "2 .df.plugin.PlayerStartBreakEventH\000R\020pl" - "ayerStartBreak\022=\n\013block_break\030\033 \001(\0132\032.df" - ".plugin.BlockBreakEventH\000R\nblockBreak\022P\n" - "\022player_block_place\030\034 \001(\0132 .df.plugin.Pl" - "ayerBlockPlaceEventH\000R\020playerBlockPlace\022" - "M\n\021player_block_pick\030\035 \001(\0132\037.df.plugin.P" - "layerBlockPickEventH\000R\017playerBlockPick\022G" - "\n\017player_item_use\030\036 \001(\0132\035.df.plugin.Play" - "erItemUseEventH\000R\rplayerItemUse\022^\n\030playe" - "r_item_use_on_block\030\037 \001(\0132$.df.plugin.Pl" - "ayerItemUseOnBlockEventH\000R\024playerItemUse" - "OnBlock\022a\n\031player_item_use_on_entity\030 \001" - "(\0132%.df.plugin.PlayerItemUseOnEntityEven" - "tH\000R\025playerItemUseOnEntity\022S\n\023player_ite" - "m_release\030! \001(\0132!.df.plugin.PlayerItemRe" - "leaseEventH\000R\021playerItemRelease\022S\n\023playe" - "r_item_consume\030\" \001(\0132!.df.plugin.PlayerI" - "temConsumeEventH\000R\021playerItemConsume\022V\n\024" - "player_attack_entity\030# \001(\0132\".df.plugin.P" - "layerAttackEntityEventH\000R\022playerAttackEn" - "tity\022\\\n\026player_experience_gain\030$ \001(\0132$.d" - "f.plugin.PlayerExperienceGainEventH\000R\024pl" - "ayerExperienceGain\022J\n\020player_punch_air\030%" - " \001(\0132\036.df.plugin.PlayerPunchAirEventH\000R\016" - "playerPunchAir\022J\n\020player_sign_edit\030& \001(\013" - "2\036.df.plugin.PlayerSignEditEventH\000R\016play" - "erSignEdit\022`\n\030player_lectern_page_turn\030\'" - " \001(\0132%.df.plugin.PlayerLecternPageTurnEv" - "entH\000R\025playerLecternPageTurn\022P\n\022player_i" - "tem_damage\030( \001(\0132 .df.plugin.PlayerItemD" - "amageEventH\000R\020playerItemDamage\022P\n\022player" - "_item_pickup\030) \001(\0132 .df.plugin.PlayerIte" - "mPickupEventH\000R\020playerItemPickup\022]\n\027play" - "er_held_slot_change\030* \001(\0132$.df.plugin.Pl" - "ayerHeldSlotChangeEventH\000R\024playerHeldSlo" - "tChange\022J\n\020player_item_drop\030+ \001(\0132\036.df.p" - "lugin.PlayerItemDropEventH\000R\016playerItemD" - "rop\022I\n\017player_transfer\030, \001(\0132\036.df.plugin" - ".PlayerTransferEventH\000R\016playerTransfer\0223" - "\n\007command\030- \001(\0132\027.df.plugin.CommandEvent" - "H\000R\007command\022R\n\022player_diagnostics\030. \001(\0132" - "!.df.plugin.PlayerDiagnosticsEventH\000R\021pl" - "ayerDiagnostics\022M\n\021world_liquid_flow\030F \001" - "(\0132\037.df.plugin.WorldLiquidFlowEventH\000R\017w" - "orldLiquidFlow\022P\n\022world_liquid_decay\030G \001" - "(\0132 .df.plugin.WorldLiquidDecayEventH\000R\020" - "worldLiquidDecay\022S\n\023world_liquid_harden\030" - "H \001(\0132!.df.plugin.WorldLiquidHardenEvent" - "H\000R\021worldLiquidHarden\022=\n\013world_sound\030I \001" - "(\0132\032.df.plugin.WorldSoundEventH\000R\nworldS" - "ound\022M\n\021world_fire_spread\030J \001(\0132\037.df.plu" - "gin.WorldFireSpreadEventH\000R\017worldFireSpr" - "ead\022J\n\020world_block_burn\030K \001(\0132\036.df.plugi" - "n.WorldBlockBurnEventH\000R\016worldBlockBurn\022" - "P\n\022world_crop_trample\030L \001(\0132 .df.plugin." - "WorldCropTrampleEventH\000R\020worldCropTrampl" - "e\022P\n\022world_leaves_decay\030M \001(\0132 .df.plugi" - "n.WorldLeavesDecayEventH\000R\020worldLeavesDe" - "cay\022P\n\022world_entity_spawn\030N \001(\0132 .df.plu" - "gin.WorldEntitySpawnEventH\000R\020worldEntity" - "Spawn\022V\n\024world_entity_despawn\030O \001(\0132\".df" - ".plugin.WorldEntityDespawnEventH\000R\022world" - "EntityDespawn\022I\n\017world_explosion\030P \001(\0132\036" - ".df.plugin.WorldExplosionEventH\000R\016worldE" - "xplosion\022=\n\013world_close\030Q \001(\0132\032.df.plugi" - "n.WorldCloseEventH\000R\nworldCloseB\t\n\007paylo" - "ad\"\205\003\n\014PluginToHost\022\033\n\tplugin_id\030\001 \001(\tR\010" - "pluginId\022.\n\005hello\030\n \001(\0132\026.df.plugin.Plug" - "inHelloH\000R\005hello\0229\n\tsubscribe\030\013 \001(\0132\031.df" - ".plugin.EventSubscribeH\000R\tsubscribe\022F\n\013s" - "erver_info\030\014 \001(\0132#.df.plugin.ServerInfor" - "mationRequestH\000R\nserverInfo\0222\n\007actions\030\024" - " \001(\0132\026.df.plugin.ActionBatchH\000R\007actions\022" - ")\n\003log\030\036 \001(\0132\025.df.plugin.LogMessageH\000R\003l" - "og\022;\n\014event_result\030( \001(\0132\026.df.plugin.Eve" - "ntResultH\000R\013eventResultB\t\n\007payload\"\324\001\n\013P" - "luginHello\022\022\n\004name\030\001 \001(\tR\004name\022\030\n\007versio" - "n\030\002 \001(\tR\007version\022\037\n\013api_version\030\003 \001(\tR\na" - "piVersion\0222\n\010commands\030\004 \003(\0132\026.df.plugin." - "CommandSpecR\010commands\022B\n\014custom_items\030\005 " - "\003(\0132\037.df.plugin.CustomItemDefinitionR\013cu" - "stomItems\"<\n\nLogMessage\022\024\n\005level\030\001 \001(\tR\005" - "level\022\030\n\007message\030\002 \001(\tR\007message\">\n\016Event" - "Subscribe\022,\n\006events\030\001 \003(\0162\024.df.plugin.Ev" - "entTypeR\006events*\212\t\n\tEventType\022\032\n\026EVENT_T" - "YPE_UNSPECIFIED\020\000\022\022\n\016EVENT_TYPE_ALL\020\001\022\017\n" - "\013PLAYER_JOIN\020\n\022\017\n\013PLAYER_QUIT\020\013\022\017\n\013PLAYE" - "R_MOVE\020\014\022\017\n\013PLAYER_JUMP\020\r\022\023\n\017PLAYER_TELE" - "PORT\020\016\022\027\n\023PLAYER_CHANGE_WORLD\020\017\022\030\n\024PLAYE" - "R_TOGGLE_SPRINT\020\020\022\027\n\023PLAYER_TOGGLE_SNEAK" - "\020\021\022\010\n\004CHAT\020\022\022\024\n\020PLAYER_FOOD_LOSS\020\023\022\017\n\013PL" - "AYER_HEAL\020\024\022\017\n\013PLAYER_HURT\020\025\022\020\n\014PLAYER_D" - "EATH\020\026\022\022\n\016PLAYER_RESPAWN\020\027\022\026\n\022PLAYER_SKI" - "N_CHANGE\020\030\022\032\n\026PLAYER_FIRE_EXTINGUISH\020\031\022\026" - "\n\022PLAYER_START_BREAK\020\032\022\026\n\022PLAYER_BLOCK_B" - "REAK\020\033\022\026\n\022PLAYER_BLOCK_PLACE\020\034\022\025\n\021PLAYER" - "_BLOCK_PICK\020\035\022\023\n\017PLAYER_ITEM_USE\020\036\022\034\n\030PL" - "AYER_ITEM_USE_ON_BLOCK\020\037\022\035\n\031PLAYER_ITEM_" - "USE_ON_ENTITY\020 \022\027\n\023PLAYER_ITEM_RELEASE\020!" - "\022\027\n\023PLAYER_ITEM_CONSUME\020\"\022\030\n\024PLAYER_ATTA" - "CK_ENTITY\020#\022\032\n\026PLAYER_EXPERIENCE_GAIN\020$\022" - "\024\n\020PLAYER_PUNCH_AIR\020%\022\024\n\020PLAYER_SIGN_EDI" - "T\020&\022\034\n\030PLAYER_LECTERN_PAGE_TURN\020\'\022\026\n\022PLA" - "YER_ITEM_DAMAGE\020(\022\026\n\022PLAYER_ITEM_PICKUP\020" - ")\022\033\n\027PLAYER_HELD_SLOT_CHANGE\020*\022\024\n\020PLAYER" - "_ITEM_DROP\020+\022\023\n\017PLAYER_TRANSFER\020,\022\013\n\007COM" - "MAND\020-\022\026\n\022PLAYER_DIAGNOSTICS\020.\022\025\n\021WORLD_" - "LIQUID_FLOW\020F\022\026\n\022WORLD_LIQUID_DECAY\020G\022\027\n" - "\023WORLD_LIQUID_HARDEN\020H\022\017\n\013WORLD_SOUND\020I\022" - "\025\n\021WORLD_FIRE_SPREAD\020J\022\024\n\020WORLD_BLOCK_BU" - "RN\020K\022\026\n\022WORLD_CROP_TRAMPLE\020L\022\026\n\022WORLD_LE" - "AVES_DECAY\020M\022\026\n\022WORLD_ENTITY_SPAWN\020N\022\030\n\024" - "WORLD_ENTITY_DESPAWN\020O\022\023\n\017WORLD_EXPLOSIO" - "N\020P\022\017\n\013WORLD_CLOSE\020Q2M\n\006Plugin\022C\n\013EventS" - "tream\022\027.df.plugin.PluginToHost\032\027.df.plug" - "in.HostToPlugin(\0010\001B\212\001\n\rcom.df.pluginB\013P" - "luginProtoP\001Z\'github.com/secmc/plugin/pr" - "oto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plu" - "gin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin" - "b\006proto3" + "(\0132\030.df.plugin.EventEnvelopeH\000R\005event\022>\n" + "\raction_result\030\025 \001(\0132\027.df.plugin.ActionR" + "esultH\000R\014actionResultB\t\n\007payload\"\032\n\030Serv" + "erInformationRequest\"5\n\031ServerInformatio" + "nResponse\022\030\n\007plugins\030\001 \003(\tR\007plugins\",\n\tH" + "ostHello\022\037\n\013api_version\030\001 \001(\tR\napiVersio" + "n\"&\n\014HostShutdown\022\026\n\006reason\030\001 \001(\tR\006reaso" + "n\"\346\036\n\rEventEnvelope\022\031\n\010event_id\030\001 \001(\tR\007e" + "ventId\022(\n\004type\030\002 \001(\0162\024.df.plugin.EventTy" + "peR\004type\022)\n\020expects_response\030\003 \001(\010R\017expe" + "ctsResponse\022=\n\013player_join\030\n \001(\0132\032.df.pl" + "ugin.PlayerJoinEventH\000R\nplayerJoin\022=\n\013pl" + "ayer_quit\030\013 \001(\0132\032.df.plugin.PlayerQuitEv" + "entH\000R\nplayerQuit\022=\n\013player_move\030\014 \001(\0132\032" + ".df.plugin.PlayerMoveEventH\000R\nplayerMove" + "\022=\n\013player_jump\030\r \001(\0132\032.df.plugin.Player" + "JumpEventH\000R\nplayerJump\022I\n\017player_telepo" + "rt\030\016 \001(\0132\036.df.plugin.PlayerTeleportEvent" + "H\000R\016playerTeleport\022S\n\023player_change_worl" + "d\030\017 \001(\0132!.df.plugin.PlayerChangeWorldEve" + "ntH\000R\021playerChangeWorld\022V\n\024player_toggle" + "_sprint\030\020 \001(\0132\".df.plugin.PlayerToggleSp" + "rintEventH\000R\022playerToggleSprint\022S\n\023playe" + "r_toggle_sneak\030\021 \001(\0132!.df.plugin.PlayerT" + "oggleSneakEventH\000R\021playerToggleSneak\022*\n\004" + "chat\030\022 \001(\0132\024.df.plugin.ChatEventH\000R\004chat" + "\022J\n\020player_food_loss\030\023 \001(\0132\036.df.plugin.P" + "layerFoodLossEventH\000R\016playerFoodLoss\022=\n\013" + "player_heal\030\024 \001(\0132\032.df.plugin.PlayerHeal" + "EventH\000R\nplayerHeal\022=\n\013player_hurt\030\025 \001(\013" + "2\032.df.plugin.PlayerHurtEventH\000R\nplayerHu" + "rt\022@\n\014player_death\030\026 \001(\0132\033.df.plugin.Pla" + "yerDeathEventH\000R\013playerDeath\022F\n\016player_r" + "espawn\030\027 \001(\0132\035.df.plugin.PlayerRespawnEv" + "entH\000R\rplayerRespawn\022P\n\022player_skin_chan" + "ge\030\030 \001(\0132 .df.plugin.PlayerSkinChangeEve" + "ntH\000R\020playerSkinChange\022\\\n\026player_fire_ex" + "tinguish\030\031 \001(\0132$.df.plugin.PlayerFireExt" + "inguishEventH\000R\024playerFireExtinguish\022P\n\022" + "player_start_break\030\032 \001(\0132 .df.plugin.Pla" + "yerStartBreakEventH\000R\020playerStartBreak\022=" + "\n\013block_break\030\033 \001(\0132\032.df.plugin.BlockBre" + "akEventH\000R\nblockBreak\022P\n\022player_block_pl" + "ace\030\034 \001(\0132 .df.plugin.PlayerBlockPlaceEv" + "entH\000R\020playerBlockPlace\022M\n\021player_block_" + "pick\030\035 \001(\0132\037.df.plugin.PlayerBlockPickEv" + "entH\000R\017playerBlockPick\022G\n\017player_item_us" + "e\030\036 \001(\0132\035.df.plugin.PlayerItemUseEventH\000" + "R\rplayerItemUse\022^\n\030player_item_use_on_bl" + "ock\030\037 \001(\0132$.df.plugin.PlayerItemUseOnBlo" + "ckEventH\000R\024playerItemUseOnBlock\022a\n\031playe" + "r_item_use_on_entity\030 \001(\0132%.df.plugin.P" + "layerItemUseOnEntityEventH\000R\025playerItemU" + "seOnEntity\022S\n\023player_item_release\030! \001(\0132" + "!.df.plugin.PlayerItemReleaseEventH\000R\021pl" + "ayerItemRelease\022S\n\023player_item_consume\030\"" + " \001(\0132!.df.plugin.PlayerItemConsumeEventH" + "\000R\021playerItemConsume\022V\n\024player_attack_en" + "tity\030# \001(\0132\".df.plugin.PlayerAttackEntit" + "yEventH\000R\022playerAttackEntity\022\\\n\026player_e" + "xperience_gain\030$ \001(\0132$.df.plugin.PlayerE" + "xperienceGainEventH\000R\024playerExperienceGa" + "in\022J\n\020player_punch_air\030% \001(\0132\036.df.plugin" + ".PlayerPunchAirEventH\000R\016playerPunchAir\022J" + "\n\020player_sign_edit\030& \001(\0132\036.df.plugin.Pla" + "yerSignEditEventH\000R\016playerSignEdit\022`\n\030pl" + "ayer_lectern_page_turn\030\' \001(\0132%.df.plugin" + ".PlayerLecternPageTurnEventH\000R\025playerLec" + "ternPageTurn\022P\n\022player_item_damage\030( \001(\013" + "2 .df.plugin.PlayerItemDamageEventH\000R\020pl" + "ayerItemDamage\022P\n\022player_item_pickup\030) \001" + "(\0132 .df.plugin.PlayerItemPickupEventH\000R\020" + "playerItemPickup\022]\n\027player_held_slot_cha" + "nge\030* \001(\0132$.df.plugin.PlayerHeldSlotChan" + "geEventH\000R\024playerHeldSlotChange\022J\n\020playe" + "r_item_drop\030+ \001(\0132\036.df.plugin.PlayerItem" + "DropEventH\000R\016playerItemDrop\022I\n\017player_tr" + "ansfer\030, \001(\0132\036.df.plugin.PlayerTransferE" + "ventH\000R\016playerTransfer\0223\n\007command\030- \001(\0132" + "\027.df.plugin.CommandEventH\000R\007command\022R\n\022p" + "layer_diagnostics\030. \001(\0132!.df.plugin.Play" + "erDiagnosticsEventH\000R\021playerDiagnostics\022" + "M\n\021world_liquid_flow\030F \001(\0132\037.df.plugin.W" + "orldLiquidFlowEventH\000R\017worldLiquidFlow\022P" + "\n\022world_liquid_decay\030G \001(\0132 .df.plugin.W" + "orldLiquidDecayEventH\000R\020worldLiquidDecay" + "\022S\n\023world_liquid_harden\030H \001(\0132!.df.plugi" + "n.WorldLiquidHardenEventH\000R\021worldLiquidH" + "arden\022=\n\013world_sound\030I \001(\0132\032.df.plugin.W" + "orldSoundEventH\000R\nworldSound\022M\n\021world_fi" + "re_spread\030J \001(\0132\037.df.plugin.WorldFireSpr" + "eadEventH\000R\017worldFireSpread\022J\n\020world_blo" + "ck_burn\030K \001(\0132\036.df.plugin.WorldBlockBurn" + "EventH\000R\016worldBlockBurn\022P\n\022world_crop_tr" + "ample\030L \001(\0132 .df.plugin.WorldCropTrample" + "EventH\000R\020worldCropTrample\022P\n\022world_leave" + "s_decay\030M \001(\0132 .df.plugin.WorldLeavesDec" + "ayEventH\000R\020worldLeavesDecay\022P\n\022world_ent" + "ity_spawn\030N \001(\0132 .df.plugin.WorldEntityS" + "pawnEventH\000R\020worldEntitySpawn\022V\n\024world_e" + "ntity_despawn\030O \001(\0132\".df.plugin.WorldEnt" + "ityDespawnEventH\000R\022worldEntityDespawn\022I\n" + "\017world_explosion\030P \001(\0132\036.df.plugin.World" + "ExplosionEventH\000R\016worldExplosion\022=\n\013worl" + "d_close\030Q \001(\0132\032.df.plugin.WorldCloseEven" + "tH\000R\nworldCloseB\t\n\007payload\"\205\003\n\014PluginToH" + "ost\022\033\n\tplugin_id\030\001 \001(\tR\010pluginId\022.\n\005hell" + "o\030\n \001(\0132\026.df.plugin.PluginHelloH\000R\005hello" + "\0229\n\tsubscribe\030\013 \001(\0132\031.df.plugin.EventSub" + "scribeH\000R\tsubscribe\022F\n\013server_info\030\014 \001(\013" + "2#.df.plugin.ServerInformationRequestH\000R" + "\nserverInfo\0222\n\007actions\030\024 \001(\0132\026.df.plugin" + ".ActionBatchH\000R\007actions\022)\n\003log\030\036 \001(\0132\025.d" + "f.plugin.LogMessageH\000R\003log\022;\n\014event_resu" + "lt\030( \001(\0132\026.df.plugin.EventResultH\000R\013even" + "tResultB\t\n\007payload\"\324\001\n\013PluginHello\022\022\n\004na" + "me\030\001 \001(\tR\004name\022\030\n\007version\030\002 \001(\tR\007version" + "\022\037\n\013api_version\030\003 \001(\tR\napiVersion\0222\n\010com" + "mands\030\004 \003(\0132\026.df.plugin.CommandSpecR\010com" + "mands\022B\n\014custom_items\030\005 \003(\0132\037.df.plugin." + "CustomItemDefinitionR\013customItems\"<\n\nLog" + "Message\022\024\n\005level\030\001 \001(\tR\005level\022\030\n\007message" + "\030\002 \001(\tR\007message\">\n\016EventSubscribe\022,\n\006eve" + "nts\030\001 \003(\0162\024.df.plugin.EventTypeR\006events*" + "\212\t\n\tEventType\022\032\n\026EVENT_TYPE_UNSPECIFIED\020" + "\000\022\022\n\016EVENT_TYPE_ALL\020\001\022\017\n\013PLAYER_JOIN\020\n\022\017" + "\n\013PLAYER_QUIT\020\013\022\017\n\013PLAYER_MOVE\020\014\022\017\n\013PLAY" + "ER_JUMP\020\r\022\023\n\017PLAYER_TELEPORT\020\016\022\027\n\023PLAYER" + "_CHANGE_WORLD\020\017\022\030\n\024PLAYER_TOGGLE_SPRINT\020" + "\020\022\027\n\023PLAYER_TOGGLE_SNEAK\020\021\022\010\n\004CHAT\020\022\022\024\n\020" + "PLAYER_FOOD_LOSS\020\023\022\017\n\013PLAYER_HEAL\020\024\022\017\n\013P" + "LAYER_HURT\020\025\022\020\n\014PLAYER_DEATH\020\026\022\022\n\016PLAYER" + "_RESPAWN\020\027\022\026\n\022PLAYER_SKIN_CHANGE\020\030\022\032\n\026PL" + "AYER_FIRE_EXTINGUISH\020\031\022\026\n\022PLAYER_START_B" + "REAK\020\032\022\026\n\022PLAYER_BLOCK_BREAK\020\033\022\026\n\022PLAYER" + "_BLOCK_PLACE\020\034\022\025\n\021PLAYER_BLOCK_PICK\020\035\022\023\n" + "\017PLAYER_ITEM_USE\020\036\022\034\n\030PLAYER_ITEM_USE_ON" + "_BLOCK\020\037\022\035\n\031PLAYER_ITEM_USE_ON_ENTITY\020 \022" + "\027\n\023PLAYER_ITEM_RELEASE\020!\022\027\n\023PLAYER_ITEM_" + "CONSUME\020\"\022\030\n\024PLAYER_ATTACK_ENTITY\020#\022\032\n\026P" + "LAYER_EXPERIENCE_GAIN\020$\022\024\n\020PLAYER_PUNCH_" + "AIR\020%\022\024\n\020PLAYER_SIGN_EDIT\020&\022\034\n\030PLAYER_LE" + "CTERN_PAGE_TURN\020\'\022\026\n\022PLAYER_ITEM_DAMAGE\020" + "(\022\026\n\022PLAYER_ITEM_PICKUP\020)\022\033\n\027PLAYER_HELD" + "_SLOT_CHANGE\020*\022\024\n\020PLAYER_ITEM_DROP\020+\022\023\n\017" + "PLAYER_TRANSFER\020,\022\013\n\007COMMAND\020-\022\026\n\022PLAYER" + "_DIAGNOSTICS\020.\022\025\n\021WORLD_LIQUID_FLOW\020F\022\026\n" + "\022WORLD_LIQUID_DECAY\020G\022\027\n\023WORLD_LIQUID_HA" + "RDEN\020H\022\017\n\013WORLD_SOUND\020I\022\025\n\021WORLD_FIRE_SP" + "READ\020J\022\024\n\020WORLD_BLOCK_BURN\020K\022\026\n\022WORLD_CR" + "OP_TRAMPLE\020L\022\026\n\022WORLD_LEAVES_DECAY\020M\022\026\n\022" + "WORLD_ENTITY_SPAWN\020N\022\030\n\024WORLD_ENTITY_DES" + "PAWN\020O\022\023\n\017WORLD_EXPLOSION\020P\022\017\n\013WORLD_CLO" + "SE\020Q2M\n\006Plugin\022C\n\013EventStream\022\027.df.plugi" + "n.PluginToHost\032\027.df.plugin.HostToPlugin(" + "\0010\001B\212\001\n\rcom.df.pluginB\013PluginProtoP\001Z\'gi" + "thub.com/secmc/plugin/proto/generated\242\002\003" + "DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\" + "GPBMetadata\352\002\nDf::Pluginb\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_plugin_2eproto_deps[6] = { @@ -706,7 +709,7 @@ static ::absl::once_flag descriptor_table_plugin_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_plugin_2eproto = { false, false, - 6648, + 6712, descriptor_table_protodef_plugin_2eproto, "plugin.proto", &descriptor_table_plugin_2eproto_once, @@ -791,6 +794,30 @@ void HostToPlugin::set_allocated_event(::df::plugin::EventEnvelope* PROTOBUF_NUL } // @@protoc_insertion_point(field_set_allocated:df.plugin.HostToPlugin.event) } +void HostToPlugin::set_allocated_action_result(::df::plugin::ActionResult* PROTOBUF_NULLABLE action_result) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_payload(); + if (action_result) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(action_result)->GetArena(); + if (message_arena != submessage_arena) { + action_result = ::google::protobuf::internal::GetOwnedMessage(message_arena, action_result, submessage_arena); + } + set_has_action_result(); + _impl_.payload_.action_result_ = action_result; + } + // @@protoc_insertion_point(field_set_allocated:df.plugin.HostToPlugin.action_result) +} +void HostToPlugin::clear_action_result() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (payload_case() == kActionResult) { + if (GetArena() == nullptr) { + delete _impl_.payload_.action_result_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.payload_.action_result_); + } + clear_has_payload(); + } +} HostToPlugin::HostToPlugin(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) : ::google::protobuf::Message(arena, HostToPlugin_class_data_.base()) { @@ -838,6 +865,9 @@ HostToPlugin::HostToPlugin( case kEvent: _impl_.payload_.event_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.payload_.event_); break; + case kActionResult: + _impl_.payload_.action_result_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.payload_.action_result_); + break; } // @@protoc_insertion_point(copy_constructor:df.plugin.HostToPlugin) @@ -907,6 +937,14 @@ void HostToPlugin::clear_payload() { } break; } + case kActionResult: { + if (GetArena() == nullptr) { + delete _impl_.payload_.action_result_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.payload_.action_result_); + } + break; + } case PAYLOAD_NOT_SET: { break; } @@ -958,17 +996,17 @@ HostToPlugin::GetClassData() const { return HostToPlugin_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 5, 4, 40, 2> +const ::_pbi::TcParseTable<0, 6, 5, 40, 2> HostToPlugin::_table_ = { { PROTOBUF_FIELD_OFFSET(HostToPlugin, _impl_._has_bits_), 0, // no _extensions_ - 20, 0, // max_field_number, fast_idx_mask + 21, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294439422, // skipmap + 4293390846, // skipmap offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 4, // num_aux_entries + 6, // num_field_entries + 5, // num_aux_entries offsetof(decltype(_table_), aux_entries), HostToPlugin_class_data_.base(), nullptr, // post_loop_handler @@ -994,12 +1032,15 @@ HostToPlugin::_table_ = { {PROTOBUF_FIELD_OFFSET(HostToPlugin, _impl_.payload_.server_info_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, // .df.plugin.EventEnvelope event = 20 [json_name = "event"]; {PROTOBUF_FIELD_OFFSET(HostToPlugin, _impl_.payload_.event_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; + {PROTOBUF_FIELD_OFFSET(HostToPlugin, _impl_.payload_.action_result_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::HostHello>()}, {::_pbi::TcParser::GetTable<::df::plugin::HostShutdown>()}, {::_pbi::TcParser::GetTable<::df::plugin::ServerInformationResponse>()}, {::_pbi::TcParser::GetTable<::df::plugin::EventEnvelope>()}, + {::_pbi::TcParser::GetTable<::df::plugin::ActionResult>()}, }}, {{ "\26\11\0\0\0\0\0\0" @@ -1077,6 +1118,12 @@ ::uint8_t* PROTOBUF_NONNULL HostToPlugin::_InternalSerialize( stream); break; } + case kActionResult: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 21, *this_._impl_.payload_.action_result_, this_._impl_.payload_.action_result_->GetCachedSize(), target, + stream); + break; + } default: break; } @@ -1138,6 +1185,12 @@ ::size_t HostToPlugin::ByteSizeLong() const { ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.payload_.event_); break; } + // .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; + case kActionResult: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.payload_.action_result_); + break; + } case PAYLOAD_NOT_SET: { break; } @@ -1215,6 +1268,14 @@ void HostToPlugin::MergeImpl(::google::protobuf::MessageLite& to_msg, } break; } + case kActionResult: { + if (oneof_needs_init) { + _this->_impl_.payload_.action_result_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.payload_.action_result_); + } else { + _this->_impl_.payload_.action_result_->MergeFrom(*from._impl_.payload_.action_result_); + } + break; + } case PAYLOAD_NOT_SET: break; } diff --git a/packages/cpp/src/generated/plugin.pb.h b/packages/cpp/src/generated/plugin.pb.h index e1dd6b1..d465039 100644 --- a/packages/cpp/src/generated/plugin.pb.h +++ b/packages/cpp/src/generated/plugin.pb.h @@ -1612,30 +1612,30 @@ class PluginHello final : public ::google::protobuf::Message extern const ::google::protobuf::internal::ClassDataFull PluginHello_class_data_; // ------------------------------------------------------------------- -class PluginToHost final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.PluginToHost) */ { +class EventEnvelope final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.EventEnvelope) */ { public: - inline PluginToHost() : PluginToHost(nullptr) {} - ~PluginToHost() PROTOBUF_FINAL; + inline EventEnvelope() : EventEnvelope(nullptr) {} + ~EventEnvelope() PROTOBUF_FINAL; #if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PluginToHost* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + void operator delete(EventEnvelope* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PluginToHost)); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EventEnvelope)); } #endif template - explicit PROTOBUF_CONSTEXPR PluginToHost(::google::protobuf::internal::ConstantInitialized); + explicit PROTOBUF_CONSTEXPR EventEnvelope(::google::protobuf::internal::ConstantInitialized); - inline PluginToHost(const PluginToHost& from) : PluginToHost(nullptr, from) {} - inline PluginToHost(PluginToHost&& from) noexcept - : PluginToHost(nullptr, ::std::move(from)) {} - inline PluginToHost& operator=(const PluginToHost& from) { + inline EventEnvelope(const EventEnvelope& from) : EventEnvelope(nullptr, from) {} + inline EventEnvelope(EventEnvelope&& from) noexcept + : EventEnvelope(nullptr, ::std::move(from)) {} + inline EventEnvelope& operator=(const EventEnvelope& from) { CopyFrom(from); return *this; } - inline PluginToHost& operator=(PluginToHost&& from) noexcept { + inline EventEnvelope& operator=(EventEnvelope&& from) noexcept { if (this == &from) return *this; if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { InternalSwap(&from); @@ -1663,22 +1663,65 @@ class PluginToHost final : public ::google::protobuf::Message static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { return default_instance().GetMetadata().reflection; } - static const PluginToHost& default_instance() { - return *reinterpret_cast( - &_PluginToHost_default_instance_); + static const EventEnvelope& default_instance() { + return *reinterpret_cast( + &_EventEnvelope_default_instance_); } enum PayloadCase { - kHello = 10, - kSubscribe = 11, - kServerInfo = 12, - kActions = 20, - kLog = 30, - kEventResult = 40, + kPlayerJoin = 10, + kPlayerQuit = 11, + kPlayerMove = 12, + kPlayerJump = 13, + kPlayerTeleport = 14, + kPlayerChangeWorld = 15, + kPlayerToggleSprint = 16, + kPlayerToggleSneak = 17, + kChat = 18, + kPlayerFoodLoss = 19, + kPlayerHeal = 20, + kPlayerHurt = 21, + kPlayerDeath = 22, + kPlayerRespawn = 23, + kPlayerSkinChange = 24, + kPlayerFireExtinguish = 25, + kPlayerStartBreak = 26, + kBlockBreak = 27, + kPlayerBlockPlace = 28, + kPlayerBlockPick = 29, + kPlayerItemUse = 30, + kPlayerItemUseOnBlock = 31, + kPlayerItemUseOnEntity = 32, + kPlayerItemRelease = 33, + kPlayerItemConsume = 34, + kPlayerAttackEntity = 35, + kPlayerExperienceGain = 36, + kPlayerPunchAir = 37, + kPlayerSignEdit = 38, + kPlayerLecternPageTurn = 39, + kPlayerItemDamage = 40, + kPlayerItemPickup = 41, + kPlayerHeldSlotChange = 42, + kPlayerItemDrop = 43, + kPlayerTransfer = 44, + kCommand = 45, + kPlayerDiagnostics = 46, + kWorldLiquidFlow = 70, + kWorldLiquidDecay = 71, + kWorldLiquidHarden = 72, + kWorldSound = 73, + kWorldFireSpread = 74, + kWorldBlockBurn = 75, + kWorldCropTrample = 76, + kWorldLeavesDecay = 77, + kWorldEntitySpawn = 78, + kWorldEntityDespawn = 79, + kWorldExplosion = 80, + kWorldClose = 81, PAYLOAD_NOT_SET = 0, }; - static constexpr int kIndexInFileMessages = 6; - friend void swap(PluginToHost& a, PluginToHost& b) { a.Swap(&b); } - inline void Swap(PluginToHost* PROTOBUF_NONNULL other) { + static constexpr int kIndexInFileMessages = 5; + friend void swap(EventEnvelope& a, EventEnvelope& b) { a.Swap(&b); } + inline void Swap(EventEnvelope* PROTOBUF_NONNULL other) { if (other == this) return; if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { InternalSwap(other); @@ -1686,7 +1729,7 @@ class PluginToHost final : public ::google::protobuf::Message ::google::protobuf::internal::GenericSwap(this, other); } } - void UnsafeArenaSwap(PluginToHost* PROTOBUF_NONNULL other) { + void UnsafeArenaSwap(EventEnvelope* PROTOBUF_NONNULL other) { if (other == this) return; ABSL_DCHECK(GetArena() == other->GetArena()); InternalSwap(other); @@ -1694,13 +1737,13 @@ class PluginToHost final : public ::google::protobuf::Message // implements Message ---------------------------------------------- - PluginToHost* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); + EventEnvelope* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); } using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const PluginToHost& from); + void CopyFrom(const EventEnvelope& from); using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const PluginToHost& from) { PluginToHost::MergeImpl(*this, from); } + void MergeFrom(const EventEnvelope& from) { EventEnvelope::MergeImpl(*this, from); } private: static void MergeImpl(::google::protobuf::MessageLite& to_msg, @@ -1736,17 +1779,17 @@ class PluginToHost final : public ::google::protobuf::Message private: void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); static void SharedDtor(MessageLite& self); - void InternalSwap(PluginToHost* PROTOBUF_NONNULL other); + void InternalSwap(EventEnvelope* PROTOBUF_NONNULL other); private: template friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.PluginToHost"; } + static ::absl::string_view FullMessageName() { return "df.plugin.EventEnvelope"; } - explicit PluginToHost(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - PluginToHost(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PluginToHost& from); - PluginToHost( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PluginToHost&& from) noexcept - : PluginToHost(arena) { + explicit EventEnvelope(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + EventEnvelope(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const EventEnvelope& from); + EventEnvelope( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, EventEnvelope&& from) noexcept + : EventEnvelope(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -1763,714 +1806,326 @@ class PluginToHost final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { - kPluginIdFieldNumber = 1, - kHelloFieldNumber = 10, - kSubscribeFieldNumber = 11, - kServerInfoFieldNumber = 12, - kActionsFieldNumber = 20, - kLogFieldNumber = 30, - kEventResultFieldNumber = 40, + kEventIdFieldNumber = 1, + kTypeFieldNumber = 2, + kExpectsResponseFieldNumber = 3, + kPlayerJoinFieldNumber = 10, + kPlayerQuitFieldNumber = 11, + kPlayerMoveFieldNumber = 12, + kPlayerJumpFieldNumber = 13, + kPlayerTeleportFieldNumber = 14, + kPlayerChangeWorldFieldNumber = 15, + kPlayerToggleSprintFieldNumber = 16, + kPlayerToggleSneakFieldNumber = 17, + kChatFieldNumber = 18, + kPlayerFoodLossFieldNumber = 19, + kPlayerHealFieldNumber = 20, + kPlayerHurtFieldNumber = 21, + kPlayerDeathFieldNumber = 22, + kPlayerRespawnFieldNumber = 23, + kPlayerSkinChangeFieldNumber = 24, + kPlayerFireExtinguishFieldNumber = 25, + kPlayerStartBreakFieldNumber = 26, + kBlockBreakFieldNumber = 27, + kPlayerBlockPlaceFieldNumber = 28, + kPlayerBlockPickFieldNumber = 29, + kPlayerItemUseFieldNumber = 30, + kPlayerItemUseOnBlockFieldNumber = 31, + kPlayerItemUseOnEntityFieldNumber = 32, + kPlayerItemReleaseFieldNumber = 33, + kPlayerItemConsumeFieldNumber = 34, + kPlayerAttackEntityFieldNumber = 35, + kPlayerExperienceGainFieldNumber = 36, + kPlayerPunchAirFieldNumber = 37, + kPlayerSignEditFieldNumber = 38, + kPlayerLecternPageTurnFieldNumber = 39, + kPlayerItemDamageFieldNumber = 40, + kPlayerItemPickupFieldNumber = 41, + kPlayerHeldSlotChangeFieldNumber = 42, + kPlayerItemDropFieldNumber = 43, + kPlayerTransferFieldNumber = 44, + kCommandFieldNumber = 45, + kPlayerDiagnosticsFieldNumber = 46, + kWorldLiquidFlowFieldNumber = 70, + kWorldLiquidDecayFieldNumber = 71, + kWorldLiquidHardenFieldNumber = 72, + kWorldSoundFieldNumber = 73, + kWorldFireSpreadFieldNumber = 74, + kWorldBlockBurnFieldNumber = 75, + kWorldCropTrampleFieldNumber = 76, + kWorldLeavesDecayFieldNumber = 77, + kWorldEntitySpawnFieldNumber = 78, + kWorldEntityDespawnFieldNumber = 79, + kWorldExplosionFieldNumber = 80, + kWorldCloseFieldNumber = 81, }; - // string plugin_id = 1 [json_name = "pluginId"]; - void clear_plugin_id() ; - const ::std::string& plugin_id() const; + // string event_id = 1 [json_name = "eventId"]; + void clear_event_id() ; + const ::std::string& event_id() const; template - void set_plugin_id(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_plugin_id(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_plugin_id(); - void set_allocated_plugin_id(::std::string* PROTOBUF_NULLABLE value); + void set_event_id(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_event_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_event_id(); + void set_allocated_event_id(::std::string* PROTOBUF_NULLABLE value); private: - const ::std::string& _internal_plugin_id() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_plugin_id(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_plugin_id(); + const ::std::string& _internal_event_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_event_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_event_id(); public: - // .df.plugin.PluginHello hello = 10 [json_name = "hello"]; - bool has_hello() const; + // .df.plugin.EventType type = 2 [json_name = "type"]; + void clear_type() ; + ::df::plugin::EventType type() const; + void set_type(::df::plugin::EventType value); + private: - bool _internal_has_hello() const; + ::df::plugin::EventType _internal_type() const; + void _internal_set_type(::df::plugin::EventType value); public: - void clear_hello() ; - const ::df::plugin::PluginHello& hello() const; - [[nodiscard]] ::df::plugin::PluginHello* PROTOBUF_NULLABLE release_hello(); - ::df::plugin::PluginHello* PROTOBUF_NONNULL mutable_hello(); - void set_allocated_hello(::df::plugin::PluginHello* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_hello(::df::plugin::PluginHello* PROTOBUF_NULLABLE value); - ::df::plugin::PluginHello* PROTOBUF_NULLABLE unsafe_arena_release_hello(); + // bool expects_response = 3 [json_name = "expectsResponse"]; + void clear_expects_response() ; + bool expects_response() const; + void set_expects_response(bool value); private: - const ::df::plugin::PluginHello& _internal_hello() const; - ::df::plugin::PluginHello* PROTOBUF_NONNULL _internal_mutable_hello(); + bool _internal_expects_response() const; + void _internal_set_expects_response(bool value); public: - // .df.plugin.EventSubscribe subscribe = 11 [json_name = "subscribe"]; - bool has_subscribe() const; + // .df.plugin.PlayerJoinEvent player_join = 10 [json_name = "playerJoin"]; + bool has_player_join() const; private: - bool _internal_has_subscribe() const; + bool _internal_has_player_join() const; public: - void clear_subscribe() ; - const ::df::plugin::EventSubscribe& subscribe() const; - [[nodiscard]] ::df::plugin::EventSubscribe* PROTOBUF_NULLABLE release_subscribe(); - ::df::plugin::EventSubscribe* PROTOBUF_NONNULL mutable_subscribe(); - void set_allocated_subscribe(::df::plugin::EventSubscribe* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_subscribe(::df::plugin::EventSubscribe* PROTOBUF_NULLABLE value); - ::df::plugin::EventSubscribe* PROTOBUF_NULLABLE unsafe_arena_release_subscribe(); + void clear_player_join() ; + const ::df::plugin::PlayerJoinEvent& player_join() const; + [[nodiscard]] ::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE release_player_join(); + ::df::plugin::PlayerJoinEvent* PROTOBUF_NONNULL mutable_player_join(); + void set_allocated_player_join(::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_join(::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_join(); private: - const ::df::plugin::EventSubscribe& _internal_subscribe() const; - ::df::plugin::EventSubscribe* PROTOBUF_NONNULL _internal_mutable_subscribe(); + const ::df::plugin::PlayerJoinEvent& _internal_player_join() const; + ::df::plugin::PlayerJoinEvent* PROTOBUF_NONNULL _internal_mutable_player_join(); public: - // .df.plugin.ServerInformationRequest server_info = 12 [json_name = "serverInfo"]; - bool has_server_info() const; + // .df.plugin.PlayerQuitEvent player_quit = 11 [json_name = "playerQuit"]; + bool has_player_quit() const; private: - bool _internal_has_server_info() const; + bool _internal_has_player_quit() const; public: - void clear_server_info() ; - const ::df::plugin::ServerInformationRequest& server_info() const; - [[nodiscard]] ::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE release_server_info(); - ::df::plugin::ServerInformationRequest* PROTOBUF_NONNULL mutable_server_info(); - void set_allocated_server_info(::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_server_info(::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE value); - ::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE unsafe_arena_release_server_info(); + void clear_player_quit() ; + const ::df::plugin::PlayerQuitEvent& player_quit() const; + [[nodiscard]] ::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE release_player_quit(); + ::df::plugin::PlayerQuitEvent* PROTOBUF_NONNULL mutable_player_quit(); + void set_allocated_player_quit(::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_quit(::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_quit(); private: - const ::df::plugin::ServerInformationRequest& _internal_server_info() const; - ::df::plugin::ServerInformationRequest* PROTOBUF_NONNULL _internal_mutable_server_info(); + const ::df::plugin::PlayerQuitEvent& _internal_player_quit() const; + ::df::plugin::PlayerQuitEvent* PROTOBUF_NONNULL _internal_mutable_player_quit(); public: - // .df.plugin.ActionBatch actions = 20 [json_name = "actions"]; - bool has_actions() const; + // .df.plugin.PlayerMoveEvent player_move = 12 [json_name = "playerMove"]; + bool has_player_move() const; private: - bool _internal_has_actions() const; + bool _internal_has_player_move() const; public: - void clear_actions() ; - const ::df::plugin::ActionBatch& actions() const; - [[nodiscard]] ::df::plugin::ActionBatch* PROTOBUF_NULLABLE release_actions(); - ::df::plugin::ActionBatch* PROTOBUF_NONNULL mutable_actions(); - void set_allocated_actions(::df::plugin::ActionBatch* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_actions(::df::plugin::ActionBatch* PROTOBUF_NULLABLE value); - ::df::plugin::ActionBatch* PROTOBUF_NULLABLE unsafe_arena_release_actions(); + void clear_player_move() ; + const ::df::plugin::PlayerMoveEvent& player_move() const; + [[nodiscard]] ::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE release_player_move(); + ::df::plugin::PlayerMoveEvent* PROTOBUF_NONNULL mutable_player_move(); + void set_allocated_player_move(::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_move(::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_move(); private: - const ::df::plugin::ActionBatch& _internal_actions() const; - ::df::plugin::ActionBatch* PROTOBUF_NONNULL _internal_mutable_actions(); + const ::df::plugin::PlayerMoveEvent& _internal_player_move() const; + ::df::plugin::PlayerMoveEvent* PROTOBUF_NONNULL _internal_mutable_player_move(); public: - // .df.plugin.LogMessage log = 30 [json_name = "log"]; - bool has_log() const; + // .df.plugin.PlayerJumpEvent player_jump = 13 [json_name = "playerJump"]; + bool has_player_jump() const; private: - bool _internal_has_log() const; + bool _internal_has_player_jump() const; public: - void clear_log() ; - const ::df::plugin::LogMessage& log() const; - [[nodiscard]] ::df::plugin::LogMessage* PROTOBUF_NULLABLE release_log(); - ::df::plugin::LogMessage* PROTOBUF_NONNULL mutable_log(); - void set_allocated_log(::df::plugin::LogMessage* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_log(::df::plugin::LogMessage* PROTOBUF_NULLABLE value); - ::df::plugin::LogMessage* PROTOBUF_NULLABLE unsafe_arena_release_log(); + void clear_player_jump() ; + const ::df::plugin::PlayerJumpEvent& player_jump() const; + [[nodiscard]] ::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE release_player_jump(); + ::df::plugin::PlayerJumpEvent* PROTOBUF_NONNULL mutable_player_jump(); + void set_allocated_player_jump(::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_jump(::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_jump(); private: - const ::df::plugin::LogMessage& _internal_log() const; - ::df::plugin::LogMessage* PROTOBUF_NONNULL _internal_mutable_log(); + const ::df::plugin::PlayerJumpEvent& _internal_player_jump() const; + ::df::plugin::PlayerJumpEvent* PROTOBUF_NONNULL _internal_mutable_player_jump(); public: - // .df.plugin.EventResult event_result = 40 [json_name = "eventResult"]; - bool has_event_result() const; + // .df.plugin.PlayerTeleportEvent player_teleport = 14 [json_name = "playerTeleport"]; + bool has_player_teleport() const; private: - bool _internal_has_event_result() const; + bool _internal_has_player_teleport() const; public: - void clear_event_result() ; - const ::df::plugin::EventResult& event_result() const; - [[nodiscard]] ::df::plugin::EventResult* PROTOBUF_NULLABLE release_event_result(); - ::df::plugin::EventResult* PROTOBUF_NONNULL mutable_event_result(); - void set_allocated_event_result(::df::plugin::EventResult* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_event_result(::df::plugin::EventResult* PROTOBUF_NULLABLE value); - ::df::plugin::EventResult* PROTOBUF_NULLABLE unsafe_arena_release_event_result(); + void clear_player_teleport() ; + const ::df::plugin::PlayerTeleportEvent& player_teleport() const; + [[nodiscard]] ::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE release_player_teleport(); + ::df::plugin::PlayerTeleportEvent* PROTOBUF_NONNULL mutable_player_teleport(); + void set_allocated_player_teleport(::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_teleport(::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_teleport(); private: - const ::df::plugin::EventResult& _internal_event_result() const; - ::df::plugin::EventResult* PROTOBUF_NONNULL _internal_mutable_event_result(); + const ::df::plugin::PlayerTeleportEvent& _internal_player_teleport() const; + ::df::plugin::PlayerTeleportEvent* PROTOBUF_NONNULL _internal_mutable_player_teleport(); public: - void clear_payload(); - PayloadCase payload_case() const; - // @@protoc_insertion_point(class_scope:df.plugin.PluginToHost) - private: - class _Internal; - void set_has_hello(); - void set_has_subscribe(); - void set_has_server_info(); - void set_has_actions(); - void set_has_log(); - void set_has_event_result(); - inline bool has_payload() const; - inline void clear_has_payload(); - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<0, 7, - 6, 40, - 7> - _table_; + // .df.plugin.PlayerChangeWorldEvent player_change_world = 15 [json_name = "playerChangeWorld"]; + bool has_player_change_world() const; + private: + bool _internal_has_player_change_world() const; - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const PluginToHost& from_msg); - ::google::protobuf::internal::HasBits<1> _has_bits_; - ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr plugin_id_; - union PayloadUnion { - constexpr PayloadUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::google::protobuf::Message* PROTOBUF_NULLABLE hello_; - ::google::protobuf::Message* PROTOBUF_NULLABLE subscribe_; - ::google::protobuf::Message* PROTOBUF_NULLABLE server_info_; - ::google::protobuf::Message* PROTOBUF_NULLABLE actions_; - ::google::protobuf::Message* PROTOBUF_NULLABLE log_; - ::google::protobuf::Message* PROTOBUF_NULLABLE event_result_; - } payload_; - ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_plugin_2eproto; -}; + public: + void clear_player_change_world() ; + const ::df::plugin::PlayerChangeWorldEvent& player_change_world() const; + [[nodiscard]] ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE release_player_change_world(); + ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NONNULL mutable_player_change_world(); + void set_allocated_player_change_world(::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_change_world(::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_change_world(); -extern const ::google::protobuf::internal::ClassDataFull PluginToHost_class_data_; -// ------------------------------------------------------------------- + private: + const ::df::plugin::PlayerChangeWorldEvent& _internal_player_change_world() const; + ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NONNULL _internal_mutable_player_change_world(); -class EventEnvelope final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.EventEnvelope) */ { - public: - inline EventEnvelope() : EventEnvelope(nullptr) {} - ~EventEnvelope() PROTOBUF_FINAL; + public: + // .df.plugin.PlayerToggleSprintEvent player_toggle_sprint = 16 [json_name = "playerToggleSprint"]; + bool has_player_toggle_sprint() const; + private: + bool _internal_has_player_toggle_sprint() const; -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(EventEnvelope* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(EventEnvelope)); - } -#endif + public: + void clear_player_toggle_sprint() ; + const ::df::plugin::PlayerToggleSprintEvent& player_toggle_sprint() const; + [[nodiscard]] ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE release_player_toggle_sprint(); + ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NONNULL mutable_player_toggle_sprint(); + void set_allocated_player_toggle_sprint(::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_toggle_sprint(::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_toggle_sprint(); - template - explicit PROTOBUF_CONSTEXPR EventEnvelope(::google::protobuf::internal::ConstantInitialized); + private: + const ::df::plugin::PlayerToggleSprintEvent& _internal_player_toggle_sprint() const; + ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NONNULL _internal_mutable_player_toggle_sprint(); - inline EventEnvelope(const EventEnvelope& from) : EventEnvelope(nullptr, from) {} - inline EventEnvelope(EventEnvelope&& from) noexcept - : EventEnvelope(nullptr, ::std::move(from)) {} - inline EventEnvelope& operator=(const EventEnvelope& from) { - CopyFrom(from); - return *this; - } - inline EventEnvelope& operator=(EventEnvelope&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } + public: + // .df.plugin.PlayerToggleSneakEvent player_toggle_sneak = 17 [json_name = "playerToggleSneak"]; + bool has_player_toggle_sneak() const; + private: + bool _internal_has_player_toggle_sneak() const; - inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); - } - inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); - } - - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { - return GetDescriptor(); - } - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const EventEnvelope& default_instance() { - return *reinterpret_cast( - &_EventEnvelope_default_instance_); - } - enum PayloadCase { - kPlayerJoin = 10, - kPlayerQuit = 11, - kPlayerMove = 12, - kPlayerJump = 13, - kPlayerTeleport = 14, - kPlayerChangeWorld = 15, - kPlayerToggleSprint = 16, - kPlayerToggleSneak = 17, - kChat = 18, - kPlayerFoodLoss = 19, - kPlayerHeal = 20, - kPlayerHurt = 21, - kPlayerDeath = 22, - kPlayerRespawn = 23, - kPlayerSkinChange = 24, - kPlayerFireExtinguish = 25, - kPlayerStartBreak = 26, - kBlockBreak = 27, - kPlayerBlockPlace = 28, - kPlayerBlockPick = 29, - kPlayerItemUse = 30, - kPlayerItemUseOnBlock = 31, - kPlayerItemUseOnEntity = 32, - kPlayerItemRelease = 33, - kPlayerItemConsume = 34, - kPlayerAttackEntity = 35, - kPlayerExperienceGain = 36, - kPlayerPunchAir = 37, - kPlayerSignEdit = 38, - kPlayerLecternPageTurn = 39, - kPlayerItemDamage = 40, - kPlayerItemPickup = 41, - kPlayerHeldSlotChange = 42, - kPlayerItemDrop = 43, - kPlayerTransfer = 44, - kCommand = 45, - kPlayerDiagnostics = 46, - kWorldLiquidFlow = 70, - kWorldLiquidDecay = 71, - kWorldLiquidHarden = 72, - kWorldSound = 73, - kWorldFireSpread = 74, - kWorldBlockBurn = 75, - kWorldCropTrample = 76, - kWorldLeavesDecay = 77, - kWorldEntitySpawn = 78, - kWorldEntityDespawn = 79, - kWorldExplosion = 80, - kWorldClose = 81, - PAYLOAD_NOT_SET = 0, - }; - static constexpr int kIndexInFileMessages = 5; - friend void swap(EventEnvelope& a, EventEnvelope& b) { a.Swap(&b); } - inline void Swap(EventEnvelope* PROTOBUF_NONNULL other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(EventEnvelope* PROTOBUF_NONNULL other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - EventEnvelope* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); - } - using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const EventEnvelope& from); - using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const EventEnvelope& from) { EventEnvelope::MergeImpl(*this, from); } + public: + void clear_player_toggle_sneak() ; + const ::df::plugin::PlayerToggleSneakEvent& player_toggle_sneak() const; + [[nodiscard]] ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE release_player_toggle_sneak(); + ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NONNULL mutable_player_toggle_sneak(); + void set_allocated_player_toggle_sneak(::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_toggle_sneak(::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_toggle_sneak(); private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); + const ::df::plugin::PlayerToggleSneakEvent& _internal_player_toggle_sneak() const; + ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NONNULL _internal_mutable_player_toggle_sneak(); public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) + // .df.plugin.ChatEvent chat = 18 [json_name = "chat"]; + bool has_chat() const; private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); + bool _internal_has_chat() const; public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } + void clear_chat() ; + const ::df::plugin::ChatEvent& chat() const; + [[nodiscard]] ::df::plugin::ChatEvent* PROTOBUF_NULLABLE release_chat(); + ::df::plugin::ChatEvent* PROTOBUF_NONNULL mutable_chat(); + void set_allocated_chat(::df::plugin::ChatEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_chat(::df::plugin::ChatEvent* PROTOBUF_NULLABLE value); + ::df::plugin::ChatEvent* PROTOBUF_NULLABLE unsafe_arena_release_chat(); private: - void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(EventEnvelope* PROTOBUF_NONNULL other); - private: - template - friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.EventEnvelope"; } - - explicit EventEnvelope(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - EventEnvelope(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const EventEnvelope& from); - EventEnvelope( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, EventEnvelope&& from) noexcept - : EventEnvelope(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; - static void* PROTOBUF_NONNULL PlacementNew_( - const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static constexpr auto InternalNewImpl_(); - - public: - static constexpr auto InternalGenerateClassData_(); + const ::df::plugin::ChatEvent& _internal_chat() const; + ::df::plugin::ChatEvent* PROTOBUF_NONNULL _internal_mutable_chat(); - ::google::protobuf::Metadata GetMetadata() const; - // nested types ---------------------------------------------------- + public: + // .df.plugin.PlayerFoodLossEvent player_food_loss = 19 [json_name = "playerFoodLoss"]; + bool has_player_food_loss() const; + private: + bool _internal_has_player_food_loss() const; - // accessors ------------------------------------------------------- - enum : int { - kEventIdFieldNumber = 1, - kTypeFieldNumber = 2, - kExpectsResponseFieldNumber = 3, - kPlayerJoinFieldNumber = 10, - kPlayerQuitFieldNumber = 11, - kPlayerMoveFieldNumber = 12, - kPlayerJumpFieldNumber = 13, - kPlayerTeleportFieldNumber = 14, - kPlayerChangeWorldFieldNumber = 15, - kPlayerToggleSprintFieldNumber = 16, - kPlayerToggleSneakFieldNumber = 17, - kChatFieldNumber = 18, - kPlayerFoodLossFieldNumber = 19, - kPlayerHealFieldNumber = 20, - kPlayerHurtFieldNumber = 21, - kPlayerDeathFieldNumber = 22, - kPlayerRespawnFieldNumber = 23, - kPlayerSkinChangeFieldNumber = 24, - kPlayerFireExtinguishFieldNumber = 25, - kPlayerStartBreakFieldNumber = 26, - kBlockBreakFieldNumber = 27, - kPlayerBlockPlaceFieldNumber = 28, - kPlayerBlockPickFieldNumber = 29, - kPlayerItemUseFieldNumber = 30, - kPlayerItemUseOnBlockFieldNumber = 31, - kPlayerItemUseOnEntityFieldNumber = 32, - kPlayerItemReleaseFieldNumber = 33, - kPlayerItemConsumeFieldNumber = 34, - kPlayerAttackEntityFieldNumber = 35, - kPlayerExperienceGainFieldNumber = 36, - kPlayerPunchAirFieldNumber = 37, - kPlayerSignEditFieldNumber = 38, - kPlayerLecternPageTurnFieldNumber = 39, - kPlayerItemDamageFieldNumber = 40, - kPlayerItemPickupFieldNumber = 41, - kPlayerHeldSlotChangeFieldNumber = 42, - kPlayerItemDropFieldNumber = 43, - kPlayerTransferFieldNumber = 44, - kCommandFieldNumber = 45, - kPlayerDiagnosticsFieldNumber = 46, - kWorldLiquidFlowFieldNumber = 70, - kWorldLiquidDecayFieldNumber = 71, - kWorldLiquidHardenFieldNumber = 72, - kWorldSoundFieldNumber = 73, - kWorldFireSpreadFieldNumber = 74, - kWorldBlockBurnFieldNumber = 75, - kWorldCropTrampleFieldNumber = 76, - kWorldLeavesDecayFieldNumber = 77, - kWorldEntitySpawnFieldNumber = 78, - kWorldEntityDespawnFieldNumber = 79, - kWorldExplosionFieldNumber = 80, - kWorldCloseFieldNumber = 81, - }; - // string event_id = 1 [json_name = "eventId"]; - void clear_event_id() ; - const ::std::string& event_id() const; - template - void set_event_id(Arg_&& arg, Args_... args); - ::std::string* PROTOBUF_NONNULL mutable_event_id(); - [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_event_id(); - void set_allocated_event_id(::std::string* PROTOBUF_NULLABLE value); + public: + void clear_player_food_loss() ; + const ::df::plugin::PlayerFoodLossEvent& player_food_loss() const; + [[nodiscard]] ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE release_player_food_loss(); + ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NONNULL mutable_player_food_loss(); + void set_allocated_player_food_loss(::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_food_loss(::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_food_loss(); private: - const ::std::string& _internal_event_id() const; - PROTOBUF_ALWAYS_INLINE void _internal_set_event_id(const ::std::string& value); - ::std::string* PROTOBUF_NONNULL _internal_mutable_event_id(); + const ::df::plugin::PlayerFoodLossEvent& _internal_player_food_loss() const; + ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NONNULL _internal_mutable_player_food_loss(); public: - // .df.plugin.EventType type = 2 [json_name = "type"]; - void clear_type() ; - ::df::plugin::EventType type() const; - void set_type(::df::plugin::EventType value); - + // .df.plugin.PlayerHealEvent player_heal = 20 [json_name = "playerHeal"]; + bool has_player_heal() const; private: - ::df::plugin::EventType _internal_type() const; - void _internal_set_type(::df::plugin::EventType value); + bool _internal_has_player_heal() const; public: - // bool expects_response = 3 [json_name = "expectsResponse"]; - void clear_expects_response() ; - bool expects_response() const; - void set_expects_response(bool value); + void clear_player_heal() ; + const ::df::plugin::PlayerHealEvent& player_heal() const; + [[nodiscard]] ::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE release_player_heal(); + ::df::plugin::PlayerHealEvent* PROTOBUF_NONNULL mutable_player_heal(); + void set_allocated_player_heal(::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_heal(::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_heal(); private: - bool _internal_expects_response() const; - void _internal_set_expects_response(bool value); + const ::df::plugin::PlayerHealEvent& _internal_player_heal() const; + ::df::plugin::PlayerHealEvent* PROTOBUF_NONNULL _internal_mutable_player_heal(); public: - // .df.plugin.PlayerJoinEvent player_join = 10 [json_name = "playerJoin"]; - bool has_player_join() const; + // .df.plugin.PlayerHurtEvent player_hurt = 21 [json_name = "playerHurt"]; + bool has_player_hurt() const; private: - bool _internal_has_player_join() const; + bool _internal_has_player_hurt() const; public: - void clear_player_join() ; - const ::df::plugin::PlayerJoinEvent& player_join() const; - [[nodiscard]] ::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE release_player_join(); - ::df::plugin::PlayerJoinEvent* PROTOBUF_NONNULL mutable_player_join(); - void set_allocated_player_join(::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_join(::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerJoinEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_join(); + void clear_player_hurt() ; + const ::df::plugin::PlayerHurtEvent& player_hurt() const; + [[nodiscard]] ::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE release_player_hurt(); + ::df::plugin::PlayerHurtEvent* PROTOBUF_NONNULL mutable_player_hurt(); + void set_allocated_player_hurt(::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_player_hurt(::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE value); + ::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_hurt(); private: - const ::df::plugin::PlayerJoinEvent& _internal_player_join() const; - ::df::plugin::PlayerJoinEvent* PROTOBUF_NONNULL _internal_mutable_player_join(); + const ::df::plugin::PlayerHurtEvent& _internal_player_hurt() const; + ::df::plugin::PlayerHurtEvent* PROTOBUF_NONNULL _internal_mutable_player_hurt(); public: - // .df.plugin.PlayerQuitEvent player_quit = 11 [json_name = "playerQuit"]; - bool has_player_quit() const; + // .df.plugin.PlayerDeathEvent player_death = 22 [json_name = "playerDeath"]; + bool has_player_death() const; private: - bool _internal_has_player_quit() const; - - public: - void clear_player_quit() ; - const ::df::plugin::PlayerQuitEvent& player_quit() const; - [[nodiscard]] ::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE release_player_quit(); - ::df::plugin::PlayerQuitEvent* PROTOBUF_NONNULL mutable_player_quit(); - void set_allocated_player_quit(::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_quit(::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerQuitEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_quit(); - - private: - const ::df::plugin::PlayerQuitEvent& _internal_player_quit() const; - ::df::plugin::PlayerQuitEvent* PROTOBUF_NONNULL _internal_mutable_player_quit(); - - public: - // .df.plugin.PlayerMoveEvent player_move = 12 [json_name = "playerMove"]; - bool has_player_move() const; - private: - bool _internal_has_player_move() const; - - public: - void clear_player_move() ; - const ::df::plugin::PlayerMoveEvent& player_move() const; - [[nodiscard]] ::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE release_player_move(); - ::df::plugin::PlayerMoveEvent* PROTOBUF_NONNULL mutable_player_move(); - void set_allocated_player_move(::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_move(::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerMoveEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_move(); - - private: - const ::df::plugin::PlayerMoveEvent& _internal_player_move() const; - ::df::plugin::PlayerMoveEvent* PROTOBUF_NONNULL _internal_mutable_player_move(); - - public: - // .df.plugin.PlayerJumpEvent player_jump = 13 [json_name = "playerJump"]; - bool has_player_jump() const; - private: - bool _internal_has_player_jump() const; - - public: - void clear_player_jump() ; - const ::df::plugin::PlayerJumpEvent& player_jump() const; - [[nodiscard]] ::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE release_player_jump(); - ::df::plugin::PlayerJumpEvent* PROTOBUF_NONNULL mutable_player_jump(); - void set_allocated_player_jump(::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_jump(::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerJumpEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_jump(); - - private: - const ::df::plugin::PlayerJumpEvent& _internal_player_jump() const; - ::df::plugin::PlayerJumpEvent* PROTOBUF_NONNULL _internal_mutable_player_jump(); - - public: - // .df.plugin.PlayerTeleportEvent player_teleport = 14 [json_name = "playerTeleport"]; - bool has_player_teleport() const; - private: - bool _internal_has_player_teleport() const; - - public: - void clear_player_teleport() ; - const ::df::plugin::PlayerTeleportEvent& player_teleport() const; - [[nodiscard]] ::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE release_player_teleport(); - ::df::plugin::PlayerTeleportEvent* PROTOBUF_NONNULL mutable_player_teleport(); - void set_allocated_player_teleport(::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_teleport(::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerTeleportEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_teleport(); - - private: - const ::df::plugin::PlayerTeleportEvent& _internal_player_teleport() const; - ::df::plugin::PlayerTeleportEvent* PROTOBUF_NONNULL _internal_mutable_player_teleport(); - - public: - // .df.plugin.PlayerChangeWorldEvent player_change_world = 15 [json_name = "playerChangeWorld"]; - bool has_player_change_world() const; - private: - bool _internal_has_player_change_world() const; - - public: - void clear_player_change_world() ; - const ::df::plugin::PlayerChangeWorldEvent& player_change_world() const; - [[nodiscard]] ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE release_player_change_world(); - ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NONNULL mutable_player_change_world(); - void set_allocated_player_change_world(::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_change_world(::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_change_world(); - - private: - const ::df::plugin::PlayerChangeWorldEvent& _internal_player_change_world() const; - ::df::plugin::PlayerChangeWorldEvent* PROTOBUF_NONNULL _internal_mutable_player_change_world(); - - public: - // .df.plugin.PlayerToggleSprintEvent player_toggle_sprint = 16 [json_name = "playerToggleSprint"]; - bool has_player_toggle_sprint() const; - private: - bool _internal_has_player_toggle_sprint() const; - - public: - void clear_player_toggle_sprint() ; - const ::df::plugin::PlayerToggleSprintEvent& player_toggle_sprint() const; - [[nodiscard]] ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE release_player_toggle_sprint(); - ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NONNULL mutable_player_toggle_sprint(); - void set_allocated_player_toggle_sprint(::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_toggle_sprint(::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_toggle_sprint(); - - private: - const ::df::plugin::PlayerToggleSprintEvent& _internal_player_toggle_sprint() const; - ::df::plugin::PlayerToggleSprintEvent* PROTOBUF_NONNULL _internal_mutable_player_toggle_sprint(); - - public: - // .df.plugin.PlayerToggleSneakEvent player_toggle_sneak = 17 [json_name = "playerToggleSneak"]; - bool has_player_toggle_sneak() const; - private: - bool _internal_has_player_toggle_sneak() const; - - public: - void clear_player_toggle_sneak() ; - const ::df::plugin::PlayerToggleSneakEvent& player_toggle_sneak() const; - [[nodiscard]] ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE release_player_toggle_sneak(); - ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NONNULL mutable_player_toggle_sneak(); - void set_allocated_player_toggle_sneak(::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_toggle_sneak(::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_toggle_sneak(); - - private: - const ::df::plugin::PlayerToggleSneakEvent& _internal_player_toggle_sneak() const; - ::df::plugin::PlayerToggleSneakEvent* PROTOBUF_NONNULL _internal_mutable_player_toggle_sneak(); - - public: - // .df.plugin.ChatEvent chat = 18 [json_name = "chat"]; - bool has_chat() const; - private: - bool _internal_has_chat() const; - - public: - void clear_chat() ; - const ::df::plugin::ChatEvent& chat() const; - [[nodiscard]] ::df::plugin::ChatEvent* PROTOBUF_NULLABLE release_chat(); - ::df::plugin::ChatEvent* PROTOBUF_NONNULL mutable_chat(); - void set_allocated_chat(::df::plugin::ChatEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_chat(::df::plugin::ChatEvent* PROTOBUF_NULLABLE value); - ::df::plugin::ChatEvent* PROTOBUF_NULLABLE unsafe_arena_release_chat(); - - private: - const ::df::plugin::ChatEvent& _internal_chat() const; - ::df::plugin::ChatEvent* PROTOBUF_NONNULL _internal_mutable_chat(); - - public: - // .df.plugin.PlayerFoodLossEvent player_food_loss = 19 [json_name = "playerFoodLoss"]; - bool has_player_food_loss() const; - private: - bool _internal_has_player_food_loss() const; - - public: - void clear_player_food_loss() ; - const ::df::plugin::PlayerFoodLossEvent& player_food_loss() const; - [[nodiscard]] ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE release_player_food_loss(); - ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NONNULL mutable_player_food_loss(); - void set_allocated_player_food_loss(::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_food_loss(::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_food_loss(); - - private: - const ::df::plugin::PlayerFoodLossEvent& _internal_player_food_loss() const; - ::df::plugin::PlayerFoodLossEvent* PROTOBUF_NONNULL _internal_mutable_player_food_loss(); - - public: - // .df.plugin.PlayerHealEvent player_heal = 20 [json_name = "playerHeal"]; - bool has_player_heal() const; - private: - bool _internal_has_player_heal() const; - - public: - void clear_player_heal() ; - const ::df::plugin::PlayerHealEvent& player_heal() const; - [[nodiscard]] ::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE release_player_heal(); - ::df::plugin::PlayerHealEvent* PROTOBUF_NONNULL mutable_player_heal(); - void set_allocated_player_heal(::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_heal(::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerHealEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_heal(); - - private: - const ::df::plugin::PlayerHealEvent& _internal_player_heal() const; - ::df::plugin::PlayerHealEvent* PROTOBUF_NONNULL _internal_mutable_player_heal(); - - public: - // .df.plugin.PlayerHurtEvent player_hurt = 21 [json_name = "playerHurt"]; - bool has_player_hurt() const; - private: - bool _internal_has_player_hurt() const; - - public: - void clear_player_hurt() ; - const ::df::plugin::PlayerHurtEvent& player_hurt() const; - [[nodiscard]] ::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE release_player_hurt(); - ::df::plugin::PlayerHurtEvent* PROTOBUF_NONNULL mutable_player_hurt(); - void set_allocated_player_hurt(::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_player_hurt(::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE value); - ::df::plugin::PlayerHurtEvent* PROTOBUF_NULLABLE unsafe_arena_release_player_hurt(); - - private: - const ::df::plugin::PlayerHurtEvent& _internal_player_hurt() const; - ::df::plugin::PlayerHurtEvent* PROTOBUF_NONNULL _internal_mutable_player_hurt(); - - public: - // .df.plugin.PlayerDeathEvent player_death = 22 [json_name = "playerDeath"]; - bool has_player_death() const; - private: - bool _internal_has_player_death() const; + bool _internal_has_player_death() const; public: void clear_player_death() ; @@ -2966,270 +2621,660 @@ class EventEnvelope final : public ::google::protobuf::Message private: bool _internal_has_world_liquid_decay() const; - public: - void clear_world_liquid_decay() ; - const ::df::plugin::WorldLiquidDecayEvent& world_liquid_decay() const; - [[nodiscard]] ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE release_world_liquid_decay(); - ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NONNULL mutable_world_liquid_decay(); - void set_allocated_world_liquid_decay(::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_liquid_decay(::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_liquid_decay(); + public: + void clear_world_liquid_decay() ; + const ::df::plugin::WorldLiquidDecayEvent& world_liquid_decay() const; + [[nodiscard]] ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE release_world_liquid_decay(); + ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NONNULL mutable_world_liquid_decay(); + void set_allocated_world_liquid_decay(::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_liquid_decay(::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_liquid_decay(); + + private: + const ::df::plugin::WorldLiquidDecayEvent& _internal_world_liquid_decay() const; + ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NONNULL _internal_mutable_world_liquid_decay(); + + public: + // .df.plugin.WorldLiquidHardenEvent world_liquid_harden = 72 [json_name = "worldLiquidHarden"]; + bool has_world_liquid_harden() const; + private: + bool _internal_has_world_liquid_harden() const; + + public: + void clear_world_liquid_harden() ; + const ::df::plugin::WorldLiquidHardenEvent& world_liquid_harden() const; + [[nodiscard]] ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE release_world_liquid_harden(); + ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NONNULL mutable_world_liquid_harden(); + void set_allocated_world_liquid_harden(::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_liquid_harden(::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_liquid_harden(); + + private: + const ::df::plugin::WorldLiquidHardenEvent& _internal_world_liquid_harden() const; + ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NONNULL _internal_mutable_world_liquid_harden(); + + public: + // .df.plugin.WorldSoundEvent world_sound = 73 [json_name = "worldSound"]; + bool has_world_sound() const; + private: + bool _internal_has_world_sound() const; + + public: + void clear_world_sound() ; + const ::df::plugin::WorldSoundEvent& world_sound() const; + [[nodiscard]] ::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE release_world_sound(); + ::df::plugin::WorldSoundEvent* PROTOBUF_NONNULL mutable_world_sound(); + void set_allocated_world_sound(::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_sound(::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_sound(); + + private: + const ::df::plugin::WorldSoundEvent& _internal_world_sound() const; + ::df::plugin::WorldSoundEvent* PROTOBUF_NONNULL _internal_mutable_world_sound(); + + public: + // .df.plugin.WorldFireSpreadEvent world_fire_spread = 74 [json_name = "worldFireSpread"]; + bool has_world_fire_spread() const; + private: + bool _internal_has_world_fire_spread() const; + + public: + void clear_world_fire_spread() ; + const ::df::plugin::WorldFireSpreadEvent& world_fire_spread() const; + [[nodiscard]] ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE release_world_fire_spread(); + ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NONNULL mutable_world_fire_spread(); + void set_allocated_world_fire_spread(::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_fire_spread(::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_fire_spread(); + + private: + const ::df::plugin::WorldFireSpreadEvent& _internal_world_fire_spread() const; + ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NONNULL _internal_mutable_world_fire_spread(); + + public: + // .df.plugin.WorldBlockBurnEvent world_block_burn = 75 [json_name = "worldBlockBurn"]; + bool has_world_block_burn() const; + private: + bool _internal_has_world_block_burn() const; + + public: + void clear_world_block_burn() ; + const ::df::plugin::WorldBlockBurnEvent& world_block_burn() const; + [[nodiscard]] ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE release_world_block_burn(); + ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NONNULL mutable_world_block_burn(); + void set_allocated_world_block_burn(::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_block_burn(::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_block_burn(); + + private: + const ::df::plugin::WorldBlockBurnEvent& _internal_world_block_burn() const; + ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NONNULL _internal_mutable_world_block_burn(); + + public: + // .df.plugin.WorldCropTrampleEvent world_crop_trample = 76 [json_name = "worldCropTrample"]; + bool has_world_crop_trample() const; + private: + bool _internal_has_world_crop_trample() const; + + public: + void clear_world_crop_trample() ; + const ::df::plugin::WorldCropTrampleEvent& world_crop_trample() const; + [[nodiscard]] ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE release_world_crop_trample(); + ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NONNULL mutable_world_crop_trample(); + void set_allocated_world_crop_trample(::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_crop_trample(::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_crop_trample(); + + private: + const ::df::plugin::WorldCropTrampleEvent& _internal_world_crop_trample() const; + ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NONNULL _internal_mutable_world_crop_trample(); + + public: + // .df.plugin.WorldLeavesDecayEvent world_leaves_decay = 77 [json_name = "worldLeavesDecay"]; + bool has_world_leaves_decay() const; + private: + bool _internal_has_world_leaves_decay() const; + + public: + void clear_world_leaves_decay() ; + const ::df::plugin::WorldLeavesDecayEvent& world_leaves_decay() const; + [[nodiscard]] ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE release_world_leaves_decay(); + ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NONNULL mutable_world_leaves_decay(); + void set_allocated_world_leaves_decay(::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_leaves_decay(::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_leaves_decay(); + + private: + const ::df::plugin::WorldLeavesDecayEvent& _internal_world_leaves_decay() const; + ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NONNULL _internal_mutable_world_leaves_decay(); + + public: + // .df.plugin.WorldEntitySpawnEvent world_entity_spawn = 78 [json_name = "worldEntitySpawn"]; + bool has_world_entity_spawn() const; + private: + bool _internal_has_world_entity_spawn() const; + + public: + void clear_world_entity_spawn() ; + const ::df::plugin::WorldEntitySpawnEvent& world_entity_spawn() const; + [[nodiscard]] ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE release_world_entity_spawn(); + ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NONNULL mutable_world_entity_spawn(); + void set_allocated_world_entity_spawn(::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_entity_spawn(::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_entity_spawn(); + + private: + const ::df::plugin::WorldEntitySpawnEvent& _internal_world_entity_spawn() const; + ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NONNULL _internal_mutable_world_entity_spawn(); + + public: + // .df.plugin.WorldEntityDespawnEvent world_entity_despawn = 79 [json_name = "worldEntityDespawn"]; + bool has_world_entity_despawn() const; + private: + bool _internal_has_world_entity_despawn() const; + + public: + void clear_world_entity_despawn() ; + const ::df::plugin::WorldEntityDespawnEvent& world_entity_despawn() const; + [[nodiscard]] ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE release_world_entity_despawn(); + ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NONNULL mutable_world_entity_despawn(); + void set_allocated_world_entity_despawn(::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_entity_despawn(::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_entity_despawn(); + + private: + const ::df::plugin::WorldEntityDespawnEvent& _internal_world_entity_despawn() const; + ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NONNULL _internal_mutable_world_entity_despawn(); + + public: + // .df.plugin.WorldExplosionEvent world_explosion = 80 [json_name = "worldExplosion"]; + bool has_world_explosion() const; + private: + bool _internal_has_world_explosion() const; + + public: + void clear_world_explosion() ; + const ::df::plugin::WorldExplosionEvent& world_explosion() const; + [[nodiscard]] ::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE release_world_explosion(); + ::df::plugin::WorldExplosionEvent* PROTOBUF_NONNULL mutable_world_explosion(); + void set_allocated_world_explosion(::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_explosion(::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_explosion(); + + private: + const ::df::plugin::WorldExplosionEvent& _internal_world_explosion() const; + ::df::plugin::WorldExplosionEvent* PROTOBUF_NONNULL _internal_mutable_world_explosion(); + + public: + // .df.plugin.WorldCloseEvent world_close = 81 [json_name = "worldClose"]; + bool has_world_close() const; + private: + bool _internal_has_world_close() const; + + public: + void clear_world_close() ; + const ::df::plugin::WorldCloseEvent& world_close() const; + [[nodiscard]] ::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE release_world_close(); + ::df::plugin::WorldCloseEvent* PROTOBUF_NONNULL mutable_world_close(); + void set_allocated_world_close(::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_world_close(::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE value); + ::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_close(); + + private: + const ::df::plugin::WorldCloseEvent& _internal_world_close() const; + ::df::plugin::WorldCloseEvent* PROTOBUF_NONNULL _internal_mutable_world_close(); + + public: + void clear_payload(); + PayloadCase payload_case() const; + // @@protoc_insertion_point(class_scope:df.plugin.EventEnvelope) + private: + class _Internal; + void set_has_player_join(); + void set_has_player_quit(); + void set_has_player_move(); + void set_has_player_jump(); + void set_has_player_teleport(); + void set_has_player_change_world(); + void set_has_player_toggle_sprint(); + void set_has_player_toggle_sneak(); + void set_has_chat(); + void set_has_player_food_loss(); + void set_has_player_heal(); + void set_has_player_hurt(); + void set_has_player_death(); + void set_has_player_respawn(); + void set_has_player_skin_change(); + void set_has_player_fire_extinguish(); + void set_has_player_start_break(); + void set_has_block_break(); + void set_has_player_block_place(); + void set_has_player_block_pick(); + void set_has_player_item_use(); + void set_has_player_item_use_on_block(); + void set_has_player_item_use_on_entity(); + void set_has_player_item_release(); + void set_has_player_item_consume(); + void set_has_player_attack_entity(); + void set_has_player_experience_gain(); + void set_has_player_punch_air(); + void set_has_player_sign_edit(); + void set_has_player_lectern_page_turn(); + void set_has_player_item_damage(); + void set_has_player_item_pickup(); + void set_has_player_held_slot_change(); + void set_has_player_item_drop(); + void set_has_player_transfer(); + void set_has_command(); + void set_has_player_diagnostics(); + void set_has_world_liquid_flow(); + void set_has_world_liquid_decay(); + void set_has_world_liquid_harden(); + void set_has_world_sound(); + void set_has_world_fire_spread(); + void set_has_world_block_burn(); + void set_has_world_crop_trample(); + void set_has_world_leaves_decay(); + void set_has_world_entity_spawn(); + void set_has_world_entity_despawn(); + void set_has_world_explosion(); + void set_has_world_close(); + inline bool has_payload() const; + inline void clear_has_payload(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable<2, 52, + 49, 88, + 13> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + inline explicit Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, + const EventEnvelope& from_msg); + ::google::protobuf::internal::HasBits<1> _has_bits_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::google::protobuf::internal::ArenaStringPtr event_id_; + int type_; + bool expects_response_; + union PayloadUnion { + constexpr PayloadUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_join_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_quit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_move_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_jump_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_teleport_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_change_world_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_toggle_sprint_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_toggle_sneak_; + ::google::protobuf::Message* PROTOBUF_NULLABLE chat_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_food_loss_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_heal_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_hurt_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_death_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_respawn_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_skin_change_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_fire_extinguish_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_start_break_; + ::google::protobuf::Message* PROTOBUF_NULLABLE block_break_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_block_place_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_block_pick_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_on_block_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_on_entity_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_release_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_consume_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_attack_entity_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_experience_gain_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_punch_air_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_sign_edit_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_lectern_page_turn_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_damage_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_pickup_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_held_slot_change_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_drop_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_transfer_; + ::google::protobuf::Message* PROTOBUF_NULLABLE command_; + ::google::protobuf::Message* PROTOBUF_NULLABLE player_diagnostics_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_flow_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_decay_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_harden_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_sound_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_fire_spread_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_block_burn_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_crop_trample_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_leaves_decay_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_entity_spawn_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_entity_despawn_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_explosion_; + ::google::protobuf::Message* PROTOBUF_NULLABLE world_close_; + } payload_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_plugin_2eproto; +}; + +extern const ::google::protobuf::internal::ClassDataFull EventEnvelope_class_data_; +// ------------------------------------------------------------------- + +class PluginToHost final : public ::google::protobuf::Message +/* @@protoc_insertion_point(class_definition:df.plugin.PluginToHost) */ { + public: + inline PluginToHost() : PluginToHost(nullptr) {} + ~PluginToHost() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PluginToHost* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PluginToHost)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PluginToHost(::google::protobuf::internal::ConstantInitialized); + + inline PluginToHost(const PluginToHost& from) : PluginToHost(nullptr, from) {} + inline PluginToHost(PluginToHost&& from) noexcept + : PluginToHost(nullptr, ::std::move(from)) {} + inline PluginToHost& operator=(const PluginToHost& from) { + CopyFrom(from); + return *this; + } + inline PluginToHost& operator=(PluginToHost&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); + } + inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); + } - private: - const ::df::plugin::WorldLiquidDecayEvent& _internal_world_liquid_decay() const; - ::df::plugin::WorldLiquidDecayEvent* PROTOBUF_NONNULL _internal_mutable_world_liquid_decay(); + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { + return GetDescriptor(); + } + static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const PluginToHost& default_instance() { + return *reinterpret_cast( + &_PluginToHost_default_instance_); + } + enum PayloadCase { + kHello = 10, + kSubscribe = 11, + kServerInfo = 12, + kActions = 20, + kLog = 30, + kEventResult = 40, + PAYLOAD_NOT_SET = 0, + }; + static constexpr int kIndexInFileMessages = 6; + friend void swap(PluginToHost& a, PluginToHost& b) { a.Swap(&b); } + inline void Swap(PluginToHost* PROTOBUF_NONNULL other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PluginToHost* PROTOBUF_NONNULL other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } - public: - // .df.plugin.WorldLiquidHardenEvent world_liquid_harden = 72 [json_name = "worldLiquidHarden"]; - bool has_world_liquid_harden() const; - private: - bool _internal_has_world_liquid_harden() const; + // implements Message ---------------------------------------------- - public: - void clear_world_liquid_harden() ; - const ::df::plugin::WorldLiquidHardenEvent& world_liquid_harden() const; - [[nodiscard]] ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE release_world_liquid_harden(); - ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NONNULL mutable_world_liquid_harden(); - void set_allocated_world_liquid_harden(::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_liquid_harden(::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_liquid_harden(); + PluginToHost* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { + return ::google::protobuf::Message::DefaultConstruct(arena); + } + using ::google::protobuf::Message::CopyFrom; + void CopyFrom(const PluginToHost& from); + using ::google::protobuf::Message::MergeFrom; + void MergeFrom(const PluginToHost& from) { PluginToHost::MergeImpl(*this, from); } private: - const ::df::plugin::WorldLiquidHardenEvent& _internal_world_liquid_harden() const; - ::df::plugin::WorldLiquidHardenEvent* PROTOBUF_NONNULL _internal_mutable_world_liquid_harden(); + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); public: - // .df.plugin.WorldSoundEvent world_sound = 73 [json_name = "worldSound"]; - bool has_world_sound() const; + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) private: - bool _internal_has_world_sound() const; + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); public: - void clear_world_sound() ; - const ::df::plugin::WorldSoundEvent& world_sound() const; - [[nodiscard]] ::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE release_world_sound(); - ::df::plugin::WorldSoundEvent* PROTOBUF_NONNULL mutable_world_sound(); - void set_allocated_world_sound(::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_sound(::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldSoundEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_sound(); - - private: - const ::df::plugin::WorldSoundEvent& _internal_world_sound() const; - ::df::plugin::WorldSoundEvent* PROTOBUF_NONNULL _internal_mutable_world_sound(); + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( + ::uint8_t* PROTOBUF_NONNULL target, + ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } - public: - // .df.plugin.WorldFireSpreadEvent world_fire_spread = 74 [json_name = "worldFireSpread"]; - bool has_world_fire_spread() const; private: - bool _internal_has_world_fire_spread() const; + void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PluginToHost* PROTOBUF_NONNULL other); + private: + template + friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "df.plugin.PluginToHost"; } - public: - void clear_world_fire_spread() ; - const ::df::plugin::WorldFireSpreadEvent& world_fire_spread() const; - [[nodiscard]] ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE release_world_fire_spread(); - ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NONNULL mutable_world_fire_spread(); - void set_allocated_world_fire_spread(::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_fire_spread(::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_fire_spread(); + explicit PluginToHost(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + PluginToHost(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const PluginToHost& from); + PluginToHost( + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, PluginToHost&& from) noexcept + : PluginToHost(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; + static void* PROTOBUF_NONNULL PlacementNew_( + const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); + static constexpr auto InternalNewImpl_(); - private: - const ::df::plugin::WorldFireSpreadEvent& _internal_world_fire_spread() const; - ::df::plugin::WorldFireSpreadEvent* PROTOBUF_NONNULL _internal_mutable_world_fire_spread(); + public: + static constexpr auto InternalGenerateClassData_(); - public: - // .df.plugin.WorldBlockBurnEvent world_block_burn = 75 [json_name = "worldBlockBurn"]; - bool has_world_block_burn() const; - private: - bool _internal_has_world_block_burn() const; + ::google::protobuf::Metadata GetMetadata() const; + // nested types ---------------------------------------------------- - public: - void clear_world_block_burn() ; - const ::df::plugin::WorldBlockBurnEvent& world_block_burn() const; - [[nodiscard]] ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE release_world_block_burn(); - ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NONNULL mutable_world_block_burn(); - void set_allocated_world_block_burn(::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_block_burn(::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_block_burn(); + // accessors ------------------------------------------------------- + enum : int { + kPluginIdFieldNumber = 1, + kHelloFieldNumber = 10, + kSubscribeFieldNumber = 11, + kServerInfoFieldNumber = 12, + kActionsFieldNumber = 20, + kLogFieldNumber = 30, + kEventResultFieldNumber = 40, + }; + // string plugin_id = 1 [json_name = "pluginId"]; + void clear_plugin_id() ; + const ::std::string& plugin_id() const; + template + void set_plugin_id(Arg_&& arg, Args_... args); + ::std::string* PROTOBUF_NONNULL mutable_plugin_id(); + [[nodiscard]] ::std::string* PROTOBUF_NULLABLE release_plugin_id(); + void set_allocated_plugin_id(::std::string* PROTOBUF_NULLABLE value); private: - const ::df::plugin::WorldBlockBurnEvent& _internal_world_block_burn() const; - ::df::plugin::WorldBlockBurnEvent* PROTOBUF_NONNULL _internal_mutable_world_block_burn(); + const ::std::string& _internal_plugin_id() const; + PROTOBUF_ALWAYS_INLINE void _internal_set_plugin_id(const ::std::string& value); + ::std::string* PROTOBUF_NONNULL _internal_mutable_plugin_id(); public: - // .df.plugin.WorldCropTrampleEvent world_crop_trample = 76 [json_name = "worldCropTrample"]; - bool has_world_crop_trample() const; + // .df.plugin.PluginHello hello = 10 [json_name = "hello"]; + bool has_hello() const; private: - bool _internal_has_world_crop_trample() const; + bool _internal_has_hello() const; public: - void clear_world_crop_trample() ; - const ::df::plugin::WorldCropTrampleEvent& world_crop_trample() const; - [[nodiscard]] ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE release_world_crop_trample(); - ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NONNULL mutable_world_crop_trample(); - void set_allocated_world_crop_trample(::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_crop_trample(::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_crop_trample(); + void clear_hello() ; + const ::df::plugin::PluginHello& hello() const; + [[nodiscard]] ::df::plugin::PluginHello* PROTOBUF_NULLABLE release_hello(); + ::df::plugin::PluginHello* PROTOBUF_NONNULL mutable_hello(); + void set_allocated_hello(::df::plugin::PluginHello* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_hello(::df::plugin::PluginHello* PROTOBUF_NULLABLE value); + ::df::plugin::PluginHello* PROTOBUF_NULLABLE unsafe_arena_release_hello(); private: - const ::df::plugin::WorldCropTrampleEvent& _internal_world_crop_trample() const; - ::df::plugin::WorldCropTrampleEvent* PROTOBUF_NONNULL _internal_mutable_world_crop_trample(); + const ::df::plugin::PluginHello& _internal_hello() const; + ::df::plugin::PluginHello* PROTOBUF_NONNULL _internal_mutable_hello(); public: - // .df.plugin.WorldLeavesDecayEvent world_leaves_decay = 77 [json_name = "worldLeavesDecay"]; - bool has_world_leaves_decay() const; + // .df.plugin.EventSubscribe subscribe = 11 [json_name = "subscribe"]; + bool has_subscribe() const; private: - bool _internal_has_world_leaves_decay() const; + bool _internal_has_subscribe() const; public: - void clear_world_leaves_decay() ; - const ::df::plugin::WorldLeavesDecayEvent& world_leaves_decay() const; - [[nodiscard]] ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE release_world_leaves_decay(); - ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NONNULL mutable_world_leaves_decay(); - void set_allocated_world_leaves_decay(::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_leaves_decay(::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_leaves_decay(); - - private: - const ::df::plugin::WorldLeavesDecayEvent& _internal_world_leaves_decay() const; - ::df::plugin::WorldLeavesDecayEvent* PROTOBUF_NONNULL _internal_mutable_world_leaves_decay(); + void clear_subscribe() ; + const ::df::plugin::EventSubscribe& subscribe() const; + [[nodiscard]] ::df::plugin::EventSubscribe* PROTOBUF_NULLABLE release_subscribe(); + ::df::plugin::EventSubscribe* PROTOBUF_NONNULL mutable_subscribe(); + void set_allocated_subscribe(::df::plugin::EventSubscribe* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_subscribe(::df::plugin::EventSubscribe* PROTOBUF_NULLABLE value); + ::df::plugin::EventSubscribe* PROTOBUF_NULLABLE unsafe_arena_release_subscribe(); - public: - // .df.plugin.WorldEntitySpawnEvent world_entity_spawn = 78 [json_name = "worldEntitySpawn"]; - bool has_world_entity_spawn() const; private: - bool _internal_has_world_entity_spawn() const; + const ::df::plugin::EventSubscribe& _internal_subscribe() const; + ::df::plugin::EventSubscribe* PROTOBUF_NONNULL _internal_mutable_subscribe(); public: - void clear_world_entity_spawn() ; - const ::df::plugin::WorldEntitySpawnEvent& world_entity_spawn() const; - [[nodiscard]] ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE release_world_entity_spawn(); - ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NONNULL mutable_world_entity_spawn(); - void set_allocated_world_entity_spawn(::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_entity_spawn(::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_entity_spawn(); + // .df.plugin.ServerInformationRequest server_info = 12 [json_name = "serverInfo"]; + bool has_server_info() const; + private: + bool _internal_has_server_info() const; + + public: + void clear_server_info() ; + const ::df::plugin::ServerInformationRequest& server_info() const; + [[nodiscard]] ::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE release_server_info(); + ::df::plugin::ServerInformationRequest* PROTOBUF_NONNULL mutable_server_info(); + void set_allocated_server_info(::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_server_info(::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE value); + ::df::plugin::ServerInformationRequest* PROTOBUF_NULLABLE unsafe_arena_release_server_info(); private: - const ::df::plugin::WorldEntitySpawnEvent& _internal_world_entity_spawn() const; - ::df::plugin::WorldEntitySpawnEvent* PROTOBUF_NONNULL _internal_mutable_world_entity_spawn(); + const ::df::plugin::ServerInformationRequest& _internal_server_info() const; + ::df::plugin::ServerInformationRequest* PROTOBUF_NONNULL _internal_mutable_server_info(); public: - // .df.plugin.WorldEntityDespawnEvent world_entity_despawn = 79 [json_name = "worldEntityDespawn"]; - bool has_world_entity_despawn() const; + // .df.plugin.ActionBatch actions = 20 [json_name = "actions"]; + bool has_actions() const; private: - bool _internal_has_world_entity_despawn() const; + bool _internal_has_actions() const; public: - void clear_world_entity_despawn() ; - const ::df::plugin::WorldEntityDespawnEvent& world_entity_despawn() const; - [[nodiscard]] ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE release_world_entity_despawn(); - ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NONNULL mutable_world_entity_despawn(); - void set_allocated_world_entity_despawn(::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_entity_despawn(::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_entity_despawn(); + void clear_actions() ; + const ::df::plugin::ActionBatch& actions() const; + [[nodiscard]] ::df::plugin::ActionBatch* PROTOBUF_NULLABLE release_actions(); + ::df::plugin::ActionBatch* PROTOBUF_NONNULL mutable_actions(); + void set_allocated_actions(::df::plugin::ActionBatch* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_actions(::df::plugin::ActionBatch* PROTOBUF_NULLABLE value); + ::df::plugin::ActionBatch* PROTOBUF_NULLABLE unsafe_arena_release_actions(); private: - const ::df::plugin::WorldEntityDespawnEvent& _internal_world_entity_despawn() const; - ::df::plugin::WorldEntityDespawnEvent* PROTOBUF_NONNULL _internal_mutable_world_entity_despawn(); + const ::df::plugin::ActionBatch& _internal_actions() const; + ::df::plugin::ActionBatch* PROTOBUF_NONNULL _internal_mutable_actions(); public: - // .df.plugin.WorldExplosionEvent world_explosion = 80 [json_name = "worldExplosion"]; - bool has_world_explosion() const; + // .df.plugin.LogMessage log = 30 [json_name = "log"]; + bool has_log() const; private: - bool _internal_has_world_explosion() const; + bool _internal_has_log() const; public: - void clear_world_explosion() ; - const ::df::plugin::WorldExplosionEvent& world_explosion() const; - [[nodiscard]] ::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE release_world_explosion(); - ::df::plugin::WorldExplosionEvent* PROTOBUF_NONNULL mutable_world_explosion(); - void set_allocated_world_explosion(::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_explosion(::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldExplosionEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_explosion(); + void clear_log() ; + const ::df::plugin::LogMessage& log() const; + [[nodiscard]] ::df::plugin::LogMessage* PROTOBUF_NULLABLE release_log(); + ::df::plugin::LogMessage* PROTOBUF_NONNULL mutable_log(); + void set_allocated_log(::df::plugin::LogMessage* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_log(::df::plugin::LogMessage* PROTOBUF_NULLABLE value); + ::df::plugin::LogMessage* PROTOBUF_NULLABLE unsafe_arena_release_log(); private: - const ::df::plugin::WorldExplosionEvent& _internal_world_explosion() const; - ::df::plugin::WorldExplosionEvent* PROTOBUF_NONNULL _internal_mutable_world_explosion(); + const ::df::plugin::LogMessage& _internal_log() const; + ::df::plugin::LogMessage* PROTOBUF_NONNULL _internal_mutable_log(); public: - // .df.plugin.WorldCloseEvent world_close = 81 [json_name = "worldClose"]; - bool has_world_close() const; + // .df.plugin.EventResult event_result = 40 [json_name = "eventResult"]; + bool has_event_result() const; private: - bool _internal_has_world_close() const; + bool _internal_has_event_result() const; public: - void clear_world_close() ; - const ::df::plugin::WorldCloseEvent& world_close() const; - [[nodiscard]] ::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE release_world_close(); - ::df::plugin::WorldCloseEvent* PROTOBUF_NONNULL mutable_world_close(); - void set_allocated_world_close(::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_close(::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE value); - ::df::plugin::WorldCloseEvent* PROTOBUF_NULLABLE unsafe_arena_release_world_close(); + void clear_event_result() ; + const ::df::plugin::EventResult& event_result() const; + [[nodiscard]] ::df::plugin::EventResult* PROTOBUF_NULLABLE release_event_result(); + ::df::plugin::EventResult* PROTOBUF_NONNULL mutable_event_result(); + void set_allocated_event_result(::df::plugin::EventResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_event_result(::df::plugin::EventResult* PROTOBUF_NULLABLE value); + ::df::plugin::EventResult* PROTOBUF_NULLABLE unsafe_arena_release_event_result(); private: - const ::df::plugin::WorldCloseEvent& _internal_world_close() const; - ::df::plugin::WorldCloseEvent* PROTOBUF_NONNULL _internal_mutable_world_close(); + const ::df::plugin::EventResult& _internal_event_result() const; + ::df::plugin::EventResult* PROTOBUF_NONNULL _internal_mutable_event_result(); public: void clear_payload(); PayloadCase payload_case() const; - // @@protoc_insertion_point(class_scope:df.plugin.EventEnvelope) + // @@protoc_insertion_point(class_scope:df.plugin.PluginToHost) private: class _Internal; - void set_has_player_join(); - void set_has_player_quit(); - void set_has_player_move(); - void set_has_player_jump(); - void set_has_player_teleport(); - void set_has_player_change_world(); - void set_has_player_toggle_sprint(); - void set_has_player_toggle_sneak(); - void set_has_chat(); - void set_has_player_food_loss(); - void set_has_player_heal(); - void set_has_player_hurt(); - void set_has_player_death(); - void set_has_player_respawn(); - void set_has_player_skin_change(); - void set_has_player_fire_extinguish(); - void set_has_player_start_break(); - void set_has_block_break(); - void set_has_player_block_place(); - void set_has_player_block_pick(); - void set_has_player_item_use(); - void set_has_player_item_use_on_block(); - void set_has_player_item_use_on_entity(); - void set_has_player_item_release(); - void set_has_player_item_consume(); - void set_has_player_attack_entity(); - void set_has_player_experience_gain(); - void set_has_player_punch_air(); - void set_has_player_sign_edit(); - void set_has_player_lectern_page_turn(); - void set_has_player_item_damage(); - void set_has_player_item_pickup(); - void set_has_player_held_slot_change(); - void set_has_player_item_drop(); - void set_has_player_transfer(); - void set_has_command(); - void set_has_player_diagnostics(); - void set_has_world_liquid_flow(); - void set_has_world_liquid_decay(); - void set_has_world_liquid_harden(); - void set_has_world_sound(); - void set_has_world_fire_spread(); - void set_has_world_block_burn(); - void set_has_world_crop_trample(); - void set_has_world_leaves_decay(); - void set_has_world_entity_spawn(); - void set_has_world_entity_despawn(); - void set_has_world_explosion(); - void set_has_world_close(); + void set_has_hello(); + void set_has_subscribe(); + void set_has_server_info(); + void set_has_actions(); + void set_has_log(); + void set_has_event_result(); inline bool has_payload() const; inline void clear_has_payload(); friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<2, 52, - 49, 88, - 13> + static const ::google::protobuf::internal::TcParseTable<0, 7, + 6, 40, + 7> _table_; friend class ::google::protobuf::MessageLite; @@ -3246,64 +3291,19 @@ class EventEnvelope final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const EventEnvelope& from_msg); + const PluginToHost& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::internal::ArenaStringPtr event_id_; - int type_; - bool expects_response_; + ::google::protobuf::internal::ArenaStringPtr plugin_id_; union PayloadUnion { constexpr PayloadUnion() : _constinit_{} {} ::google::protobuf::internal::ConstantInitialized _constinit_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_join_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_quit_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_move_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_jump_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_teleport_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_change_world_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_toggle_sprint_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_toggle_sneak_; - ::google::protobuf::Message* PROTOBUF_NULLABLE chat_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_food_loss_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_heal_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_hurt_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_death_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_respawn_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_skin_change_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_fire_extinguish_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_start_break_; - ::google::protobuf::Message* PROTOBUF_NULLABLE block_break_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_block_place_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_block_pick_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_on_block_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_use_on_entity_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_release_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_consume_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_attack_entity_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_experience_gain_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_punch_air_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_sign_edit_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_lectern_page_turn_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_damage_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_pickup_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_held_slot_change_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_item_drop_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_transfer_; - ::google::protobuf::Message* PROTOBUF_NULLABLE command_; - ::google::protobuf::Message* PROTOBUF_NULLABLE player_diagnostics_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_flow_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_decay_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_liquid_harden_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_sound_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_fire_spread_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_block_burn_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_crop_trample_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_leaves_decay_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_entity_spawn_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_entity_despawn_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_explosion_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_close_; + ::google::protobuf::Message* PROTOBUF_NULLABLE hello_; + ::google::protobuf::Message* PROTOBUF_NULLABLE subscribe_; + ::google::protobuf::Message* PROTOBUF_NULLABLE server_info_; + ::google::protobuf::Message* PROTOBUF_NULLABLE actions_; + ::google::protobuf::Message* PROTOBUF_NULLABLE log_; + ::google::protobuf::Message* PROTOBUF_NULLABLE event_result_; } payload_; ::uint32_t _oneof_case_[1]; PROTOBUF_TSAN_DECLARE_MEMBER @@ -3312,7 +3312,7 @@ class EventEnvelope final : public ::google::protobuf::Message friend struct ::TableStruct_plugin_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull EventEnvelope_class_data_; +extern const ::google::protobuf::internal::ClassDataFull PluginToHost_class_data_; // ------------------------------------------------------------------- class HostToPlugin final : public ::google::protobuf::Message @@ -3375,6 +3375,7 @@ class HostToPlugin final : public ::google::protobuf::Message kShutdown = 11, kServerInfo = 12, kEvent = 20, + kActionResult = 21, PAYLOAD_NOT_SET = 0, }; static constexpr int kIndexInFileMessages = 0; @@ -3469,6 +3470,7 @@ class HostToPlugin final : public ::google::protobuf::Message kShutdownFieldNumber = 11, kServerInfoFieldNumber = 12, kEventFieldNumber = 20, + kActionResultFieldNumber = 21, }; // string plugin_id = 1 [json_name = "pluginId"]; void clear_plugin_id() ; @@ -3560,6 +3562,25 @@ class HostToPlugin final : public ::google::protobuf::Message const ::df::plugin::EventEnvelope& _internal_event() const; ::df::plugin::EventEnvelope* PROTOBUF_NONNULL _internal_mutable_event(); + public: + // .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; + bool has_action_result() const; + private: + bool _internal_has_action_result() const; + + public: + void clear_action_result() ; + const ::df::plugin::ActionResult& action_result() const; + [[nodiscard]] ::df::plugin::ActionResult* PROTOBUF_NULLABLE release_action_result(); + ::df::plugin::ActionResult* PROTOBUF_NONNULL mutable_action_result(); + void set_allocated_action_result(::df::plugin::ActionResult* PROTOBUF_NULLABLE value); + void unsafe_arena_set_allocated_action_result(::df::plugin::ActionResult* PROTOBUF_NULLABLE value); + ::df::plugin::ActionResult* PROTOBUF_NULLABLE unsafe_arena_release_action_result(); + + private: + const ::df::plugin::ActionResult& _internal_action_result() const; + ::df::plugin::ActionResult* PROTOBUF_NONNULL _internal_mutable_action_result(); + public: void clear_payload(); PayloadCase payload_case() const; @@ -3570,11 +3591,12 @@ class HostToPlugin final : public ::google::protobuf::Message void set_has_shutdown(); void set_has_server_info(); void set_has_event(); + void set_has_action_result(); inline bool has_payload() const; inline void clear_has_payload(); friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<0, 5, - 4, 40, + static const ::google::protobuf::internal::TcParseTable<0, 6, + 5, 40, 2> _table_; @@ -3603,6 +3625,7 @@ class HostToPlugin final : public ::google::protobuf::Message ::google::protobuf::Message* PROTOBUF_NULLABLE shutdown_; ::google::protobuf::Message* PROTOBUF_NULLABLE server_info_; ::google::protobuf::Message* PROTOBUF_NULLABLE event_; + ::google::protobuf::Message* PROTOBUF_NULLABLE action_result_; } payload_; ::uint32_t _oneof_case_[1]; PROTOBUF_TSAN_DECLARE_MEMBER @@ -4022,6 +4045,77 @@ inline ::df::plugin::EventEnvelope* PROTOBUF_NONNULL HostToPlugin::mutable_event return _msg; } +// .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; +inline bool HostToPlugin::has_action_result() const { + return payload_case() == kActionResult; +} +inline bool HostToPlugin::_internal_has_action_result() const { + return payload_case() == kActionResult; +} +inline void HostToPlugin::set_has_action_result() { + _impl_._oneof_case_[0] = kActionResult; +} +inline ::df::plugin::ActionResult* PROTOBUF_NULLABLE HostToPlugin::release_action_result() { + // @@protoc_insertion_point(field_release:df.plugin.HostToPlugin.action_result) + if (payload_case() == kActionResult) { + clear_has_payload(); + auto* temp = reinterpret_cast<::df::plugin::ActionResult*>(_impl_.payload_.action_result_); + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.payload_.action_result_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::df::plugin::ActionResult& HostToPlugin::_internal_action_result() const { + return payload_case() == kActionResult ? static_cast(*reinterpret_cast<::df::plugin::ActionResult*>(_impl_.payload_.action_result_)) + : reinterpret_cast(::df::plugin::_ActionResult_default_instance_); +} +inline const ::df::plugin::ActionResult& HostToPlugin::action_result() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:df.plugin.HostToPlugin.action_result) + return _internal_action_result(); +} +inline ::df::plugin::ActionResult* PROTOBUF_NULLABLE HostToPlugin::unsafe_arena_release_action_result() { + // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.HostToPlugin.action_result) + if (payload_case() == kActionResult) { + clear_has_payload(); + auto* temp = reinterpret_cast<::df::plugin::ActionResult*>(_impl_.payload_.action_result_); + _impl_.payload_.action_result_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void HostToPlugin::unsafe_arena_set_allocated_action_result( + ::df::plugin::ActionResult* PROTOBUF_NULLABLE value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_payload(); + if (value) { + set_has_action_result(); + _impl_.payload_.action_result_ = reinterpret_cast<::google::protobuf::Message*>(value); + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.HostToPlugin.action_result) +} +inline ::df::plugin::ActionResult* PROTOBUF_NONNULL HostToPlugin::_internal_mutable_action_result() { + if (payload_case() != kActionResult) { + clear_payload(); + set_has_action_result(); + _impl_.payload_.action_result_ = reinterpret_cast<::google::protobuf::Message*>( + ::google::protobuf::Message::DefaultConstruct<::df::plugin::ActionResult>(GetArena())); + } + return reinterpret_cast<::df::plugin::ActionResult*>(_impl_.payload_.action_result_); +} +inline ::df::plugin::ActionResult* PROTOBUF_NONNULL HostToPlugin::mutable_action_result() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::df::plugin::ActionResult* _msg = _internal_mutable_action_result(); + // @@protoc_insertion_point(field_mutable:df.plugin.HostToPlugin.action_result) + return _msg; +} + inline bool HostToPlugin::has_payload() const { return payload_case() != PAYLOAD_NOT_SET; } diff --git a/packages/node/src/generated/actions.js b/packages/node/src/generated/actions.js index cc630bf..441771d 100644 --- a/packages/node/src/generated/actions.js +++ b/packages/node/src/generated/actions.js @@ -5,8 +5,141 @@ // source: actions.proto /* eslint-disable */ import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; -import { effectTypeFromJSON, effectTypeToJSON, gameModeFromJSON, gameModeToJSON, ItemStack, soundFromJSON, soundToJSON, Vec3, } from "./common.js"; +import { BBox, BlockPos, BlockState, difficultyFromJSON, difficultyToJSON, effectTypeFromJSON, effectTypeToJSON, EntityRef, gameModeFromJSON, gameModeToJSON, ItemStack, soundFromJSON, soundToJSON, Vec3, WorldRef, } from "./common.js"; export const protobufPackage = "df.plugin"; +export var ParticleType; +(function (ParticleType) { + ParticleType[ParticleType["PARTICLE_TYPE_UNSPECIFIED"] = 0] = "PARTICLE_TYPE_UNSPECIFIED"; + ParticleType[ParticleType["PARTICLE_HUGE_EXPLOSION"] = 1] = "PARTICLE_HUGE_EXPLOSION"; + ParticleType[ParticleType["PARTICLE_ENDERMAN_TELEPORT"] = 2] = "PARTICLE_ENDERMAN_TELEPORT"; + ParticleType[ParticleType["PARTICLE_SNOWBALL_POOF"] = 3] = "PARTICLE_SNOWBALL_POOF"; + ParticleType[ParticleType["PARTICLE_EGG_SMASH"] = 4] = "PARTICLE_EGG_SMASH"; + ParticleType[ParticleType["PARTICLE_SPLASH"] = 5] = "PARTICLE_SPLASH"; + ParticleType[ParticleType["PARTICLE_EFFECT"] = 6] = "PARTICLE_EFFECT"; + ParticleType[ParticleType["PARTICLE_ENTITY_FLAME"] = 7] = "PARTICLE_ENTITY_FLAME"; + ParticleType[ParticleType["PARTICLE_FLAME"] = 8] = "PARTICLE_FLAME"; + ParticleType[ParticleType["PARTICLE_DUST"] = 9] = "PARTICLE_DUST"; + ParticleType[ParticleType["PARTICLE_BLOCK_FORCE_FIELD"] = 10] = "PARTICLE_BLOCK_FORCE_FIELD"; + ParticleType[ParticleType["PARTICLE_BONE_MEAL"] = 11] = "PARTICLE_BONE_MEAL"; + ParticleType[ParticleType["PARTICLE_EVAPORATE"] = 12] = "PARTICLE_EVAPORATE"; + ParticleType[ParticleType["PARTICLE_WATER_DRIP"] = 13] = "PARTICLE_WATER_DRIP"; + ParticleType[ParticleType["PARTICLE_LAVA_DRIP"] = 14] = "PARTICLE_LAVA_DRIP"; + ParticleType[ParticleType["PARTICLE_LAVA"] = 15] = "PARTICLE_LAVA"; + ParticleType[ParticleType["PARTICLE_DUST_PLUME"] = 16] = "PARTICLE_DUST_PLUME"; + ParticleType[ParticleType["PARTICLE_BLOCK_BREAK"] = 17] = "PARTICLE_BLOCK_BREAK"; + ParticleType[ParticleType["PARTICLE_PUNCH_BLOCK"] = 18] = "PARTICLE_PUNCH_BLOCK"; + ParticleType[ParticleType["UNRECOGNIZED"] = -1] = "UNRECOGNIZED"; +})(ParticleType || (ParticleType = {})); +export function particleTypeFromJSON(object) { + switch (object) { + case 0: + case "PARTICLE_TYPE_UNSPECIFIED": + return ParticleType.PARTICLE_TYPE_UNSPECIFIED; + case 1: + case "PARTICLE_HUGE_EXPLOSION": + return ParticleType.PARTICLE_HUGE_EXPLOSION; + case 2: + case "PARTICLE_ENDERMAN_TELEPORT": + return ParticleType.PARTICLE_ENDERMAN_TELEPORT; + case 3: + case "PARTICLE_SNOWBALL_POOF": + return ParticleType.PARTICLE_SNOWBALL_POOF; + case 4: + case "PARTICLE_EGG_SMASH": + return ParticleType.PARTICLE_EGG_SMASH; + case 5: + case "PARTICLE_SPLASH": + return ParticleType.PARTICLE_SPLASH; + case 6: + case "PARTICLE_EFFECT": + return ParticleType.PARTICLE_EFFECT; + case 7: + case "PARTICLE_ENTITY_FLAME": + return ParticleType.PARTICLE_ENTITY_FLAME; + case 8: + case "PARTICLE_FLAME": + return ParticleType.PARTICLE_FLAME; + case 9: + case "PARTICLE_DUST": + return ParticleType.PARTICLE_DUST; + case 10: + case "PARTICLE_BLOCK_FORCE_FIELD": + return ParticleType.PARTICLE_BLOCK_FORCE_FIELD; + case 11: + case "PARTICLE_BONE_MEAL": + return ParticleType.PARTICLE_BONE_MEAL; + case 12: + case "PARTICLE_EVAPORATE": + return ParticleType.PARTICLE_EVAPORATE; + case 13: + case "PARTICLE_WATER_DRIP": + return ParticleType.PARTICLE_WATER_DRIP; + case 14: + case "PARTICLE_LAVA_DRIP": + return ParticleType.PARTICLE_LAVA_DRIP; + case 15: + case "PARTICLE_LAVA": + return ParticleType.PARTICLE_LAVA; + case 16: + case "PARTICLE_DUST_PLUME": + return ParticleType.PARTICLE_DUST_PLUME; + case 17: + case "PARTICLE_BLOCK_BREAK": + return ParticleType.PARTICLE_BLOCK_BREAK; + case 18: + case "PARTICLE_PUNCH_BLOCK": + return ParticleType.PARTICLE_PUNCH_BLOCK; + case -1: + case "UNRECOGNIZED": + default: + return ParticleType.UNRECOGNIZED; + } +} +export function particleTypeToJSON(object) { + switch (object) { + case ParticleType.PARTICLE_TYPE_UNSPECIFIED: + return "PARTICLE_TYPE_UNSPECIFIED"; + case ParticleType.PARTICLE_HUGE_EXPLOSION: + return "PARTICLE_HUGE_EXPLOSION"; + case ParticleType.PARTICLE_ENDERMAN_TELEPORT: + return "PARTICLE_ENDERMAN_TELEPORT"; + case ParticleType.PARTICLE_SNOWBALL_POOF: + return "PARTICLE_SNOWBALL_POOF"; + case ParticleType.PARTICLE_EGG_SMASH: + return "PARTICLE_EGG_SMASH"; + case ParticleType.PARTICLE_SPLASH: + return "PARTICLE_SPLASH"; + case ParticleType.PARTICLE_EFFECT: + return "PARTICLE_EFFECT"; + case ParticleType.PARTICLE_ENTITY_FLAME: + return "PARTICLE_ENTITY_FLAME"; + case ParticleType.PARTICLE_FLAME: + return "PARTICLE_FLAME"; + case ParticleType.PARTICLE_DUST: + return "PARTICLE_DUST"; + case ParticleType.PARTICLE_BLOCK_FORCE_FIELD: + return "PARTICLE_BLOCK_FORCE_FIELD"; + case ParticleType.PARTICLE_BONE_MEAL: + return "PARTICLE_BONE_MEAL"; + case ParticleType.PARTICLE_EVAPORATE: + return "PARTICLE_EVAPORATE"; + case ParticleType.PARTICLE_WATER_DRIP: + return "PARTICLE_WATER_DRIP"; + case ParticleType.PARTICLE_LAVA_DRIP: + return "PARTICLE_LAVA_DRIP"; + case ParticleType.PARTICLE_LAVA: + return "PARTICLE_LAVA"; + case ParticleType.PARTICLE_DUST_PLUME: + return "PARTICLE_DUST_PLUME"; + case ParticleType.PARTICLE_BLOCK_BREAK: + return "PARTICLE_BLOCK_BREAK"; + case ParticleType.PARTICLE_PUNCH_BLOCK: + return "PARTICLE_PUNCH_BLOCK"; + case ParticleType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} function createBaseActionBatch() { return { actions: [] }; } @@ -81,6 +214,16 @@ function createBaseAction() { sendTip: undefined, playSound: undefined, executeCommand: undefined, + worldSetDefaultGameMode: undefined, + worldSetDifficulty: undefined, + worldSetTickRange: undefined, + worldSetBlock: undefined, + worldPlaySound: undefined, + worldAddParticle: undefined, + worldQueryEntities: undefined, + worldQueryPlayers: undefined, + worldQueryEntitiesWithin: undefined, + worldQueryViewers: undefined, }; } export const Action = { @@ -142,6 +285,36 @@ export const Action = { if (message.executeCommand !== undefined) { ExecuteCommandAction.encode(message.executeCommand, writer.uint32(402).fork()).join(); } + if (message.worldSetDefaultGameMode !== undefined) { + WorldSetDefaultGameModeAction.encode(message.worldSetDefaultGameMode, writer.uint32(482).fork()).join(); + } + if (message.worldSetDifficulty !== undefined) { + WorldSetDifficultyAction.encode(message.worldSetDifficulty, writer.uint32(490).fork()).join(); + } + if (message.worldSetTickRange !== undefined) { + WorldSetTickRangeAction.encode(message.worldSetTickRange, writer.uint32(498).fork()).join(); + } + if (message.worldSetBlock !== undefined) { + WorldSetBlockAction.encode(message.worldSetBlock, writer.uint32(506).fork()).join(); + } + if (message.worldPlaySound !== undefined) { + WorldPlaySoundAction.encode(message.worldPlaySound, writer.uint32(514).fork()).join(); + } + if (message.worldAddParticle !== undefined) { + WorldAddParticleAction.encode(message.worldAddParticle, writer.uint32(522).fork()).join(); + } + if (message.worldQueryEntities !== undefined) { + WorldQueryEntitiesAction.encode(message.worldQueryEntities, writer.uint32(562).fork()).join(); + } + if (message.worldQueryPlayers !== undefined) { + WorldQueryPlayersAction.encode(message.worldQueryPlayers, writer.uint32(570).fork()).join(); + } + if (message.worldQueryEntitiesWithin !== undefined) { + WorldQueryEntitiesWithinAction.encode(message.worldQueryEntitiesWithin, writer.uint32(578).fork()).join(); + } + if (message.worldQueryViewers !== undefined) { + WorldQueryViewersAction.encode(message.worldQueryViewers, writer.uint32(586).fork()).join(); + } return writer; }, decode(input, length) { @@ -284,6 +457,76 @@ export const Action = { message.executeCommand = ExecuteCommandAction.decode(reader, reader.uint32()); continue; } + case 60: { + if (tag !== 482) { + break; + } + message.worldSetDefaultGameMode = WorldSetDefaultGameModeAction.decode(reader, reader.uint32()); + continue; + } + case 61: { + if (tag !== 490) { + break; + } + message.worldSetDifficulty = WorldSetDifficultyAction.decode(reader, reader.uint32()); + continue; + } + case 62: { + if (tag !== 498) { + break; + } + message.worldSetTickRange = WorldSetTickRangeAction.decode(reader, reader.uint32()); + continue; + } + case 63: { + if (tag !== 506) { + break; + } + message.worldSetBlock = WorldSetBlockAction.decode(reader, reader.uint32()); + continue; + } + case 64: { + if (tag !== 514) { + break; + } + message.worldPlaySound = WorldPlaySoundAction.decode(reader, reader.uint32()); + continue; + } + case 65: { + if (tag !== 522) { + break; + } + message.worldAddParticle = WorldAddParticleAction.decode(reader, reader.uint32()); + continue; + } + case 70: { + if (tag !== 562) { + break; + } + message.worldQueryEntities = WorldQueryEntitiesAction.decode(reader, reader.uint32()); + continue; + } + case 71: { + if (tag !== 570) { + break; + } + message.worldQueryPlayers = WorldQueryPlayersAction.decode(reader, reader.uint32()); + continue; + } + case 72: { + if (tag !== 578) { + break; + } + message.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.decode(reader, reader.uint32()); + continue; + } + case 73: { + if (tag !== 586) { + break; + } + message.worldQueryViewers = WorldQueryViewersAction.decode(reader, reader.uint32()); + continue; + } } if ((tag & 7) === 4 || tag === 0) { break; @@ -313,6 +556,32 @@ export const Action = { sendTip: isSet(object.sendTip) ? SendTipAction.fromJSON(object.sendTip) : undefined, playSound: isSet(object.playSound) ? PlaySoundAction.fromJSON(object.playSound) : undefined, executeCommand: isSet(object.executeCommand) ? ExecuteCommandAction.fromJSON(object.executeCommand) : undefined, + worldSetDefaultGameMode: isSet(object.worldSetDefaultGameMode) + ? WorldSetDefaultGameModeAction.fromJSON(object.worldSetDefaultGameMode) + : undefined, + worldSetDifficulty: isSet(object.worldSetDifficulty) + ? WorldSetDifficultyAction.fromJSON(object.worldSetDifficulty) + : undefined, + worldSetTickRange: isSet(object.worldSetTickRange) + ? WorldSetTickRangeAction.fromJSON(object.worldSetTickRange) + : undefined, + worldSetBlock: isSet(object.worldSetBlock) ? WorldSetBlockAction.fromJSON(object.worldSetBlock) : undefined, + worldPlaySound: isSet(object.worldPlaySound) ? WorldPlaySoundAction.fromJSON(object.worldPlaySound) : undefined, + worldAddParticle: isSet(object.worldAddParticle) + ? WorldAddParticleAction.fromJSON(object.worldAddParticle) + : undefined, + worldQueryEntities: isSet(object.worldQueryEntities) + ? WorldQueryEntitiesAction.fromJSON(object.worldQueryEntities) + : undefined, + worldQueryPlayers: isSet(object.worldQueryPlayers) + ? WorldQueryPlayersAction.fromJSON(object.worldQueryPlayers) + : undefined, + worldQueryEntitiesWithin: isSet(object.worldQueryEntitiesWithin) + ? WorldQueryEntitiesWithinAction.fromJSON(object.worldQueryEntitiesWithin) + : undefined, + worldQueryViewers: isSet(object.worldQueryViewers) + ? WorldQueryViewersAction.fromJSON(object.worldQueryViewers) + : undefined, }; }, toJSON(message) { @@ -374,6 +643,36 @@ export const Action = { if (message.executeCommand !== undefined) { obj.executeCommand = ExecuteCommandAction.toJSON(message.executeCommand); } + if (message.worldSetDefaultGameMode !== undefined) { + obj.worldSetDefaultGameMode = WorldSetDefaultGameModeAction.toJSON(message.worldSetDefaultGameMode); + } + if (message.worldSetDifficulty !== undefined) { + obj.worldSetDifficulty = WorldSetDifficultyAction.toJSON(message.worldSetDifficulty); + } + if (message.worldSetTickRange !== undefined) { + obj.worldSetTickRange = WorldSetTickRangeAction.toJSON(message.worldSetTickRange); + } + if (message.worldSetBlock !== undefined) { + obj.worldSetBlock = WorldSetBlockAction.toJSON(message.worldSetBlock); + } + if (message.worldPlaySound !== undefined) { + obj.worldPlaySound = WorldPlaySoundAction.toJSON(message.worldPlaySound); + } + if (message.worldAddParticle !== undefined) { + obj.worldAddParticle = WorldAddParticleAction.toJSON(message.worldAddParticle); + } + if (message.worldQueryEntities !== undefined) { + obj.worldQueryEntities = WorldQueryEntitiesAction.toJSON(message.worldQueryEntities); + } + if (message.worldQueryPlayers !== undefined) { + obj.worldQueryPlayers = WorldQueryPlayersAction.toJSON(message.worldQueryPlayers); + } + if (message.worldQueryEntitiesWithin !== undefined) { + obj.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.toJSON(message.worldQueryEntitiesWithin); + } + if (message.worldQueryViewers !== undefined) { + obj.worldQueryViewers = WorldQueryViewersAction.toJSON(message.worldQueryViewers); + } return obj; }, create(base) { @@ -436,6 +735,38 @@ export const Action = { message.executeCommand = (object.executeCommand !== undefined && object.executeCommand !== null) ? ExecuteCommandAction.fromPartial(object.executeCommand) : undefined; + message.worldSetDefaultGameMode = + (object.worldSetDefaultGameMode !== undefined && object.worldSetDefaultGameMode !== null) + ? WorldSetDefaultGameModeAction.fromPartial(object.worldSetDefaultGameMode) + : undefined; + message.worldSetDifficulty = (object.worldSetDifficulty !== undefined && object.worldSetDifficulty !== null) + ? WorldSetDifficultyAction.fromPartial(object.worldSetDifficulty) + : undefined; + message.worldSetTickRange = (object.worldSetTickRange !== undefined && object.worldSetTickRange !== null) + ? WorldSetTickRangeAction.fromPartial(object.worldSetTickRange) + : undefined; + message.worldSetBlock = (object.worldSetBlock !== undefined && object.worldSetBlock !== null) + ? WorldSetBlockAction.fromPartial(object.worldSetBlock) + : undefined; + message.worldPlaySound = (object.worldPlaySound !== undefined && object.worldPlaySound !== null) + ? WorldPlaySoundAction.fromPartial(object.worldPlaySound) + : undefined; + message.worldAddParticle = (object.worldAddParticle !== undefined && object.worldAddParticle !== null) + ? WorldAddParticleAction.fromPartial(object.worldAddParticle) + : undefined; + message.worldQueryEntities = (object.worldQueryEntities !== undefined && object.worldQueryEntities !== null) + ? WorldQueryEntitiesAction.fromPartial(object.worldQueryEntities) + : undefined; + message.worldQueryPlayers = (object.worldQueryPlayers !== undefined && object.worldQueryPlayers !== null) + ? WorldQueryPlayersAction.fromPartial(object.worldQueryPlayers) + : undefined; + message.worldQueryEntitiesWithin = + (object.worldQueryEntitiesWithin !== undefined && object.worldQueryEntitiesWithin !== null) + ? WorldQueryEntitiesWithinAction.fromPartial(object.worldQueryEntitiesWithin) + : undefined; + message.worldQueryViewers = (object.worldQueryViewers !== undefined && object.worldQueryViewers !== null) + ? WorldQueryViewersAction.fromPartial(object.worldQueryViewers) + : undefined; return message; }, }; @@ -1888,6 +2219,1292 @@ export const ExecuteCommandAction = { return message; }, }; +function createBaseWorldSetDefaultGameModeAction() { + return { world: undefined, gameMode: 0 }; +} +export const WorldSetDefaultGameModeAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.gameMode !== 0) { + writer.uint32(16).int32(message.gameMode); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetDefaultGameModeAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + message.gameMode = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + gameMode: isSet(object.gameMode) ? gameModeFromJSON(object.gameMode) : 0, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.gameMode !== 0) { + obj.gameMode = gameModeToJSON(message.gameMode); + } + return obj; + }, + create(base) { + return WorldSetDefaultGameModeAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldSetDefaultGameModeAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.gameMode = object.gameMode ?? 0; + return message; + }, +}; +function createBaseWorldSetDifficultyAction() { + return { world: undefined, difficulty: 0 }; +} +export const WorldSetDifficultyAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.difficulty !== 0) { + writer.uint32(16).int32(message.difficulty); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetDifficultyAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + message.difficulty = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + difficulty: isSet(object.difficulty) ? difficultyFromJSON(object.difficulty) : 0, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.difficulty !== 0) { + obj.difficulty = difficultyToJSON(message.difficulty); + } + return obj; + }, + create(base) { + return WorldSetDifficultyAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldSetDifficultyAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.difficulty = object.difficulty ?? 0; + return message; + }, +}; +function createBaseWorldSetTickRangeAction() { + return { world: undefined, tickRange: 0 }; +} +export const WorldSetTickRangeAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.tickRange !== 0) { + writer.uint32(16).int32(message.tickRange); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetTickRangeAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + message.tickRange = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + tickRange: isSet(object.tickRange) ? globalThis.Number(object.tickRange) : 0, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.tickRange !== 0) { + obj.tickRange = Math.round(message.tickRange); + } + return obj; + }, + create(base) { + return WorldSetTickRangeAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldSetTickRangeAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.tickRange = object.tickRange ?? 0; + return message; + }, +}; +function createBaseWorldSetBlockAction() { + return { world: undefined, position: undefined, block: undefined }; +} +export const WorldSetBlockAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + BlockPos.encode(message.position, writer.uint32(18).fork()).join(); + } + if (message.block !== undefined) { + BlockState.encode(message.block, writer.uint32(26).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetBlockAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.position = BlockPos.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + message.block = BlockState.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? BlockPos.fromJSON(object.position) : undefined, + block: isSet(object.block) ? BlockState.fromJSON(object.block) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = BlockPos.toJSON(message.position); + } + if (message.block !== undefined) { + obj.block = BlockState.toJSON(message.block); + } + return obj; + }, + create(base) { + return WorldSetBlockAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldSetBlockAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? BlockPos.fromPartial(object.position) + : undefined; + message.block = (object.block !== undefined && object.block !== null) + ? BlockState.fromPartial(object.block) + : undefined; + return message; + }, +}; +function createBaseWorldPlaySoundAction() { + return { world: undefined, sound: 0, position: undefined }; +} +export const WorldPlaySoundAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.sound !== 0) { + writer.uint32(16).int32(message.sound); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(26).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldPlaySoundAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + message.sound = reader.int32(); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + sound: isSet(object.sound) ? soundFromJSON(object.sound) : 0, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.sound !== 0) { + obj.sound = soundToJSON(message.sound); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + return obj; + }, + create(base) { + return WorldPlaySoundAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldPlaySoundAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.sound = object.sound ?? 0; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + return message; + }, +}; +function createBaseWorldAddParticleAction() { + return { world: undefined, position: undefined, particle: 0, block: undefined, face: undefined }; +} +export const WorldAddParticleAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + if (message.particle !== 0) { + writer.uint32(24).int32(message.particle); + } + if (message.block !== undefined) { + BlockState.encode(message.block, writer.uint32(34).fork()).join(); + } + if (message.face !== undefined) { + writer.uint32(40).int32(message.face); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldAddParticleAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + message.particle = reader.int32(); + continue; + } + case 4: { + if (tag !== 34) { + break; + } + message.block = BlockState.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + message.face = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + particle: isSet(object.particle) ? particleTypeFromJSON(object.particle) : 0, + block: isSet(object.block) ? BlockState.fromJSON(object.block) : undefined, + face: isSet(object.face) ? globalThis.Number(object.face) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + if (message.particle !== 0) { + obj.particle = particleTypeToJSON(message.particle); + } + if (message.block !== undefined) { + obj.block = BlockState.toJSON(message.block); + } + if (message.face !== undefined) { + obj.face = Math.round(message.face); + } + return obj; + }, + create(base) { + return WorldAddParticleAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldAddParticleAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + message.particle = object.particle ?? 0; + message.block = (object.block !== undefined && object.block !== null) + ? BlockState.fromPartial(object.block) + : undefined; + message.face = object.face ?? undefined; + return message; + }, +}; +function createBaseWorldQueryEntitiesAction() { + return { world: undefined }; +} +export const WorldQueryEntitiesAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryEntitiesAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + return obj; + }, + create(base) { + return WorldQueryEntitiesAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldQueryEntitiesAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + return message; + }, +}; +function createBaseWorldQueryPlayersAction() { + return { world: undefined }; +} +export const WorldQueryPlayersAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryPlayersAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + return obj; + }, + create(base) { + return WorldQueryPlayersAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldQueryPlayersAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + return message; + }, +}; +function createBaseWorldQueryEntitiesWithinAction() { + return { world: undefined, box: undefined }; +} +export const WorldQueryEntitiesWithinAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.box !== undefined) { + BBox.encode(message.box, writer.uint32(18).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryEntitiesWithinAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.box = BBox.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + box: isSet(object.box) ? BBox.fromJSON(object.box) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.box !== undefined) { + obj.box = BBox.toJSON(message.box); + } + return obj; + }, + create(base) { + return WorldQueryEntitiesWithinAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldQueryEntitiesWithinAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.box = (object.box !== undefined && object.box !== null) ? BBox.fromPartial(object.box) : undefined; + return message; + }, +}; +function createBaseWorldQueryViewersAction() { + return { world: undefined, position: undefined }; +} +export const WorldQueryViewersAction = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryViewersAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + return obj; + }, + create(base) { + return WorldQueryViewersAction.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldQueryViewersAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + return message; + }, +}; +function createBaseActionStatus() { + return { ok: false, error: undefined }; +} +export const ActionStatus = { + encode(message, writer = new BinaryWriter()) { + if (message.ok !== false) { + writer.uint32(8).bool(message.ok); + } + if (message.error !== undefined) { + writer.uint32(18).string(message.error); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseActionStatus(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + message.ok = reader.bool(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + ok: isSet(object.ok) ? globalThis.Boolean(object.ok) : false, + error: isSet(object.error) ? globalThis.String(object.error) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.ok !== false) { + obj.ok = message.ok; + } + if (message.error !== undefined) { + obj.error = message.error; + } + return obj; + }, + create(base) { + return ActionStatus.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseActionStatus(); + message.ok = object.ok ?? false; + message.error = object.error ?? undefined; + return message; + }, +}; +function createBaseWorldEntitiesResult() { + return { world: undefined, entities: [] }; +} +export const WorldEntitiesResult = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + for (const v of message.entities) { + EntityRef.encode(v, writer.uint32(18).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldEntitiesResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.entities.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + entities: globalThis.Array.isArray(object?.entities) + ? object.entities.map((e) => EntityRef.fromJSON(e)) + : [], + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.entities?.length) { + obj.entities = message.entities.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + create(base) { + return WorldEntitiesResult.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldEntitiesResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.entities = object.entities?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; +function createBaseWorldEntitiesWithinResult() { + return { world: undefined, box: undefined, entities: [] }; +} +export const WorldEntitiesWithinResult = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.box !== undefined) { + BBox.encode(message.box, writer.uint32(18).fork()).join(); + } + for (const v of message.entities) { + EntityRef.encode(v, writer.uint32(26).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldEntitiesWithinResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.box = BBox.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + message.entities.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + box: isSet(object.box) ? BBox.fromJSON(object.box) : undefined, + entities: globalThis.Array.isArray(object?.entities) + ? object.entities.map((e) => EntityRef.fromJSON(e)) + : [], + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.box !== undefined) { + obj.box = BBox.toJSON(message.box); + } + if (message.entities?.length) { + obj.entities = message.entities.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + create(base) { + return WorldEntitiesWithinResult.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldEntitiesWithinResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.box = (object.box !== undefined && object.box !== null) ? BBox.fromPartial(object.box) : undefined; + message.entities = object.entities?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; +function createBaseWorldPlayersResult() { + return { world: undefined, players: [] }; +} +export const WorldPlayersResult = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + for (const v of message.players) { + EntityRef.encode(v, writer.uint32(18).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldPlayersResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.players.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + players: globalThis.Array.isArray(object?.players) ? object.players.map((e) => EntityRef.fromJSON(e)) : [], + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.players?.length) { + obj.players = message.players.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + create(base) { + return WorldPlayersResult.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldPlayersResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.players = object.players?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; +function createBaseWorldViewersResult() { + return { world: undefined, position: undefined, viewerUuids: [] }; +} +export const WorldViewersResult = { + encode(message, writer = new BinaryWriter()) { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + for (const v of message.viewerUuids) { + writer.uint32(26).string(v); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldViewersResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + message.viewerUuids.push(reader.string()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + viewerUuids: globalThis.Array.isArray(object?.viewerUuids) + ? object.viewerUuids.map((e) => globalThis.String(e)) + : [], + }; + }, + toJSON(message) { + const obj = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + if (message.viewerUuids?.length) { + obj.viewerUuids = message.viewerUuids; + } + return obj; + }, + create(base) { + return WorldViewersResult.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseWorldViewersResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + message.viewerUuids = object.viewerUuids?.map((e) => e) || []; + return message; + }, +}; +function createBaseActionResult() { + return { + correlationId: "", + status: undefined, + worldEntities: undefined, + worldPlayers: undefined, + worldEntitiesWithin: undefined, + worldViewers: undefined, + }; +} +export const ActionResult = { + encode(message, writer = new BinaryWriter()) { + if (message.correlationId !== "") { + writer.uint32(10).string(message.correlationId); + } + if (message.status !== undefined) { + ActionStatus.encode(message.status, writer.uint32(18).fork()).join(); + } + if (message.worldEntities !== undefined) { + WorldEntitiesResult.encode(message.worldEntities, writer.uint32(82).fork()).join(); + } + if (message.worldPlayers !== undefined) { + WorldPlayersResult.encode(message.worldPlayers, writer.uint32(90).fork()).join(); + } + if (message.worldEntitiesWithin !== undefined) { + WorldEntitiesWithinResult.encode(message.worldEntitiesWithin, writer.uint32(98).fork()).join(); + } + if (message.worldViewers !== undefined) { + WorldViewersResult.encode(message.worldViewers, writer.uint32(106).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseActionResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.correlationId = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.status = ActionStatus.decode(reader, reader.uint32()); + continue; + } + case 10: { + if (tag !== 82) { + break; + } + message.worldEntities = WorldEntitiesResult.decode(reader, reader.uint32()); + continue; + } + case 11: { + if (tag !== 90) { + break; + } + message.worldPlayers = WorldPlayersResult.decode(reader, reader.uint32()); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + message.worldEntitiesWithin = WorldEntitiesWithinResult.decode(reader, reader.uint32()); + continue; + } + case 13: { + if (tag !== 106) { + break; + } + message.worldViewers = WorldViewersResult.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + correlationId: isSet(object.correlationId) ? globalThis.String(object.correlationId) : "", + status: isSet(object.status) ? ActionStatus.fromJSON(object.status) : undefined, + worldEntities: isSet(object.worldEntities) ? WorldEntitiesResult.fromJSON(object.worldEntities) : undefined, + worldPlayers: isSet(object.worldPlayers) ? WorldPlayersResult.fromJSON(object.worldPlayers) : undefined, + worldEntitiesWithin: isSet(object.worldEntitiesWithin) + ? WorldEntitiesWithinResult.fromJSON(object.worldEntitiesWithin) + : undefined, + worldViewers: isSet(object.worldViewers) ? WorldViewersResult.fromJSON(object.worldViewers) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.correlationId !== "") { + obj.correlationId = message.correlationId; + } + if (message.status !== undefined) { + obj.status = ActionStatus.toJSON(message.status); + } + if (message.worldEntities !== undefined) { + obj.worldEntities = WorldEntitiesResult.toJSON(message.worldEntities); + } + if (message.worldPlayers !== undefined) { + obj.worldPlayers = WorldPlayersResult.toJSON(message.worldPlayers); + } + if (message.worldEntitiesWithin !== undefined) { + obj.worldEntitiesWithin = WorldEntitiesWithinResult.toJSON(message.worldEntitiesWithin); + } + if (message.worldViewers !== undefined) { + obj.worldViewers = WorldViewersResult.toJSON(message.worldViewers); + } + return obj; + }, + create(base) { + return ActionResult.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseActionResult(); + message.correlationId = object.correlationId ?? ""; + message.status = (object.status !== undefined && object.status !== null) + ? ActionStatus.fromPartial(object.status) + : undefined; + message.worldEntities = (object.worldEntities !== undefined && object.worldEntities !== null) + ? WorldEntitiesResult.fromPartial(object.worldEntities) + : undefined; + message.worldPlayers = (object.worldPlayers !== undefined && object.worldPlayers !== null) + ? WorldPlayersResult.fromPartial(object.worldPlayers) + : undefined; + message.worldEntitiesWithin = (object.worldEntitiesWithin !== undefined && object.worldEntitiesWithin !== null) + ? WorldEntitiesWithinResult.fromPartial(object.worldEntitiesWithin) + : undefined; + message.worldViewers = (object.worldViewers !== undefined && object.worldViewers !== null) + ? WorldViewersResult.fromPartial(object.worldViewers) + : undefined; + return message; + }, +}; function longToNumber(int64) { const num = globalThis.Number(int64.toString()); if (num > globalThis.Number.MAX_SAFE_INTEGER) { diff --git a/packages/node/src/generated/actions.ts b/packages/node/src/generated/actions.ts index 1594e52..1bdb4fb 100644 --- a/packages/node/src/generated/actions.ts +++ b/packages/node/src/generated/actions.ts @@ -7,9 +7,16 @@ /* eslint-disable */ import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; import { + BBox, + BlockPos, + BlockState, + Difficulty, + difficultyFromJSON, + difficultyToJSON, EffectType, effectTypeFromJSON, effectTypeToJSON, + EntityRef, GameMode, gameModeFromJSON, gameModeToJSON, @@ -18,10 +25,146 @@ import { soundFromJSON, soundToJSON, Vec3, + WorldRef, } from "./common.js"; export const protobufPackage = "df.plugin"; +export enum ParticleType { + PARTICLE_TYPE_UNSPECIFIED = 0, + PARTICLE_HUGE_EXPLOSION = 1, + PARTICLE_ENDERMAN_TELEPORT = 2, + PARTICLE_SNOWBALL_POOF = 3, + PARTICLE_EGG_SMASH = 4, + PARTICLE_SPLASH = 5, + PARTICLE_EFFECT = 6, + PARTICLE_ENTITY_FLAME = 7, + PARTICLE_FLAME = 8, + PARTICLE_DUST = 9, + PARTICLE_BLOCK_FORCE_FIELD = 10, + PARTICLE_BONE_MEAL = 11, + PARTICLE_EVAPORATE = 12, + PARTICLE_WATER_DRIP = 13, + PARTICLE_LAVA_DRIP = 14, + PARTICLE_LAVA = 15, + PARTICLE_DUST_PLUME = 16, + PARTICLE_BLOCK_BREAK = 17, + PARTICLE_PUNCH_BLOCK = 18, + UNRECOGNIZED = -1, +} + +export function particleTypeFromJSON(object: any): ParticleType { + switch (object) { + case 0: + case "PARTICLE_TYPE_UNSPECIFIED": + return ParticleType.PARTICLE_TYPE_UNSPECIFIED; + case 1: + case "PARTICLE_HUGE_EXPLOSION": + return ParticleType.PARTICLE_HUGE_EXPLOSION; + case 2: + case "PARTICLE_ENDERMAN_TELEPORT": + return ParticleType.PARTICLE_ENDERMAN_TELEPORT; + case 3: + case "PARTICLE_SNOWBALL_POOF": + return ParticleType.PARTICLE_SNOWBALL_POOF; + case 4: + case "PARTICLE_EGG_SMASH": + return ParticleType.PARTICLE_EGG_SMASH; + case 5: + case "PARTICLE_SPLASH": + return ParticleType.PARTICLE_SPLASH; + case 6: + case "PARTICLE_EFFECT": + return ParticleType.PARTICLE_EFFECT; + case 7: + case "PARTICLE_ENTITY_FLAME": + return ParticleType.PARTICLE_ENTITY_FLAME; + case 8: + case "PARTICLE_FLAME": + return ParticleType.PARTICLE_FLAME; + case 9: + case "PARTICLE_DUST": + return ParticleType.PARTICLE_DUST; + case 10: + case "PARTICLE_BLOCK_FORCE_FIELD": + return ParticleType.PARTICLE_BLOCK_FORCE_FIELD; + case 11: + case "PARTICLE_BONE_MEAL": + return ParticleType.PARTICLE_BONE_MEAL; + case 12: + case "PARTICLE_EVAPORATE": + return ParticleType.PARTICLE_EVAPORATE; + case 13: + case "PARTICLE_WATER_DRIP": + return ParticleType.PARTICLE_WATER_DRIP; + case 14: + case "PARTICLE_LAVA_DRIP": + return ParticleType.PARTICLE_LAVA_DRIP; + case 15: + case "PARTICLE_LAVA": + return ParticleType.PARTICLE_LAVA; + case 16: + case "PARTICLE_DUST_PLUME": + return ParticleType.PARTICLE_DUST_PLUME; + case 17: + case "PARTICLE_BLOCK_BREAK": + return ParticleType.PARTICLE_BLOCK_BREAK; + case 18: + case "PARTICLE_PUNCH_BLOCK": + return ParticleType.PARTICLE_PUNCH_BLOCK; + case -1: + case "UNRECOGNIZED": + default: + return ParticleType.UNRECOGNIZED; + } +} + +export function particleTypeToJSON(object: ParticleType): string { + switch (object) { + case ParticleType.PARTICLE_TYPE_UNSPECIFIED: + return "PARTICLE_TYPE_UNSPECIFIED"; + case ParticleType.PARTICLE_HUGE_EXPLOSION: + return "PARTICLE_HUGE_EXPLOSION"; + case ParticleType.PARTICLE_ENDERMAN_TELEPORT: + return "PARTICLE_ENDERMAN_TELEPORT"; + case ParticleType.PARTICLE_SNOWBALL_POOF: + return "PARTICLE_SNOWBALL_POOF"; + case ParticleType.PARTICLE_EGG_SMASH: + return "PARTICLE_EGG_SMASH"; + case ParticleType.PARTICLE_SPLASH: + return "PARTICLE_SPLASH"; + case ParticleType.PARTICLE_EFFECT: + return "PARTICLE_EFFECT"; + case ParticleType.PARTICLE_ENTITY_FLAME: + return "PARTICLE_ENTITY_FLAME"; + case ParticleType.PARTICLE_FLAME: + return "PARTICLE_FLAME"; + case ParticleType.PARTICLE_DUST: + return "PARTICLE_DUST"; + case ParticleType.PARTICLE_BLOCK_FORCE_FIELD: + return "PARTICLE_BLOCK_FORCE_FIELD"; + case ParticleType.PARTICLE_BONE_MEAL: + return "PARTICLE_BONE_MEAL"; + case ParticleType.PARTICLE_EVAPORATE: + return "PARTICLE_EVAPORATE"; + case ParticleType.PARTICLE_WATER_DRIP: + return "PARTICLE_WATER_DRIP"; + case ParticleType.PARTICLE_LAVA_DRIP: + return "PARTICLE_LAVA_DRIP"; + case ParticleType.PARTICLE_LAVA: + return "PARTICLE_LAVA"; + case ParticleType.PARTICLE_DUST_PLUME: + return "PARTICLE_DUST_PLUME"; + case ParticleType.PARTICLE_BLOCK_BREAK: + return "PARTICLE_BLOCK_BREAK"; + case ParticleType.PARTICLE_PUNCH_BLOCK: + return "PARTICLE_PUNCH_BLOCK"; + case ParticleType.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + export interface ActionBatch { actions: Action[]; } @@ -60,7 +203,23 @@ export interface Action { | PlaySoundAction | undefined; /** Commands */ - executeCommand?: ExecuteCommandAction | undefined; + executeCommand?: + | ExecuteCommandAction + | undefined; + /** World configuration and effects */ + worldSetDefaultGameMode?: WorldSetDefaultGameModeAction | undefined; + worldSetDifficulty?: WorldSetDifficultyAction | undefined; + worldSetTickRange?: WorldSetTickRangeAction | undefined; + worldSetBlock?: WorldSetBlockAction | undefined; + worldPlaySound?: WorldPlaySoundAction | undefined; + worldAddParticle?: + | WorldAddParticleAction + | undefined; + /** World queries */ + worldQueryEntities?: WorldQueryEntitiesAction | undefined; + worldQueryPlayers?: WorldQueryPlayersAction | undefined; + worldQueryEntitiesWithin?: WorldQueryEntitiesWithinAction | undefined; + worldQueryViewers?: WorldQueryViewersAction | undefined; } export interface SendChatAction { @@ -201,6 +360,102 @@ export interface ExecuteCommandAction { command: string; } +export interface WorldSetDefaultGameModeAction { + world: WorldRef | undefined; + gameMode: GameMode; +} + +export interface WorldSetDifficultyAction { + world: WorldRef | undefined; + difficulty: Difficulty; +} + +export interface WorldSetTickRangeAction { + world: WorldRef | undefined; + tickRange: number; +} + +export interface WorldSetBlockAction { + world: WorldRef | undefined; + position: + | BlockPos + | undefined; + /** nil clears to air */ + block?: BlockState | undefined; +} + +export interface WorldPlaySoundAction { + world: WorldRef | undefined; + sound: Sound; + position: Vec3 | undefined; +} + +export interface WorldAddParticleAction { + world: WorldRef | undefined; + position: Vec3 | undefined; + particle: ParticleType; + /** used for block-based particles when provided */ + block?: + | BlockState + | undefined; + /** used for punch_block when provided */ + face?: number | undefined; +} + +export interface WorldQueryEntitiesAction { + world: WorldRef | undefined; +} + +export interface WorldQueryPlayersAction { + world: WorldRef | undefined; +} + +export interface WorldQueryEntitiesWithinAction { + world: WorldRef | undefined; + box: BBox | undefined; +} + +export interface WorldQueryViewersAction { + world: WorldRef | undefined; + position: Vec3 | undefined; +} + +export interface ActionStatus { + ok: boolean; + error?: string | undefined; +} + +export interface WorldEntitiesResult { + world: WorldRef | undefined; + entities: EntityRef[]; +} + +export interface WorldEntitiesWithinResult { + world: WorldRef | undefined; + box: BBox | undefined; + entities: EntityRef[]; +} + +export interface WorldPlayersResult { + world: WorldRef | undefined; + players: EntityRef[]; +} + +export interface WorldViewersResult { + world: WorldRef | undefined; + position: Vec3 | undefined; + viewerUuids: string[]; +} + +export interface ActionResult { + correlationId: string; + status?: ActionStatus | undefined; + worldEntities?: WorldEntitiesResult | undefined; + worldPlayers?: WorldPlayersResult | undefined; + worldEntitiesWithin?: WorldEntitiesWithinResult | undefined; + worldViewers?: WorldViewersResult | undefined; +} + function createBaseActionBatch(): ActionBatch { return { actions: [] }; } @@ -282,6 +537,16 @@ function createBaseAction(): Action { sendTip: undefined, playSound: undefined, executeCommand: undefined, + worldSetDefaultGameMode: undefined, + worldSetDifficulty: undefined, + worldSetTickRange: undefined, + worldSetBlock: undefined, + worldPlaySound: undefined, + worldAddParticle: undefined, + worldQueryEntities: undefined, + worldQueryPlayers: undefined, + worldQueryEntitiesWithin: undefined, + worldQueryViewers: undefined, }; } @@ -344,6 +609,36 @@ export const Action: MessageFns = { if (message.executeCommand !== undefined) { ExecuteCommandAction.encode(message.executeCommand, writer.uint32(402).fork()).join(); } + if (message.worldSetDefaultGameMode !== undefined) { + WorldSetDefaultGameModeAction.encode(message.worldSetDefaultGameMode, writer.uint32(482).fork()).join(); + } + if (message.worldSetDifficulty !== undefined) { + WorldSetDifficultyAction.encode(message.worldSetDifficulty, writer.uint32(490).fork()).join(); + } + if (message.worldSetTickRange !== undefined) { + WorldSetTickRangeAction.encode(message.worldSetTickRange, writer.uint32(498).fork()).join(); + } + if (message.worldSetBlock !== undefined) { + WorldSetBlockAction.encode(message.worldSetBlock, writer.uint32(506).fork()).join(); + } + if (message.worldPlaySound !== undefined) { + WorldPlaySoundAction.encode(message.worldPlaySound, writer.uint32(514).fork()).join(); + } + if (message.worldAddParticle !== undefined) { + WorldAddParticleAction.encode(message.worldAddParticle, writer.uint32(522).fork()).join(); + } + if (message.worldQueryEntities !== undefined) { + WorldQueryEntitiesAction.encode(message.worldQueryEntities, writer.uint32(562).fork()).join(); + } + if (message.worldQueryPlayers !== undefined) { + WorldQueryPlayersAction.encode(message.worldQueryPlayers, writer.uint32(570).fork()).join(); + } + if (message.worldQueryEntitiesWithin !== undefined) { + WorldQueryEntitiesWithinAction.encode(message.worldQueryEntitiesWithin, writer.uint32(578).fork()).join(); + } + if (message.worldQueryViewers !== undefined) { + WorldQueryViewersAction.encode(message.worldQueryViewers, writer.uint32(586).fork()).join(); + } return writer; }, @@ -506,6 +801,86 @@ export const Action: MessageFns = { message.executeCommand = ExecuteCommandAction.decode(reader, reader.uint32()); continue; } + case 60: { + if (tag !== 482) { + break; + } + + message.worldSetDefaultGameMode = WorldSetDefaultGameModeAction.decode(reader, reader.uint32()); + continue; + } + case 61: { + if (tag !== 490) { + break; + } + + message.worldSetDifficulty = WorldSetDifficultyAction.decode(reader, reader.uint32()); + continue; + } + case 62: { + if (tag !== 498) { + break; + } + + message.worldSetTickRange = WorldSetTickRangeAction.decode(reader, reader.uint32()); + continue; + } + case 63: { + if (tag !== 506) { + break; + } + + message.worldSetBlock = WorldSetBlockAction.decode(reader, reader.uint32()); + continue; + } + case 64: { + if (tag !== 514) { + break; + } + + message.worldPlaySound = WorldPlaySoundAction.decode(reader, reader.uint32()); + continue; + } + case 65: { + if (tag !== 522) { + break; + } + + message.worldAddParticle = WorldAddParticleAction.decode(reader, reader.uint32()); + continue; + } + case 70: { + if (tag !== 562) { + break; + } + + message.worldQueryEntities = WorldQueryEntitiesAction.decode(reader, reader.uint32()); + continue; + } + case 71: { + if (tag !== 570) { + break; + } + + message.worldQueryPlayers = WorldQueryPlayersAction.decode(reader, reader.uint32()); + continue; + } + case 72: { + if (tag !== 578) { + break; + } + + message.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.decode(reader, reader.uint32()); + continue; + } + case 73: { + if (tag !== 586) { + break; + } + + message.worldQueryViewers = WorldQueryViewersAction.decode(reader, reader.uint32()); + continue; + } } if ((tag & 7) === 4 || tag === 0) { break; @@ -536,6 +911,32 @@ export const Action: MessageFns = { sendTip: isSet(object.sendTip) ? SendTipAction.fromJSON(object.sendTip) : undefined, playSound: isSet(object.playSound) ? PlaySoundAction.fromJSON(object.playSound) : undefined, executeCommand: isSet(object.executeCommand) ? ExecuteCommandAction.fromJSON(object.executeCommand) : undefined, + worldSetDefaultGameMode: isSet(object.worldSetDefaultGameMode) + ? WorldSetDefaultGameModeAction.fromJSON(object.worldSetDefaultGameMode) + : undefined, + worldSetDifficulty: isSet(object.worldSetDifficulty) + ? WorldSetDifficultyAction.fromJSON(object.worldSetDifficulty) + : undefined, + worldSetTickRange: isSet(object.worldSetTickRange) + ? WorldSetTickRangeAction.fromJSON(object.worldSetTickRange) + : undefined, + worldSetBlock: isSet(object.worldSetBlock) ? WorldSetBlockAction.fromJSON(object.worldSetBlock) : undefined, + worldPlaySound: isSet(object.worldPlaySound) ? WorldPlaySoundAction.fromJSON(object.worldPlaySound) : undefined, + worldAddParticle: isSet(object.worldAddParticle) + ? WorldAddParticleAction.fromJSON(object.worldAddParticle) + : undefined, + worldQueryEntities: isSet(object.worldQueryEntities) + ? WorldQueryEntitiesAction.fromJSON(object.worldQueryEntities) + : undefined, + worldQueryPlayers: isSet(object.worldQueryPlayers) + ? WorldQueryPlayersAction.fromJSON(object.worldQueryPlayers) + : undefined, + worldQueryEntitiesWithin: isSet(object.worldQueryEntitiesWithin) + ? WorldQueryEntitiesWithinAction.fromJSON(object.worldQueryEntitiesWithin) + : undefined, + worldQueryViewers: isSet(object.worldQueryViewers) + ? WorldQueryViewersAction.fromJSON(object.worldQueryViewers) + : undefined, }; }, @@ -598,6 +999,36 @@ export const Action: MessageFns = { if (message.executeCommand !== undefined) { obj.executeCommand = ExecuteCommandAction.toJSON(message.executeCommand); } + if (message.worldSetDefaultGameMode !== undefined) { + obj.worldSetDefaultGameMode = WorldSetDefaultGameModeAction.toJSON(message.worldSetDefaultGameMode); + } + if (message.worldSetDifficulty !== undefined) { + obj.worldSetDifficulty = WorldSetDifficultyAction.toJSON(message.worldSetDifficulty); + } + if (message.worldSetTickRange !== undefined) { + obj.worldSetTickRange = WorldSetTickRangeAction.toJSON(message.worldSetTickRange); + } + if (message.worldSetBlock !== undefined) { + obj.worldSetBlock = WorldSetBlockAction.toJSON(message.worldSetBlock); + } + if (message.worldPlaySound !== undefined) { + obj.worldPlaySound = WorldPlaySoundAction.toJSON(message.worldPlaySound); + } + if (message.worldAddParticle !== undefined) { + obj.worldAddParticle = WorldAddParticleAction.toJSON(message.worldAddParticle); + } + if (message.worldQueryEntities !== undefined) { + obj.worldQueryEntities = WorldQueryEntitiesAction.toJSON(message.worldQueryEntities); + } + if (message.worldQueryPlayers !== undefined) { + obj.worldQueryPlayers = WorldQueryPlayersAction.toJSON(message.worldQueryPlayers); + } + if (message.worldQueryEntitiesWithin !== undefined) { + obj.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.toJSON(message.worldQueryEntitiesWithin); + } + if (message.worldQueryViewers !== undefined) { + obj.worldQueryViewers = WorldQueryViewersAction.toJSON(message.worldQueryViewers); + } return obj; }, @@ -661,6 +1092,38 @@ export const Action: MessageFns = { message.executeCommand = (object.executeCommand !== undefined && object.executeCommand !== null) ? ExecuteCommandAction.fromPartial(object.executeCommand) : undefined; + message.worldSetDefaultGameMode = + (object.worldSetDefaultGameMode !== undefined && object.worldSetDefaultGameMode !== null) + ? WorldSetDefaultGameModeAction.fromPartial(object.worldSetDefaultGameMode) + : undefined; + message.worldSetDifficulty = (object.worldSetDifficulty !== undefined && object.worldSetDifficulty !== null) + ? WorldSetDifficultyAction.fromPartial(object.worldSetDifficulty) + : undefined; + message.worldSetTickRange = (object.worldSetTickRange !== undefined && object.worldSetTickRange !== null) + ? WorldSetTickRangeAction.fromPartial(object.worldSetTickRange) + : undefined; + message.worldSetBlock = (object.worldSetBlock !== undefined && object.worldSetBlock !== null) + ? WorldSetBlockAction.fromPartial(object.worldSetBlock) + : undefined; + message.worldPlaySound = (object.worldPlaySound !== undefined && object.worldPlaySound !== null) + ? WorldPlaySoundAction.fromPartial(object.worldPlaySound) + : undefined; + message.worldAddParticle = (object.worldAddParticle !== undefined && object.worldAddParticle !== null) + ? WorldAddParticleAction.fromPartial(object.worldAddParticle) + : undefined; + message.worldQueryEntities = (object.worldQueryEntities !== undefined && object.worldQueryEntities !== null) + ? WorldQueryEntitiesAction.fromPartial(object.worldQueryEntities) + : undefined; + message.worldQueryPlayers = (object.worldQueryPlayers !== undefined && object.worldQueryPlayers !== null) + ? WorldQueryPlayersAction.fromPartial(object.worldQueryPlayers) + : undefined; + message.worldQueryEntitiesWithin = + (object.worldQueryEntitiesWithin !== undefined && object.worldQueryEntitiesWithin !== null) + ? WorldQueryEntitiesWithinAction.fromPartial(object.worldQueryEntitiesWithin) + : undefined; + message.worldQueryViewers = (object.worldQueryViewers !== undefined && object.worldQueryViewers !== null) + ? WorldQueryViewersAction.fromPartial(object.worldQueryViewers) + : undefined; return message; }, }; @@ -2272,6 +2735,1429 @@ export const ExecuteCommandAction: MessageFns = { }, }; +function createBaseWorldSetDefaultGameModeAction(): WorldSetDefaultGameModeAction { + return { world: undefined, gameMode: 0 }; +} + +export const WorldSetDefaultGameModeAction: MessageFns = { + encode(message: WorldSetDefaultGameModeAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.gameMode !== 0) { + writer.uint32(16).int32(message.gameMode); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldSetDefaultGameModeAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetDefaultGameModeAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.gameMode = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldSetDefaultGameModeAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + gameMode: isSet(object.gameMode) ? gameModeFromJSON(object.gameMode) : 0, + }; + }, + + toJSON(message: WorldSetDefaultGameModeAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.gameMode !== 0) { + obj.gameMode = gameModeToJSON(message.gameMode); + } + return obj; + }, + + create(base?: DeepPartial): WorldSetDefaultGameModeAction { + return WorldSetDefaultGameModeAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldSetDefaultGameModeAction { + const message = createBaseWorldSetDefaultGameModeAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.gameMode = object.gameMode ?? 0; + return message; + }, +}; + +function createBaseWorldSetDifficultyAction(): WorldSetDifficultyAction { + return { world: undefined, difficulty: 0 }; +} + +export const WorldSetDifficultyAction: MessageFns = { + encode(message: WorldSetDifficultyAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.difficulty !== 0) { + writer.uint32(16).int32(message.difficulty); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldSetDifficultyAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetDifficultyAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.difficulty = reader.int32() as any; + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldSetDifficultyAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + difficulty: isSet(object.difficulty) ? difficultyFromJSON(object.difficulty) : 0, + }; + }, + + toJSON(message: WorldSetDifficultyAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.difficulty !== 0) { + obj.difficulty = difficultyToJSON(message.difficulty); + } + return obj; + }, + + create(base?: DeepPartial): WorldSetDifficultyAction { + return WorldSetDifficultyAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldSetDifficultyAction { + const message = createBaseWorldSetDifficultyAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.difficulty = object.difficulty ?? 0; + return message; + }, +}; + +function createBaseWorldSetTickRangeAction(): WorldSetTickRangeAction { + return { world: undefined, tickRange: 0 }; +} + +export const WorldSetTickRangeAction: MessageFns = { + encode(message: WorldSetTickRangeAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.tickRange !== 0) { + writer.uint32(16).int32(message.tickRange); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldSetTickRangeAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetTickRangeAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.tickRange = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldSetTickRangeAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + tickRange: isSet(object.tickRange) ? globalThis.Number(object.tickRange) : 0, + }; + }, + + toJSON(message: WorldSetTickRangeAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.tickRange !== 0) { + obj.tickRange = Math.round(message.tickRange); + } + return obj; + }, + + create(base?: DeepPartial): WorldSetTickRangeAction { + return WorldSetTickRangeAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldSetTickRangeAction { + const message = createBaseWorldSetTickRangeAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.tickRange = object.tickRange ?? 0; + return message; + }, +}; + +function createBaseWorldSetBlockAction(): WorldSetBlockAction { + return { world: undefined, position: undefined, block: undefined }; +} + +export const WorldSetBlockAction: MessageFns = { + encode(message: WorldSetBlockAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + BlockPos.encode(message.position, writer.uint32(18).fork()).join(); + } + if (message.block !== undefined) { + BlockState.encode(message.block, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldSetBlockAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldSetBlockAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.position = BlockPos.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.block = BlockState.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldSetBlockAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? BlockPos.fromJSON(object.position) : undefined, + block: isSet(object.block) ? BlockState.fromJSON(object.block) : undefined, + }; + }, + + toJSON(message: WorldSetBlockAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = BlockPos.toJSON(message.position); + } + if (message.block !== undefined) { + obj.block = BlockState.toJSON(message.block); + } + return obj; + }, + + create(base?: DeepPartial): WorldSetBlockAction { + return WorldSetBlockAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldSetBlockAction { + const message = createBaseWorldSetBlockAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? BlockPos.fromPartial(object.position) + : undefined; + message.block = (object.block !== undefined && object.block !== null) + ? BlockState.fromPartial(object.block) + : undefined; + return message; + }, +}; + +function createBaseWorldPlaySoundAction(): WorldPlaySoundAction { + return { world: undefined, sound: 0, position: undefined }; +} + +export const WorldPlaySoundAction: MessageFns = { + encode(message: WorldPlaySoundAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.sound !== 0) { + writer.uint32(16).int32(message.sound); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldPlaySoundAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldPlaySoundAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 16) { + break; + } + + message.sound = reader.int32() as any; + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldPlaySoundAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + sound: isSet(object.sound) ? soundFromJSON(object.sound) : 0, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + }; + }, + + toJSON(message: WorldPlaySoundAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.sound !== 0) { + obj.sound = soundToJSON(message.sound); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + return obj; + }, + + create(base?: DeepPartial): WorldPlaySoundAction { + return WorldPlaySoundAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldPlaySoundAction { + const message = createBaseWorldPlaySoundAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.sound = object.sound ?? 0; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + return message; + }, +}; + +function createBaseWorldAddParticleAction(): WorldAddParticleAction { + return { world: undefined, position: undefined, particle: 0, block: undefined, face: undefined }; +} + +export const WorldAddParticleAction: MessageFns = { + encode(message: WorldAddParticleAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + if (message.particle !== 0) { + writer.uint32(24).int32(message.particle); + } + if (message.block !== undefined) { + BlockState.encode(message.block, writer.uint32(34).fork()).join(); + } + if (message.face !== undefined) { + writer.uint32(40).int32(message.face); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldAddParticleAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldAddParticleAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 24) { + break; + } + + message.particle = reader.int32() as any; + continue; + } + case 4: { + if (tag !== 34) { + break; + } + + message.block = BlockState.decode(reader, reader.uint32()); + continue; + } + case 5: { + if (tag !== 40) { + break; + } + + message.face = reader.int32(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldAddParticleAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + particle: isSet(object.particle) ? particleTypeFromJSON(object.particle) : 0, + block: isSet(object.block) ? BlockState.fromJSON(object.block) : undefined, + face: isSet(object.face) ? globalThis.Number(object.face) : undefined, + }; + }, + + toJSON(message: WorldAddParticleAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + if (message.particle !== 0) { + obj.particle = particleTypeToJSON(message.particle); + } + if (message.block !== undefined) { + obj.block = BlockState.toJSON(message.block); + } + if (message.face !== undefined) { + obj.face = Math.round(message.face); + } + return obj; + }, + + create(base?: DeepPartial): WorldAddParticleAction { + return WorldAddParticleAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldAddParticleAction { + const message = createBaseWorldAddParticleAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + message.particle = object.particle ?? 0; + message.block = (object.block !== undefined && object.block !== null) + ? BlockState.fromPartial(object.block) + : undefined; + message.face = object.face ?? undefined; + return message; + }, +}; + +function createBaseWorldQueryEntitiesAction(): WorldQueryEntitiesAction { + return { world: undefined }; +} + +export const WorldQueryEntitiesAction: MessageFns = { + encode(message: WorldQueryEntitiesAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldQueryEntitiesAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryEntitiesAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldQueryEntitiesAction { + return { world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined }; + }, + + toJSON(message: WorldQueryEntitiesAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + return obj; + }, + + create(base?: DeepPartial): WorldQueryEntitiesAction { + return WorldQueryEntitiesAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldQueryEntitiesAction { + const message = createBaseWorldQueryEntitiesAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + return message; + }, +}; + +function createBaseWorldQueryPlayersAction(): WorldQueryPlayersAction { + return { world: undefined }; +} + +export const WorldQueryPlayersAction: MessageFns = { + encode(message: WorldQueryPlayersAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldQueryPlayersAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryPlayersAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldQueryPlayersAction { + return { world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined }; + }, + + toJSON(message: WorldQueryPlayersAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + return obj; + }, + + create(base?: DeepPartial): WorldQueryPlayersAction { + return WorldQueryPlayersAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldQueryPlayersAction { + const message = createBaseWorldQueryPlayersAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + return message; + }, +}; + +function createBaseWorldQueryEntitiesWithinAction(): WorldQueryEntitiesWithinAction { + return { world: undefined, box: undefined }; +} + +export const WorldQueryEntitiesWithinAction: MessageFns = { + encode(message: WorldQueryEntitiesWithinAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.box !== undefined) { + BBox.encode(message.box, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldQueryEntitiesWithinAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryEntitiesWithinAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.box = BBox.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldQueryEntitiesWithinAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + box: isSet(object.box) ? BBox.fromJSON(object.box) : undefined, + }; + }, + + toJSON(message: WorldQueryEntitiesWithinAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.box !== undefined) { + obj.box = BBox.toJSON(message.box); + } + return obj; + }, + + create(base?: DeepPartial): WorldQueryEntitiesWithinAction { + return WorldQueryEntitiesWithinAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldQueryEntitiesWithinAction { + const message = createBaseWorldQueryEntitiesWithinAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.box = (object.box !== undefined && object.box !== null) ? BBox.fromPartial(object.box) : undefined; + return message; + }, +}; + +function createBaseWorldQueryViewersAction(): WorldQueryViewersAction { + return { world: undefined, position: undefined }; +} + +export const WorldQueryViewersAction: MessageFns = { + encode(message: WorldQueryViewersAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldQueryViewersAction { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldQueryViewersAction(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldQueryViewersAction { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + }; + }, + + toJSON(message: WorldQueryViewersAction): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + return obj; + }, + + create(base?: DeepPartial): WorldQueryViewersAction { + return WorldQueryViewersAction.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldQueryViewersAction { + const message = createBaseWorldQueryViewersAction(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + return message; + }, +}; + +function createBaseActionStatus(): ActionStatus { + return { ok: false, error: undefined }; +} + +export const ActionStatus: MessageFns = { + encode(message: ActionStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.ok !== false) { + writer.uint32(8).bool(message.ok); + } + if (message.error !== undefined) { + writer.uint32(18).string(message.error); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ActionStatus { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseActionStatus(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 8) { + break; + } + + message.ok = reader.bool(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.error = reader.string(); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ActionStatus { + return { + ok: isSet(object.ok) ? globalThis.Boolean(object.ok) : false, + error: isSet(object.error) ? globalThis.String(object.error) : undefined, + }; + }, + + toJSON(message: ActionStatus): unknown { + const obj: any = {}; + if (message.ok !== false) { + obj.ok = message.ok; + } + if (message.error !== undefined) { + obj.error = message.error; + } + return obj; + }, + + create(base?: DeepPartial): ActionStatus { + return ActionStatus.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ActionStatus { + const message = createBaseActionStatus(); + message.ok = object.ok ?? false; + message.error = object.error ?? undefined; + return message; + }, +}; + +function createBaseWorldEntitiesResult(): WorldEntitiesResult { + return { world: undefined, entities: [] }; +} + +export const WorldEntitiesResult: MessageFns = { + encode(message: WorldEntitiesResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + for (const v of message.entities) { + EntityRef.encode(v!, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldEntitiesResult { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldEntitiesResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.entities.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldEntitiesResult { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + entities: globalThis.Array.isArray(object?.entities) + ? object.entities.map((e: any) => EntityRef.fromJSON(e)) + : [], + }; + }, + + toJSON(message: WorldEntitiesResult): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.entities?.length) { + obj.entities = message.entities.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): WorldEntitiesResult { + return WorldEntitiesResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldEntitiesResult { + const message = createBaseWorldEntitiesResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.entities = object.entities?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseWorldEntitiesWithinResult(): WorldEntitiesWithinResult { + return { world: undefined, box: undefined, entities: [] }; +} + +export const WorldEntitiesWithinResult: MessageFns = { + encode(message: WorldEntitiesWithinResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.box !== undefined) { + BBox.encode(message.box, writer.uint32(18).fork()).join(); + } + for (const v of message.entities) { + EntityRef.encode(v!, writer.uint32(26).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldEntitiesWithinResult { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldEntitiesWithinResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.box = BBox.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.entities.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldEntitiesWithinResult { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + box: isSet(object.box) ? BBox.fromJSON(object.box) : undefined, + entities: globalThis.Array.isArray(object?.entities) + ? object.entities.map((e: any) => EntityRef.fromJSON(e)) + : [], + }; + }, + + toJSON(message: WorldEntitiesWithinResult): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.box !== undefined) { + obj.box = BBox.toJSON(message.box); + } + if (message.entities?.length) { + obj.entities = message.entities.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): WorldEntitiesWithinResult { + return WorldEntitiesWithinResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldEntitiesWithinResult { + const message = createBaseWorldEntitiesWithinResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.box = (object.box !== undefined && object.box !== null) ? BBox.fromPartial(object.box) : undefined; + message.entities = object.entities?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseWorldPlayersResult(): WorldPlayersResult { + return { world: undefined, players: [] }; +} + +export const WorldPlayersResult: MessageFns = { + encode(message: WorldPlayersResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + for (const v of message.players) { + EntityRef.encode(v!, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldPlayersResult { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldPlayersResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.players.push(EntityRef.decode(reader, reader.uint32())); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldPlayersResult { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + players: globalThis.Array.isArray(object?.players) ? object.players.map((e: any) => EntityRef.fromJSON(e)) : [], + }; + }, + + toJSON(message: WorldPlayersResult): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.players?.length) { + obj.players = message.players.map((e) => EntityRef.toJSON(e)); + } + return obj; + }, + + create(base?: DeepPartial): WorldPlayersResult { + return WorldPlayersResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldPlayersResult { + const message = createBaseWorldPlayersResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.players = object.players?.map((e) => EntityRef.fromPartial(e)) || []; + return message; + }, +}; + +function createBaseWorldViewersResult(): WorldViewersResult { + return { world: undefined, position: undefined, viewerUuids: [] }; +} + +export const WorldViewersResult: MessageFns = { + encode(message: WorldViewersResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.world !== undefined) { + WorldRef.encode(message.world, writer.uint32(10).fork()).join(); + } + if (message.position !== undefined) { + Vec3.encode(message.position, writer.uint32(18).fork()).join(); + } + for (const v of message.viewerUuids) { + writer.uint32(26).string(v!); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): WorldViewersResult { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseWorldViewersResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.world = WorldRef.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.position = Vec3.decode(reader, reader.uint32()); + continue; + } + case 3: { + if (tag !== 26) { + break; + } + + message.viewerUuids.push(reader.string()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): WorldViewersResult { + return { + world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, + position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, + viewerUuids: globalThis.Array.isArray(object?.viewerUuids) + ? object.viewerUuids.map((e: any) => globalThis.String(e)) + : [], + }; + }, + + toJSON(message: WorldViewersResult): unknown { + const obj: any = {}; + if (message.world !== undefined) { + obj.world = WorldRef.toJSON(message.world); + } + if (message.position !== undefined) { + obj.position = Vec3.toJSON(message.position); + } + if (message.viewerUuids?.length) { + obj.viewerUuids = message.viewerUuids; + } + return obj; + }, + + create(base?: DeepPartial): WorldViewersResult { + return WorldViewersResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): WorldViewersResult { + const message = createBaseWorldViewersResult(); + message.world = (object.world !== undefined && object.world !== null) + ? WorldRef.fromPartial(object.world) + : undefined; + message.position = (object.position !== undefined && object.position !== null) + ? Vec3.fromPartial(object.position) + : undefined; + message.viewerUuids = object.viewerUuids?.map((e) => e) || []; + return message; + }, +}; + +function createBaseActionResult(): ActionResult { + return { + correlationId: "", + status: undefined, + worldEntities: undefined, + worldPlayers: undefined, + worldEntitiesWithin: undefined, + worldViewers: undefined, + }; +} + +export const ActionResult: MessageFns = { + encode(message: ActionResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.correlationId !== "") { + writer.uint32(10).string(message.correlationId); + } + if (message.status !== undefined) { + ActionStatus.encode(message.status, writer.uint32(18).fork()).join(); + } + if (message.worldEntities !== undefined) { + WorldEntitiesResult.encode(message.worldEntities, writer.uint32(82).fork()).join(); + } + if (message.worldPlayers !== undefined) { + WorldPlayersResult.encode(message.worldPlayers, writer.uint32(90).fork()).join(); + } + if (message.worldEntitiesWithin !== undefined) { + WorldEntitiesWithinResult.encode(message.worldEntitiesWithin, writer.uint32(98).fork()).join(); + } + if (message.worldViewers !== undefined) { + WorldViewersResult.encode(message.worldViewers, writer.uint32(106).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): ActionResult { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseActionResult(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.correlationId = reader.string(); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.status = ActionStatus.decode(reader, reader.uint32()); + continue; + } + case 10: { + if (tag !== 82) { + break; + } + + message.worldEntities = WorldEntitiesResult.decode(reader, reader.uint32()); + continue; + } + case 11: { + if (tag !== 90) { + break; + } + + message.worldPlayers = WorldPlayersResult.decode(reader, reader.uint32()); + continue; + } + case 12: { + if (tag !== 98) { + break; + } + + message.worldEntitiesWithin = WorldEntitiesWithinResult.decode(reader, reader.uint32()); + continue; + } + case 13: { + if (tag !== 106) { + break; + } + + message.worldViewers = WorldViewersResult.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): ActionResult { + return { + correlationId: isSet(object.correlationId) ? globalThis.String(object.correlationId) : "", + status: isSet(object.status) ? ActionStatus.fromJSON(object.status) : undefined, + worldEntities: isSet(object.worldEntities) ? WorldEntitiesResult.fromJSON(object.worldEntities) : undefined, + worldPlayers: isSet(object.worldPlayers) ? WorldPlayersResult.fromJSON(object.worldPlayers) : undefined, + worldEntitiesWithin: isSet(object.worldEntitiesWithin) + ? WorldEntitiesWithinResult.fromJSON(object.worldEntitiesWithin) + : undefined, + worldViewers: isSet(object.worldViewers) ? WorldViewersResult.fromJSON(object.worldViewers) : undefined, + }; + }, + + toJSON(message: ActionResult): unknown { + const obj: any = {}; + if (message.correlationId !== "") { + obj.correlationId = message.correlationId; + } + if (message.status !== undefined) { + obj.status = ActionStatus.toJSON(message.status); + } + if (message.worldEntities !== undefined) { + obj.worldEntities = WorldEntitiesResult.toJSON(message.worldEntities); + } + if (message.worldPlayers !== undefined) { + obj.worldPlayers = WorldPlayersResult.toJSON(message.worldPlayers); + } + if (message.worldEntitiesWithin !== undefined) { + obj.worldEntitiesWithin = WorldEntitiesWithinResult.toJSON(message.worldEntitiesWithin); + } + if (message.worldViewers !== undefined) { + obj.worldViewers = WorldViewersResult.toJSON(message.worldViewers); + } + return obj; + }, + + create(base?: DeepPartial): ActionResult { + return ActionResult.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): ActionResult { + const message = createBaseActionResult(); + message.correlationId = object.correlationId ?? ""; + message.status = (object.status !== undefined && object.status !== null) + ? ActionStatus.fromPartial(object.status) + : undefined; + message.worldEntities = (object.worldEntities !== undefined && object.worldEntities !== null) + ? WorldEntitiesResult.fromPartial(object.worldEntities) + : undefined; + message.worldPlayers = (object.worldPlayers !== undefined && object.worldPlayers !== null) + ? WorldPlayersResult.fromPartial(object.worldPlayers) + : undefined; + message.worldEntitiesWithin = (object.worldEntitiesWithin !== undefined && object.worldEntitiesWithin !== null) + ? WorldEntitiesWithinResult.fromPartial(object.worldEntitiesWithin) + : undefined; + message.worldViewers = (object.worldViewers !== undefined && object.worldViewers !== null) + ? WorldViewersResult.fromPartial(object.worldViewers) + : undefined; + return message; + }, +}; + type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined; export type DeepPartial = T extends Builtin ? T diff --git a/packages/node/src/generated/common.js b/packages/node/src/generated/common.js index 5823ba0..524d91f 100644 --- a/packages/node/src/generated/common.js +++ b/packages/node/src/generated/common.js @@ -49,6 +49,49 @@ export function gameModeToJSON(object) { return "UNRECOGNIZED"; } } +export var Difficulty; +(function (Difficulty) { + Difficulty[Difficulty["PEACEFUL"] = 0] = "PEACEFUL"; + Difficulty[Difficulty["EASY"] = 1] = "EASY"; + Difficulty[Difficulty["NORMAL"] = 2] = "NORMAL"; + Difficulty[Difficulty["HARD"] = 3] = "HARD"; + Difficulty[Difficulty["UNRECOGNIZED"] = -1] = "UNRECOGNIZED"; +})(Difficulty || (Difficulty = {})); +export function difficultyFromJSON(object) { + switch (object) { + case 0: + case "PEACEFUL": + return Difficulty.PEACEFUL; + case 1: + case "EASY": + return Difficulty.EASY; + case 2: + case "NORMAL": + return Difficulty.NORMAL; + case 3: + case "HARD": + return Difficulty.HARD; + case -1: + case "UNRECOGNIZED": + default: + return Difficulty.UNRECOGNIZED; + } +} +export function difficultyToJSON(object) { + switch (object) { + case Difficulty.PEACEFUL: + return "PEACEFUL"; + case Difficulty.EASY: + return "EASY"; + case Difficulty.NORMAL: + return "NORMAL"; + case Difficulty.HARD: + return "HARD"; + case Difficulty.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} /** * EffectType mirrors Dragonfly's registered effect IDs for straightforward mapping. * Keep numeric values aligned with dragonfly/server/entity/effect/register.go. @@ -592,6 +635,74 @@ export const Rotation = { return message; }, }; +function createBaseBBox() { + return { min: undefined, max: undefined }; +} +export const BBox = { + encode(message, writer = new BinaryWriter()) { + if (message.min !== undefined) { + Vec3.encode(message.min, writer.uint32(10).fork()).join(); + } + if (message.max !== undefined) { + Vec3.encode(message.max, writer.uint32(18).fork()).join(); + } + return writer; + }, + decode(input, length) { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBBox(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + message.min = Vec3.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + message.max = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + fromJSON(object) { + return { + min: isSet(object.min) ? Vec3.fromJSON(object.min) : undefined, + max: isSet(object.max) ? Vec3.fromJSON(object.max) : undefined, + }; + }, + toJSON(message) { + const obj = {}; + if (message.min !== undefined) { + obj.min = Vec3.toJSON(message.min); + } + if (message.max !== undefined) { + obj.max = Vec3.toJSON(message.max); + } + return obj; + }, + create(base) { + return BBox.fromPartial(base ?? {}); + }, + fromPartial(object) { + const message = createBaseBBox(); + message.min = (object.min !== undefined && object.min !== null) ? Vec3.fromPartial(object.min) : undefined; + message.max = (object.max !== undefined && object.max !== null) ? Vec3.fromPartial(object.max) : undefined; + return message; + }, +}; function createBaseBlockPos() { return { x: 0, y: 0, z: 0 }; } diff --git a/packages/node/src/generated/common.ts b/packages/node/src/generated/common.ts index 3409e6d..c237000 100644 --- a/packages/node/src/generated/common.ts +++ b/packages/node/src/generated/common.ts @@ -54,6 +54,51 @@ export function gameModeToJSON(object: GameMode): string { } } +export enum Difficulty { + PEACEFUL = 0, + EASY = 1, + NORMAL = 2, + HARD = 3, + UNRECOGNIZED = -1, +} + +export function difficultyFromJSON(object: any): Difficulty { + switch (object) { + case 0: + case "PEACEFUL": + return Difficulty.PEACEFUL; + case 1: + case "EASY": + return Difficulty.EASY; + case 2: + case "NORMAL": + return Difficulty.NORMAL; + case 3: + case "HARD": + return Difficulty.HARD; + case -1: + case "UNRECOGNIZED": + default: + return Difficulty.UNRECOGNIZED; + } +} + +export function difficultyToJSON(object: Difficulty): string { + switch (object) { + case Difficulty.PEACEFUL: + return "PEACEFUL"; + case Difficulty.EASY: + return "EASY"; + case Difficulty.NORMAL: + return "NORMAL"; + case Difficulty.HARD: + return "HARD"; + case Difficulty.UNRECOGNIZED: + default: + return "UNRECOGNIZED"; + } +} + /** * EffectType mirrors Dragonfly's registered effect IDs for straightforward mapping. * Keep numeric values aligned with dragonfly/server/entity/effect/register.go. @@ -463,6 +508,11 @@ export interface Rotation { pitch: number; } +export interface BBox { + min: Vec3 | undefined; + max: Vec3 | undefined; +} + export interface BlockPos { x: number; y: number; @@ -709,6 +759,82 @@ export const Rotation: MessageFns = { }, }; +function createBaseBBox(): BBox { + return { min: undefined, max: undefined }; +} + +export const BBox: MessageFns = { + encode(message: BBox, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { + if (message.min !== undefined) { + Vec3.encode(message.min, writer.uint32(10).fork()).join(); + } + if (message.max !== undefined) { + Vec3.encode(message.max, writer.uint32(18).fork()).join(); + } + return writer; + }, + + decode(input: BinaryReader | Uint8Array, length?: number): BBox { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseBBox(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: { + if (tag !== 10) { + break; + } + + message.min = Vec3.decode(reader, reader.uint32()); + continue; + } + case 2: { + if (tag !== 18) { + break; + } + + message.max = Vec3.decode(reader, reader.uint32()); + continue; + } + } + if ((tag & 7) === 4 || tag === 0) { + break; + } + reader.skip(tag & 7); + } + return message; + }, + + fromJSON(object: any): BBox { + return { + min: isSet(object.min) ? Vec3.fromJSON(object.min) : undefined, + max: isSet(object.max) ? Vec3.fromJSON(object.max) : undefined, + }; + }, + + toJSON(message: BBox): unknown { + const obj: any = {}; + if (message.min !== undefined) { + obj.min = Vec3.toJSON(message.min); + } + if (message.max !== undefined) { + obj.max = Vec3.toJSON(message.max); + } + return obj; + }, + + create(base?: DeepPartial): BBox { + return BBox.fromPartial(base ?? {}); + }, + fromPartial(object: DeepPartial): BBox { + const message = createBaseBBox(); + message.min = (object.min !== undefined && object.min !== null) ? Vec3.fromPartial(object.min) : undefined; + message.max = (object.max !== undefined && object.max !== null) ? Vec3.fromPartial(object.max) : undefined; + return message; + }, +}; + function createBaseBlockPos(): BlockPos { return { x: 0, y: 0, z: 0 }; } diff --git a/packages/node/src/generated/plugin.js b/packages/node/src/generated/plugin.js index a5b6d80..d331007 100644 --- a/packages/node/src/generated/plugin.js +++ b/packages/node/src/generated/plugin.js @@ -5,7 +5,7 @@ // source: plugin.proto /* eslint-disable */ import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; -import { ActionBatch } from "./actions.js"; +import { ActionBatch, ActionResult } from "./actions.js"; import { CommandEvent, CommandSpec } from "./command.js"; import { CustomItemDefinition } from "./common.js"; import { EventResult } from "./mutations.js"; @@ -338,7 +338,14 @@ export function eventTypeToJSON(object) { } } function createBaseHostToPlugin() { - return { pluginId: "", hello: undefined, shutdown: undefined, serverInfo: undefined, event: undefined }; + return { + pluginId: "", + hello: undefined, + shutdown: undefined, + serverInfo: undefined, + event: undefined, + actionResult: undefined, + }; } export const HostToPlugin = { encode(message, writer = new BinaryWriter()) { @@ -357,6 +364,9 @@ export const HostToPlugin = { if (message.event !== undefined) { EventEnvelope.encode(message.event, writer.uint32(162).fork()).join(); } + if (message.actionResult !== undefined) { + ActionResult.encode(message.actionResult, writer.uint32(170).fork()).join(); + } return writer; }, decode(input, length) { @@ -401,6 +411,13 @@ export const HostToPlugin = { message.event = EventEnvelope.decode(reader, reader.uint32()); continue; } + case 21: { + if (tag !== 170) { + break; + } + message.actionResult = ActionResult.decode(reader, reader.uint32()); + continue; + } } if ((tag & 7) === 4 || tag === 0) { break; @@ -416,6 +433,7 @@ export const HostToPlugin = { shutdown: isSet(object.shutdown) ? HostShutdown.fromJSON(object.shutdown) : undefined, serverInfo: isSet(object.serverInfo) ? ServerInformationResponse.fromJSON(object.serverInfo) : undefined, event: isSet(object.event) ? EventEnvelope.fromJSON(object.event) : undefined, + actionResult: isSet(object.actionResult) ? ActionResult.fromJSON(object.actionResult) : undefined, }; }, toJSON(message) { @@ -435,6 +453,9 @@ export const HostToPlugin = { if (message.event !== undefined) { obj.event = EventEnvelope.toJSON(message.event); } + if (message.actionResult !== undefined) { + obj.actionResult = ActionResult.toJSON(message.actionResult); + } return obj; }, create(base) { @@ -455,6 +476,9 @@ export const HostToPlugin = { message.event = (object.event !== undefined && object.event !== null) ? EventEnvelope.fromPartial(object.event) : undefined; + message.actionResult = (object.actionResult !== undefined && object.actionResult !== null) + ? ActionResult.fromPartial(object.actionResult) + : undefined; return message; }, }; diff --git a/packages/node/src/generated/plugin.ts b/packages/node/src/generated/plugin.ts index 3f63e25..272b31c 100644 --- a/packages/node/src/generated/plugin.ts +++ b/packages/node/src/generated/plugin.ts @@ -6,7 +6,7 @@ /* eslint-disable */ import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire"; -import { ActionBatch } from "./actions.js"; +import { ActionBatch, ActionResult } from "./actions.js"; import { CommandEvent, CommandSpec } from "./command.js"; import { CustomItemDefinition } from "./common.js"; import { EventResult } from "./mutations.js"; @@ -398,6 +398,7 @@ export interface HostToPlugin { shutdown?: HostShutdown | undefined; serverInfo?: ServerInformationResponse | undefined; event?: EventEnvelope | undefined; + actionResult?: ActionResult | undefined; } export interface ServerInformationRequest { @@ -499,7 +500,14 @@ export interface EventSubscribe { } function createBaseHostToPlugin(): HostToPlugin { - return { pluginId: "", hello: undefined, shutdown: undefined, serverInfo: undefined, event: undefined }; + return { + pluginId: "", + hello: undefined, + shutdown: undefined, + serverInfo: undefined, + event: undefined, + actionResult: undefined, + }; } export const HostToPlugin: MessageFns = { @@ -519,6 +527,9 @@ export const HostToPlugin: MessageFns = { if (message.event !== undefined) { EventEnvelope.encode(message.event, writer.uint32(162).fork()).join(); } + if (message.actionResult !== undefined) { + ActionResult.encode(message.actionResult, writer.uint32(170).fork()).join(); + } return writer; }, @@ -569,6 +580,14 @@ export const HostToPlugin: MessageFns = { message.event = EventEnvelope.decode(reader, reader.uint32()); continue; } + case 21: { + if (tag !== 170) { + break; + } + + message.actionResult = ActionResult.decode(reader, reader.uint32()); + continue; + } } if ((tag & 7) === 4 || tag === 0) { break; @@ -585,6 +604,7 @@ export const HostToPlugin: MessageFns = { shutdown: isSet(object.shutdown) ? HostShutdown.fromJSON(object.shutdown) : undefined, serverInfo: isSet(object.serverInfo) ? ServerInformationResponse.fromJSON(object.serverInfo) : undefined, event: isSet(object.event) ? EventEnvelope.fromJSON(object.event) : undefined, + actionResult: isSet(object.actionResult) ? ActionResult.fromJSON(object.actionResult) : undefined, }; }, @@ -605,6 +625,9 @@ export const HostToPlugin: MessageFns = { if (message.event !== undefined) { obj.event = EventEnvelope.toJSON(message.event); } + if (message.actionResult !== undefined) { + obj.actionResult = ActionResult.toJSON(message.actionResult); + } return obj; }, @@ -626,6 +649,9 @@ export const HostToPlugin: MessageFns = { message.event = (object.event !== undefined && object.event !== null) ? EventEnvelope.fromPartial(object.event) : undefined; + message.actionResult = (object.actionResult !== undefined && object.actionResult !== null) + ? ActionResult.fromPartial(object.actionResult) + : undefined; return message; }, }; diff --git a/packages/php/src/generated/Df/Plugin/Action.php b/packages/php/src/generated/Df/Plugin/Action.php index 0aa659b..2d66a4f 100644 --- a/packages/php/src/generated/Df/Plugin/Action.php +++ b/packages/php/src/generated/Df/Plugin/Action.php @@ -50,6 +50,18 @@ class Action extends \Google\Protobuf\Internal\Message * @type \Df\Plugin\PlaySoundAction $play_sound * @type \Df\Plugin\ExecuteCommandAction $execute_command * Commands + * @type \Df\Plugin\WorldSetDefaultGameModeAction $world_set_default_game_mode + * World configuration and effects + * @type \Df\Plugin\WorldSetDifficultyAction $world_set_difficulty + * @type \Df\Plugin\WorldSetTickRangeAction $world_set_tick_range + * @type \Df\Plugin\WorldSetBlockAction $world_set_block + * @type \Df\Plugin\WorldPlaySoundAction $world_play_sound + * @type \Df\Plugin\WorldAddParticleAction $world_add_particle + * @type \Df\Plugin\WorldQueryEntitiesAction $world_query_entities + * World queries + * @type \Df\Plugin\WorldQueryPlayersAction $world_query_players + * @type \Df\Plugin\WorldQueryEntitiesWithinAction $world_query_entities_within + * @type \Df\Plugin\WorldQueryViewersAction $world_query_viewers * } */ public function __construct($data = NULL) { @@ -595,6 +607,284 @@ public function setExecuteCommand($var) return $this; } + /** + * World configuration and effects + * + * Generated from protobuf field .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; + * @return \Df\Plugin\WorldSetDefaultGameModeAction|null + */ + public function getWorldSetDefaultGameMode() + { + return $this->readOneof(60); + } + + public function hasWorldSetDefaultGameMode() + { + return $this->hasOneof(60); + } + + /** + * World configuration and effects + * + * Generated from protobuf field .df.plugin.WorldSetDefaultGameModeAction world_set_default_game_mode = 60 [json_name = "worldSetDefaultGameMode"]; + * @param \Df\Plugin\WorldSetDefaultGameModeAction $var + * @return $this + */ + public function setWorldSetDefaultGameMode($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldSetDefaultGameModeAction::class); + $this->writeOneof(60, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; + * @return \Df\Plugin\WorldSetDifficultyAction|null + */ + public function getWorldSetDifficulty() + { + return $this->readOneof(61); + } + + public function hasWorldSetDifficulty() + { + return $this->hasOneof(61); + } + + /** + * Generated from protobuf field .df.plugin.WorldSetDifficultyAction world_set_difficulty = 61 [json_name = "worldSetDifficulty"]; + * @param \Df\Plugin\WorldSetDifficultyAction $var + * @return $this + */ + public function setWorldSetDifficulty($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldSetDifficultyAction::class); + $this->writeOneof(61, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; + * @return \Df\Plugin\WorldSetTickRangeAction|null + */ + public function getWorldSetTickRange() + { + return $this->readOneof(62); + } + + public function hasWorldSetTickRange() + { + return $this->hasOneof(62); + } + + /** + * Generated from protobuf field .df.plugin.WorldSetTickRangeAction world_set_tick_range = 62 [json_name = "worldSetTickRange"]; + * @param \Df\Plugin\WorldSetTickRangeAction $var + * @return $this + */ + public function setWorldSetTickRange($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldSetTickRangeAction::class); + $this->writeOneof(62, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; + * @return \Df\Plugin\WorldSetBlockAction|null + */ + public function getWorldSetBlock() + { + return $this->readOneof(63); + } + + public function hasWorldSetBlock() + { + return $this->hasOneof(63); + } + + /** + * Generated from protobuf field .df.plugin.WorldSetBlockAction world_set_block = 63 [json_name = "worldSetBlock"]; + * @param \Df\Plugin\WorldSetBlockAction $var + * @return $this + */ + public function setWorldSetBlock($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldSetBlockAction::class); + $this->writeOneof(63, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; + * @return \Df\Plugin\WorldPlaySoundAction|null + */ + public function getWorldPlaySound() + { + return $this->readOneof(64); + } + + public function hasWorldPlaySound() + { + return $this->hasOneof(64); + } + + /** + * Generated from protobuf field .df.plugin.WorldPlaySoundAction world_play_sound = 64 [json_name = "worldPlaySound"]; + * @param \Df\Plugin\WorldPlaySoundAction $var + * @return $this + */ + public function setWorldPlaySound($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldPlaySoundAction::class); + $this->writeOneof(64, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; + * @return \Df\Plugin\WorldAddParticleAction|null + */ + public function getWorldAddParticle() + { + return $this->readOneof(65); + } + + public function hasWorldAddParticle() + { + return $this->hasOneof(65); + } + + /** + * Generated from protobuf field .df.plugin.WorldAddParticleAction world_add_particle = 65 [json_name = "worldAddParticle"]; + * @param \Df\Plugin\WorldAddParticleAction $var + * @return $this + */ + public function setWorldAddParticle($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldAddParticleAction::class); + $this->writeOneof(65, $var); + + return $this; + } + + /** + * World queries + * + * Generated from protobuf field .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; + * @return \Df\Plugin\WorldQueryEntitiesAction|null + */ + public function getWorldQueryEntities() + { + return $this->readOneof(70); + } + + public function hasWorldQueryEntities() + { + return $this->hasOneof(70); + } + + /** + * World queries + * + * Generated from protobuf field .df.plugin.WorldQueryEntitiesAction world_query_entities = 70 [json_name = "worldQueryEntities"]; + * @param \Df\Plugin\WorldQueryEntitiesAction $var + * @return $this + */ + public function setWorldQueryEntities($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldQueryEntitiesAction::class); + $this->writeOneof(70, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; + * @return \Df\Plugin\WorldQueryPlayersAction|null + */ + public function getWorldQueryPlayers() + { + return $this->readOneof(71); + } + + public function hasWorldQueryPlayers() + { + return $this->hasOneof(71); + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryPlayersAction world_query_players = 71 [json_name = "worldQueryPlayers"]; + * @param \Df\Plugin\WorldQueryPlayersAction $var + * @return $this + */ + public function setWorldQueryPlayers($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldQueryPlayersAction::class); + $this->writeOneof(71, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; + * @return \Df\Plugin\WorldQueryEntitiesWithinAction|null + */ + public function getWorldQueryEntitiesWithin() + { + return $this->readOneof(72); + } + + public function hasWorldQueryEntitiesWithin() + { + return $this->hasOneof(72); + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; + * @param \Df\Plugin\WorldQueryEntitiesWithinAction $var + * @return $this + */ + public function setWorldQueryEntitiesWithin($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldQueryEntitiesWithinAction::class); + $this->writeOneof(72, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; + * @return \Df\Plugin\WorldQueryViewersAction|null + */ + public function getWorldQueryViewers() + { + return $this->readOneof(73); + } + + public function hasWorldQueryViewers() + { + return $this->hasOneof(73); + } + + /** + * Generated from protobuf field .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; + * @param \Df\Plugin\WorldQueryViewersAction $var + * @return $this + */ + public function setWorldQueryViewers($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldQueryViewersAction::class); + $this->writeOneof(73, $var); + + return $this; + } + /** * @return string */ diff --git a/packages/php/src/generated/Df/Plugin/ActionResult.php b/packages/php/src/generated/Df/Plugin/ActionResult.php new file mode 100644 index 0000000..3cf5678 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/ActionResult.php @@ -0,0 +1,217 @@ +df.plugin.ActionResult + */ +class ActionResult extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field string correlation_id = 1 [json_name = "correlationId"]; + */ + protected $correlation_id = ''; + /** + * Generated from protobuf field optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + */ + protected $status = null; + protected $result; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type string $correlation_id + * @type \Df\Plugin\ActionStatus $status + * @type \Df\Plugin\WorldEntitiesResult $world_entities + * @type \Df\Plugin\WorldPlayersResult $world_players + * @type \Df\Plugin\WorldEntitiesWithinResult $world_entities_within + * @type \Df\Plugin\WorldViewersResult $world_viewers + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field string correlation_id = 1 [json_name = "correlationId"]; + * @return string + */ + public function getCorrelationId() + { + return $this->correlation_id; + } + + /** + * Generated from protobuf field string correlation_id = 1 [json_name = "correlationId"]; + * @param string $var + * @return $this + */ + public function setCorrelationId($var) + { + GPBUtil::checkString($var, True); + $this->correlation_id = $var; + + return $this; + } + + /** + * Generated from protobuf field optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + * @return \Df\Plugin\ActionStatus|null + */ + public function getStatus() + { + return $this->status; + } + + public function hasStatus() + { + return isset($this->status); + } + + public function clearStatus() + { + unset($this->status); + } + + /** + * Generated from protobuf field optional .df.plugin.ActionStatus status = 2 [json_name = "status"]; + * @param \Df\Plugin\ActionStatus $var + * @return $this + */ + public function setStatus($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\ActionStatus::class); + $this->status = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; + * @return \Df\Plugin\WorldEntitiesResult|null + */ + public function getWorldEntities() + { + return $this->readOneof(10); + } + + public function hasWorldEntities() + { + return $this->hasOneof(10); + } + + /** + * Generated from protobuf field .df.plugin.WorldEntitiesResult world_entities = 10 [json_name = "worldEntities"]; + * @param \Df\Plugin\WorldEntitiesResult $var + * @return $this + */ + public function setWorldEntities($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldEntitiesResult::class); + $this->writeOneof(10, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; + * @return \Df\Plugin\WorldPlayersResult|null + */ + public function getWorldPlayers() + { + return $this->readOneof(11); + } + + public function hasWorldPlayers() + { + return $this->hasOneof(11); + } + + /** + * Generated from protobuf field .df.plugin.WorldPlayersResult world_players = 11 [json_name = "worldPlayers"]; + * @param \Df\Plugin\WorldPlayersResult $var + * @return $this + */ + public function setWorldPlayers($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldPlayersResult::class); + $this->writeOneof(11, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; + * @return \Df\Plugin\WorldEntitiesWithinResult|null + */ + public function getWorldEntitiesWithin() + { + return $this->readOneof(12); + } + + public function hasWorldEntitiesWithin() + { + return $this->hasOneof(12); + } + + /** + * Generated from protobuf field .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; + * @param \Df\Plugin\WorldEntitiesWithinResult $var + * @return $this + */ + public function setWorldEntitiesWithin($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldEntitiesWithinResult::class); + $this->writeOneof(12, $var); + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; + * @return \Df\Plugin\WorldViewersResult|null + */ + public function getWorldViewers() + { + return $this->readOneof(13); + } + + public function hasWorldViewers() + { + return $this->hasOneof(13); + } + + /** + * Generated from protobuf field .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; + * @param \Df\Plugin\WorldViewersResult $var + * @return $this + */ + public function setWorldViewers($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldViewersResult::class); + $this->writeOneof(13, $var); + + return $this; + } + + /** + * @return string + */ + public function getResult() + { + return $this->whichOneof("result"); + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/ActionStatus.php b/packages/php/src/generated/Df/Plugin/ActionStatus.php new file mode 100644 index 0000000..5438906 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/ActionStatus.php @@ -0,0 +1,96 @@ +df.plugin.ActionStatus + */ +class ActionStatus extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field bool ok = 1 [json_name = "ok"]; + */ + protected $ok = false; + /** + * Generated from protobuf field optional string error = 2 [json_name = "error"]; + */ + protected $error = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type bool $ok + * @type string $error + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field bool ok = 1 [json_name = "ok"]; + * @return bool + */ + public function getOk() + { + return $this->ok; + } + + /** + * Generated from protobuf field bool ok = 1 [json_name = "ok"]; + * @param bool $var + * @return $this + */ + public function setOk($var) + { + GPBUtil::checkBool($var); + $this->ok = $var; + + return $this; + } + + /** + * Generated from protobuf field optional string error = 2 [json_name = "error"]; + * @return string + */ + public function getError() + { + return isset($this->error) ? $this->error : ''; + } + + public function hasError() + { + return isset($this->error); + } + + public function clearError() + { + unset($this->error); + } + + /** + * Generated from protobuf field optional string error = 2 [json_name = "error"]; + * @param string $var + * @return $this + */ + public function setError($var) + { + GPBUtil::checkString($var, True); + $this->error = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/BBox.php b/packages/php/src/generated/Df/Plugin/BBox.php new file mode 100644 index 0000000..1bb9164 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/BBox.php @@ -0,0 +1,106 @@ +df.plugin.BBox + */ +class BBox extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.Vec3 min = 1 [json_name = "min"]; + */ + protected $min = null; + /** + * Generated from protobuf field .df.plugin.Vec3 max = 2 [json_name = "max"]; + */ + protected $max = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\Vec3 $min + * @type \Df\Plugin\Vec3 $max + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Common::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 min = 1 [json_name = "min"]; + * @return \Df\Plugin\Vec3|null + */ + public function getMin() + { + return $this->min; + } + + public function hasMin() + { + return isset($this->min); + } + + public function clearMin() + { + unset($this->min); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 min = 1 [json_name = "min"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setMin($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->min = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Vec3 max = 2 [json_name = "max"]; + * @return \Df\Plugin\Vec3|null + */ + public function getMax() + { + return $this->max; + } + + public function hasMax() + { + return isset($this->max); + } + + public function clearMax() + { + unset($this->max); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 max = 2 [json_name = "max"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setMax($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->max = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/Difficulty.php b/packages/php/src/generated/Df/Plugin/Difficulty.php new file mode 100644 index 0000000..c972136 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/Difficulty.php @@ -0,0 +1,59 @@ +df.plugin.Difficulty + */ +class Difficulty +{ + /** + * Generated from protobuf enum PEACEFUL = 0; + */ + const PEACEFUL = 0; + /** + * Generated from protobuf enum EASY = 1; + */ + const EASY = 1; + /** + * Generated from protobuf enum NORMAL = 2; + */ + const NORMAL = 2; + /** + * Generated from protobuf enum HARD = 3; + */ + const HARD = 3; + + private static $valueToName = [ + self::PEACEFUL => 'PEACEFUL', + self::EASY => 'EASY', + self::NORMAL => 'NORMAL', + self::HARD => 'HARD', + ]; + + public static function name($value) + { + if (!isset(self::$valueToName[$value])) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no name defined for value %s', __CLASS__, $value)); + } + return self::$valueToName[$value]; + } + + + public static function value($name) + { + $const = __CLASS__ . '::' . strtoupper($name); + if (!defined($const)) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no value defined for name %s', __CLASS__, $name)); + } + return constant($const); + } +} + diff --git a/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php b/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php index 1eba38f..ff285da 100644 --- a/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php +++ b/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php @@ -17,7 +17,7 @@ public static function initOnce() { } \Df\Plugin\GPBMetadata\Common::initOnce(); $pool->internalAddGeneratedFile( - "\x0A\xFB\x1C\x0A\x0Dactions.proto\x12\x09df.plugin\":\x0A\x0BActionBatch\x12+\x0A\x07actions\x18\x01 \x03(\x0B2\x11.df.plugin.ActionR\x07actions\"\xBA\x09\x0A\x06Action\x12*\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09H\x01R\x0DcorrelationId\x88\x01\x01\x128\x0A\x09send_chat\x18\x0A \x01(\x0B2\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x127\x0A\x08teleport\x18\x0B \x01(\x0B2\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\x0A\x04kick\x18\x0C \x01(\x0B2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\x0A\x0Dset_game_mode\x18\x0D \x01(\x0B2\x1C.df.plugin.SetGameModeActionH\x00R\x0BsetGameMode\x128\x0A\x09give_item\x18\x0E \x01(\x0B2\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\x0A\x0Fclear_inventory\x18\x0F \x01(\x0B2\x1F.df.plugin.ClearInventoryActionH\x00R\x0EclearInventory\x12B\x0A\x0Dset_held_item\x18\x10 \x01(\x0B2\x1C.df.plugin.SetHeldItemActionH\x00R\x0BsetHeldItem\x12;\x0A\x0Aset_health\x18\x14 \x01(\x0B2\x1A.df.plugin.SetHealthActionH\x00R\x09setHealth\x125\x0A\x08set_food\x18\x15 \x01(\x0B2\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\x0A\x0Eset_experience\x18\x16 \x01(\x0B2\x1E.df.plugin.SetExperienceActionH\x00R\x0DsetExperience\x12A\x0A\x0Cset_velocity\x18\x17 \x01(\x0B2\x1C.df.plugin.SetVelocityActionH\x00R\x0BsetVelocity\x12;\x0A\x0Aadd_effect\x18\x1E \x01(\x0B2\x1A.df.plugin.AddEffectActionH\x00R\x09addEffect\x12D\x0A\x0Dremove_effect\x18\x1F \x01(\x0B2\x1D.df.plugin.RemoveEffectActionH\x00R\x0CremoveEffect\x12;\x0A\x0Asend_title\x18( \x01(\x0B2\x1A.df.plugin.SendTitleActionH\x00R\x09sendTitle\x12;\x0A\x0Asend_popup\x18) \x01(\x0B2\x1A.df.plugin.SendPopupActionH\x00R\x09sendPopup\x125\x0A\x08send_tip\x18* \x01(\x0B2\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\x0A\x0Aplay_sound\x18+ \x01(\x0B2\x1A.df.plugin.PlaySoundActionH\x00R\x09playSound\x12J\x0A\x0Fexecute_command\x182 \x01(\x0B2\x1F.df.plugin.ExecuteCommandActionH\x00R\x0EexecuteCommandB\x06\x0A\x04kindB\x11\x0A\x0F_correlation_id\"K\x0A\x0ESendChatAction\x12\x1F\x0A\x0Btarget_uuid\x18\x01 \x01(\x09R\x0AtargetUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\x8B\x01\x0A\x0ETeleportAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12+\x0A\x08rotation\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08rotation\"E\x0A\x0AKickAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06reason\x18\x02 \x01(\x09R\x06reason\"f\x0A\x11SetGameModeAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"[\x0A\x0EGiveItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12(\x0A\x04item\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackR\x04item\"7\x0A\x14ClearInventoryAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\"\xAD\x01\x0A\x11SetHeldItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12-\x0A\x04main\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\x0A\x07offhand\x18\x03 \x01(\x0B2\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01B\x07\x0A\x05_mainB\x0A\x0A\x08_offhand\"}\x0A\x0FSetHealthAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06health\x18\x02 \x01(\x01R\x06health\x12\"\x0A\x0Amax_health\x18\x03 \x01(\x01H\x00R\x09maxHealth\x88\x01\x01B\x0D\x0A\x0B_max_health\"D\x0A\x0DSetFoodAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x12\x0A\x04food\x18\x02 \x01(\x05R\x04food\"\xB1\x01\x0A\x13SetExperienceAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x19\x0A\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1F\x0A\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1B\x0A\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\x08\x0A\x06_levelB\x0B\x0A\x09_progressB\x09\x0A\x07_amount\"a\x0A\x11SetVelocityAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08velocity\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08velocity\"\xC8\x01\x0A\x0FAddEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\x12\x14\x0A\x05level\x18\x03 \x01(\x05R\x05level\x12\x1F\x0A\x0Bduration_ms\x18\x04 \x01(\x03R\x0AdurationMs\x12%\x0A\x0Eshow_particles\x18\x05 \x01(\x08R\x0DshowParticles\"m\x0A\x12RemoveEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\"\x93\x02\x0A\x0FSendTitleAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x14\x0A\x05title\x18\x02 \x01(\x09R\x05title\x12\x1F\x0A\x08subtitle\x18\x03 \x01(\x09H\x00R\x08subtitle\x88\x01\x01\x12!\x0A\x0Afade_in_ms\x18\x04 \x01(\x03H\x01R\x08fadeInMs\x88\x01\x01\x12\$\x0A\x0Bduration_ms\x18\x05 \x01(\x03H\x02R\x0AdurationMs\x88\x01\x01\x12#\x0A\x0Bfade_out_ms\x18\x06 \x01(\x03H\x03R\x09fadeOutMs\x88\x01\x01B\x0B\x0A\x09_subtitleB\x0D\x0A\x0B_fade_in_msB\x0E\x0A\x0C_duration_msB\x0E\x0A\x0C_fade_out_ms\"L\x0A\x0FSendPopupAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"J\x0A\x0DSendTipAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\xE6\x01\x0A\x0FPlaySoundAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x120\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1B\x0A\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\x0A\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\x0B\x0A\x09_positionB\x09\x0A\x07_volumeB\x08\x0A\x06_pitch\"Q\x0A\x14ExecuteCommandAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07command\x18\x02 \x01(\x09R\x07commandB\x8B\x01\x0A\x0Dcom.df.pluginB\x0CActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" + "\x0A\x8C:\x0A\x0Dactions.proto\x12\x09df.plugin\":\x0A\x0BActionBatch\x12+\x0A\x07actions\x18\x01 \x03(\x0B2\x11.df.plugin.ActionR\x07actions\"\xAF\x10\x0A\x06Action\x12*\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09H\x01R\x0DcorrelationId\x88\x01\x01\x128\x0A\x09send_chat\x18\x0A \x01(\x0B2\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x127\x0A\x08teleport\x18\x0B \x01(\x0B2\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\x0A\x04kick\x18\x0C \x01(\x0B2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\x0A\x0Dset_game_mode\x18\x0D \x01(\x0B2\x1C.df.plugin.SetGameModeActionH\x00R\x0BsetGameMode\x128\x0A\x09give_item\x18\x0E \x01(\x0B2\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\x0A\x0Fclear_inventory\x18\x0F \x01(\x0B2\x1F.df.plugin.ClearInventoryActionH\x00R\x0EclearInventory\x12B\x0A\x0Dset_held_item\x18\x10 \x01(\x0B2\x1C.df.plugin.SetHeldItemActionH\x00R\x0BsetHeldItem\x12;\x0A\x0Aset_health\x18\x14 \x01(\x0B2\x1A.df.plugin.SetHealthActionH\x00R\x09setHealth\x125\x0A\x08set_food\x18\x15 \x01(\x0B2\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\x0A\x0Eset_experience\x18\x16 \x01(\x0B2\x1E.df.plugin.SetExperienceActionH\x00R\x0DsetExperience\x12A\x0A\x0Cset_velocity\x18\x17 \x01(\x0B2\x1C.df.plugin.SetVelocityActionH\x00R\x0BsetVelocity\x12;\x0A\x0Aadd_effect\x18\x1E \x01(\x0B2\x1A.df.plugin.AddEffectActionH\x00R\x09addEffect\x12D\x0A\x0Dremove_effect\x18\x1F \x01(\x0B2\x1D.df.plugin.RemoveEffectActionH\x00R\x0CremoveEffect\x12;\x0A\x0Asend_title\x18( \x01(\x0B2\x1A.df.plugin.SendTitleActionH\x00R\x09sendTitle\x12;\x0A\x0Asend_popup\x18) \x01(\x0B2\x1A.df.plugin.SendPopupActionH\x00R\x09sendPopup\x125\x0A\x08send_tip\x18* \x01(\x0B2\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\x0A\x0Aplay_sound\x18+ \x01(\x0B2\x1A.df.plugin.PlaySoundActionH\x00R\x09playSound\x12J\x0A\x0Fexecute_command\x182 \x01(\x0B2\x1F.df.plugin.ExecuteCommandActionH\x00R\x0EexecuteCommand\x12h\x0A\x1Bworld_set_default_game_mode\x18< \x01(\x0B2(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\x0A\x14world_set_difficulty\x18= \x01(\x0B2#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\x0A\x14world_set_tick_range\x18> \x01(\x0B2\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\x0A\x0Fworld_set_block\x18? \x01(\x0B2\x1E.df.plugin.WorldSetBlockActionH\x00R\x0DworldSetBlock\x12K\x0A\x10world_play_sound\x18@ \x01(\x0B2\x1F.df.plugin.WorldPlaySoundActionH\x00R\x0EworldPlaySound\x12Q\x0A\x12world_add_particle\x18A \x01(\x0B2!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\x0A\x14world_query_entities\x18F \x01(\x0B2#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\x0A\x13world_query_players\x18G \x01(\x0B2\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\x0A\x1Bworld_query_entities_within\x18H \x01(\x0B2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\x0A\x13world_query_viewers\x18I \x01(\x0B2\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\x0A\x04kindB\x11\x0A\x0F_correlation_id\"K\x0A\x0ESendChatAction\x12\x1F\x0A\x0Btarget_uuid\x18\x01 \x01(\x09R\x0AtargetUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\x8B\x01\x0A\x0ETeleportAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12+\x0A\x08rotation\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08rotation\"E\x0A\x0AKickAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06reason\x18\x02 \x01(\x09R\x06reason\"f\x0A\x11SetGameModeAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"[\x0A\x0EGiveItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12(\x0A\x04item\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackR\x04item\"7\x0A\x14ClearInventoryAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\"\xAD\x01\x0A\x11SetHeldItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12-\x0A\x04main\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\x0A\x07offhand\x18\x03 \x01(\x0B2\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01B\x07\x0A\x05_mainB\x0A\x0A\x08_offhand\"}\x0A\x0FSetHealthAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06health\x18\x02 \x01(\x01R\x06health\x12\"\x0A\x0Amax_health\x18\x03 \x01(\x01H\x00R\x09maxHealth\x88\x01\x01B\x0D\x0A\x0B_max_health\"D\x0A\x0DSetFoodAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x12\x0A\x04food\x18\x02 \x01(\x05R\x04food\"\xB1\x01\x0A\x13SetExperienceAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x19\x0A\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1F\x0A\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1B\x0A\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\x08\x0A\x06_levelB\x0B\x0A\x09_progressB\x09\x0A\x07_amount\"a\x0A\x11SetVelocityAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08velocity\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08velocity\"\xC8\x01\x0A\x0FAddEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\x12\x14\x0A\x05level\x18\x03 \x01(\x05R\x05level\x12\x1F\x0A\x0Bduration_ms\x18\x04 \x01(\x03R\x0AdurationMs\x12%\x0A\x0Eshow_particles\x18\x05 \x01(\x08R\x0DshowParticles\"m\x0A\x12RemoveEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\"\x93\x02\x0A\x0FSendTitleAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x14\x0A\x05title\x18\x02 \x01(\x09R\x05title\x12\x1F\x0A\x08subtitle\x18\x03 \x01(\x09H\x00R\x08subtitle\x88\x01\x01\x12!\x0A\x0Afade_in_ms\x18\x04 \x01(\x03H\x01R\x08fadeInMs\x88\x01\x01\x12\$\x0A\x0Bduration_ms\x18\x05 \x01(\x03H\x02R\x0AdurationMs\x88\x01\x01\x12#\x0A\x0Bfade_out_ms\x18\x06 \x01(\x03H\x03R\x09fadeOutMs\x88\x01\x01B\x0B\x0A\x09_subtitleB\x0D\x0A\x0B_fade_in_msB\x0E\x0A\x0C_duration_msB\x0E\x0A\x0C_fade_out_ms\"L\x0A\x0FSendPopupAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"J\x0A\x0DSendTipAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\xE6\x01\x0A\x0FPlaySoundAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x120\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1B\x0A\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\x0A\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\x0B\x0A\x09_positionB\x09\x0A\x07_volumeB\x08\x0A\x06_pitch\"Q\x0A\x14ExecuteCommandAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07command\x18\x02 \x01(\x09R\x07command\"|\x0A\x1DWorldSetDefaultGameModeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"|\x0A\x18WorldSetDifficultyAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x125\x0A\x0Adifficulty\x18\x02 \x01(\x0E2\x15.df.plugin.DifficultyR\x0Adifficulty\"c\x0A\x17WorldSetTickRangeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12\x1D\x0A\x0Atick_range\x18\x02 \x01(\x05R\x09tickRange\"\xAD\x01\x0A\x13WorldSetBlockAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12/\x0A\x08position\x18\x02 \x01(\x0B2\x13.df.plugin.BlockPosR\x08position\x120\x0A\x05block\x18\x03 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01B\x08\x0A\x06_block\"\x96\x01\x0A\x14WorldPlaySoundAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x12+\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\"\x83\x02\x0A\x16WorldAddParticleAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x123\x0A\x08particle\x18\x03 \x01(\x0E2\x17.df.plugin.ParticleTypeR\x08particle\x120\x0A\x05block\x18\x04 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01\x12\x17\x0A\x04face\x18\x05 \x01(\x05H\x01R\x04face\x88\x01\x01B\x08\x0A\x06_blockB\x07\x0A\x05_face\"E\x0A\x18WorldQueryEntitiesAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"D\x0A\x17WorldQueryPlayersAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"n\x0A\x1EWorldQueryEntitiesWithinAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\"q\x0A\x17WorldQueryViewersAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\"C\x0A\x0CActionStatus\x12\x0E\x0A\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\x0A\x05error\x18\x02 \x01(\x09H\x00R\x05error\x88\x01\x01B\x08\x0A\x06_error\"r\x0A\x13WorldEntitiesResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x08entities\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"\x9B\x01\x0A\x19WorldEntitiesWithinResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\x120\x0A\x08entities\x18\x03 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"o\x0A\x12WorldPlayersResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12.\x0A\x07players\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x07players\"\x8F\x01\x0A\x12WorldViewersResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12!\x0A\x0Cviewer_uuids\x18\x03 \x03(\x09R\x0BviewerUuids\"\xB1\x03\x0A\x0CActionResult\x12%\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09R\x0DcorrelationId\x124\x0A\x06status\x18\x02 \x01(\x0B2\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\x0A\x0Eworld_entities\x18\x0A \x01(\x0B2\x1E.df.plugin.WorldEntitiesResultH\x00R\x0DworldEntities\x12D\x0A\x0Dworld_players\x18\x0B \x01(\x0B2\x1D.df.plugin.WorldPlayersResultH\x00R\x0CworldPlayers\x12Z\x0A\x15world_entities_within\x18\x0C \x01(\x0B2\$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12D\x0A\x0Dworld_viewers\x18\x0D \x01(\x0B2\x1D.df.plugin.WorldViewersResultH\x00R\x0CworldViewersB\x08\x0A\x06resultB\x09\x0A\x07_status*\xEB\x03\x0A\x0CParticleType\x12\x1D\x0A\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1B\x0A\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1E\x0A\x1APARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1A\x0A\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\x0A\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\x0A\x0FPARTICLE_SPLASH\x10\x05\x12\x13\x0A\x0FPARTICLE_EFFECT\x10\x06\x12\x19\x0A\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\x0A\x0EPARTICLE_FLAME\x10\x08\x12\x11\x0A\x0DPARTICLE_DUST\x10\x09\x12\x1E\x0A\x1APARTICLE_BLOCK_FORCE_FIELD\x10\x0A\x12\x16\x0A\x12PARTICLE_BONE_MEAL\x10\x0B\x12\x16\x0A\x12PARTICLE_EVAPORATE\x10\x0C\x12\x17\x0A\x13PARTICLE_WATER_DRIP\x10\x0D\x12\x16\x0A\x12PARTICLE_LAVA_DRIP\x10\x0E\x12\x11\x0A\x0DPARTICLE_LAVA\x10\x0F\x12\x17\x0A\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\x0A\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\x0A\x14PARTICLE_PUNCH_BLOCK\x10\x12B\x8B\x01\x0A\x0Dcom.df.pluginB\x0CActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" , true); static::$is_initialized = true; diff --git a/packages/php/src/generated/Df/Plugin/GPBMetadata/Common.php b/packages/php/src/generated/Df/Plugin/GPBMetadata/Common.php index 046dc35..a15b458 100644 --- a/packages/php/src/generated/Df/Plugin/GPBMetadata/Common.php +++ b/packages/php/src/generated/Df/Plugin/GPBMetadata/Common.php @@ -16,7 +16,7 @@ public static function initOnce() { return; } $pool->internalAddGeneratedFile( - "\x0A\xA6\x13\x0A\x0Ccommon.proto\x12\x09df.plugin\"0\x0A\x04Vec3\x12\x0C\x0A\x01x\x18\x01 \x01(\x01R\x01x\x12\x0C\x0A\x01y\x18\x02 \x01(\x01R\x01y\x12\x0C\x0A\x01z\x18\x03 \x01(\x01R\x01z\"2\x0A\x08Rotation\x12\x10\x0A\x03yaw\x18\x01 \x01(\x02R\x03yaw\x12\x14\x0A\x05pitch\x18\x02 \x01(\x02R\x05pitch\"4\x0A\x08BlockPos\x12\x0C\x0A\x01x\x18\x01 \x01(\x05R\x01x\x12\x0C\x0A\x01y\x18\x02 \x01(\x05R\x01y\x12\x0C\x0A\x01z\x18\x03 \x01(\x05R\x01z\"I\x0A\x09ItemStack\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x12\x0A\x04meta\x18\x02 \x01(\x05R\x04meta\x12\x14\x0A\x05count\x18\x03 \x01(\x05R\x05count\"\xA6\x01\x0A\x0ABlockState\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12E\x0A\x0Aproperties\x18\x02 \x03(\x0B2%.df.plugin.BlockState.PropertiesEntryR\x0Aproperties\x1A=\x0A\x0FPropertiesEntry\x12\x10\x0A\x03key\x18\x01 \x01(\x09R\x03key\x12\x14\x0A\x05value\x18\x02 \x01(\x09R\x05value:\x028\x01\"\x8B\x01\x0A\x0BLiquidState\x12+\x0A\x05block\x18\x01 \x01(\x0B2\x15.df.plugin.BlockStateR\x05block\x12\x14\x0A\x05depth\x18\x02 \x01(\x05R\x05depth\x12\x18\x0A\x07falling\x18\x03 \x01(\x08R\x07falling\x12\x1F\x0A\x0Bliquid_type\x18\x04 \x01(\x09R\x0AliquidType\"<\x0A\x08WorldRef\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x1C\x0A\x09dimension\x18\x02 \x01(\x09R\x09dimension\"\xD7\x01\x0A\x09EntityRef\x12\x12\x0A\x04uuid\x18\x01 \x01(\x09R\x04uuid\x12\x12\x0A\x04type\x18\x02 \x01(\x09R\x04type\x12\x17\x0A\x04name\x18\x03 \x01(\x09H\x00R\x04name\x88\x01\x01\x120\x0A\x08position\x18\x04 \x01(\x0B2\x0F.df.plugin.Vec3H\x01R\x08position\x88\x01\x01\x124\x0A\x08rotation\x18\x05 \x01(\x0B2\x13.df.plugin.RotationH\x02R\x08rotation\x88\x01\x01B\x07\x0A\x05_nameB\x0B\x0A\x09_positionB\x0B\x0A\x09_rotation\"Y\x0A\x0CDamageSource\x12\x12\x0A\x04type\x18\x01 \x01(\x09R\x04type\x12%\x0A\x0Bdescription\x18\x02 \x01(\x09H\x00R\x0Bdescription\x88\x01\x01B\x0E\x0A\x0C_description\"Z\x0A\x0DHealingSource\x12\x12\x0A\x04type\x18\x01 \x01(\x09R\x04type\x12%\x0A\x0Bdescription\x18\x02 \x01(\x09H\x00R\x0Bdescription\x88\x01\x01B\x0E\x0A\x0C_description\"1\x0A\x07Address\x12\x12\x0A\x04host\x18\x01 \x01(\x09R\x04host\x12\x12\x0A\x04port\x18\x02 \x01(\x05R\x04port\"\xDA\x01\x0A\x14CustomItemDefinition\x12\x0E\x0A\x02id\x18\x01 \x01(\x09R\x02id\x12!\x0A\x0Cdisplay_name\x18\x02 \x01(\x09R\x0BdisplayName\x12!\x0A\x0Ctexture_data\x18\x03 \x01(\x0CR\x0BtextureData\x123\x0A\x08category\x18\x04 \x01(\x0E2\x17.df.plugin.ItemCategoryR\x08category\x12\x19\x0A\x05group\x18\x05 \x01(\x09H\x00R\x05group\x88\x01\x01\x12\x12\x0A\x04meta\x18\x06 \x01(\x05R\x04metaB\x08\x0A\x06_group*D\x0A\x08GameMode\x12\x0C\x0A\x08SURVIVAL\x10\x00\x12\x0C\x0A\x08CREATIVE\x10\x01\x12\x0D\x0A\x09ADVENTURE\x10\x02\x12\x0D\x0A\x09SPECTATOR\x10\x03*\xE2\x03\x0A\x0AEffectType\x12\x12\x0A\x0EEFFECT_UNKNOWN\x10\x00\x12\x09\x0A\x05SPEED\x10\x01\x12\x0C\x0A\x08SLOWNESS\x10\x02\x12\x09\x0A\x05HASTE\x10\x03\x12\x12\x0A\x0EMINING_FATIGUE\x10\x04\x12\x0C\x0A\x08STRENGTH\x10\x05\x12\x12\x0A\x0EINSTANT_HEALTH\x10\x06\x12\x12\x0A\x0EINSTANT_DAMAGE\x10\x07\x12\x0E\x0A\x0AJUMP_BOOST\x10\x08\x12\x0A\x0A\x06NAUSEA\x10\x09\x12\x10\x0A\x0CREGENERATION\x10\x0A\x12\x0E\x0A\x0ARESISTANCE\x10\x0B\x12\x13\x0A\x0FFIRE_RESISTANCE\x10\x0C\x12\x13\x0A\x0FWATER_BREATHING\x10\x0D\x12\x10\x0A\x0CINVISIBILITY\x10\x0E\x12\x0D\x0A\x09BLINDNESS\x10\x0F\x12\x10\x0A\x0CNIGHT_VISION\x10\x10\x12\x0A\x0A\x06HUNGER\x10\x11\x12\x0C\x0A\x08WEAKNESS\x10\x12\x12\x0A\x0A\x06POISON\x10\x13\x12\x0A\x0A\x06WITHER\x10\x14\x12\x10\x0A\x0CHEALTH_BOOST\x10\x15\x12\x0E\x0A\x0AABSORPTION\x10\x16\x12\x0E\x0A\x0ASATURATION\x10\x17\x12\x0E\x0A\x0ALEVITATION\x10\x18\x12\x10\x0A\x0CFATAL_POISON\x10\x19\x12\x11\x0A\x0DCONDUIT_POWER\x10\x1A\x12\x10\x0A\x0CSLOW_FALLING\x10\x1B\x12\x0C\x0A\x08DARKNESS\x10\x1E*\xCD\x02\x0A\x05Sound\x12\x11\x0A\x0DSOUND_UNKNOWN\x10\x00\x12\x0A\x0A\x06ATTACK\x10\x01\x12\x0C\x0A\x08DROWNING\x10\x02\x12\x0B\x0A\x07BURNING\x10\x03\x12\x08\x0A\x04FALL\x10\x04\x12\x08\x0A\x04BURP\x10\x05\x12\x07\x0A\x03POP\x10\x06\x12\x0D\x0A\x09EXPLOSION\x10\x07\x12\x0B\x0A\x07THUNDER\x10\x08\x12\x0C\x0A\x08LEVEL_UP\x10\x09\x12\x0E\x0A\x0AEXPERIENCE\x10\x0A\x12\x13\x0A\x0FFIREWORK_LAUNCH\x10\x0B\x12\x17\x0A\x13FIREWORK_HUGE_BLAST\x10\x0C\x12\x12\x0A\x0EFIREWORK_BLAST\x10\x0D\x12\x14\x0A\x10FIREWORK_TWINKLE\x10\x0E\x12\x0C\x0A\x08TELEPORT\x10\x0F\x12\x0D\x0A\x09ARROW_HIT\x10\x10\x12\x0E\x0A\x0AITEM_BREAK\x10\x11\x12\x0E\x0A\x0AITEM_THROW\x10\x12\x12\x09\x0A\x05TOTEM\x10\x13\x12\x13\x0A\x0FFIRE_EXTINGUISH\x10\x14*~\x0A\x0CItemCategory\x12\x1E\x0A\x1AITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\x0A\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1B\x0A\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\x0A\x13ITEM_CATEGORY_ITEMS\x10\x03B\x8A\x01\x0A\x0Dcom.df.pluginB\x0BCommonProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" + "\x0A\xB0\x14\x0A\x0Ccommon.proto\x12\x09df.plugin\"0\x0A\x04Vec3\x12\x0C\x0A\x01x\x18\x01 \x01(\x01R\x01x\x12\x0C\x0A\x01y\x18\x02 \x01(\x01R\x01y\x12\x0C\x0A\x01z\x18\x03 \x01(\x01R\x01z\"2\x0A\x08Rotation\x12\x10\x0A\x03yaw\x18\x01 \x01(\x02R\x03yaw\x12\x14\x0A\x05pitch\x18\x02 \x01(\x02R\x05pitch\"L\x0A\x04BBox\x12!\x0A\x03min\x18\x01 \x01(\x0B2\x0F.df.plugin.Vec3R\x03min\x12!\x0A\x03max\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x03max\"4\x0A\x08BlockPos\x12\x0C\x0A\x01x\x18\x01 \x01(\x05R\x01x\x12\x0C\x0A\x01y\x18\x02 \x01(\x05R\x01y\x12\x0C\x0A\x01z\x18\x03 \x01(\x05R\x01z\"I\x0A\x09ItemStack\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x12\x0A\x04meta\x18\x02 \x01(\x05R\x04meta\x12\x14\x0A\x05count\x18\x03 \x01(\x05R\x05count\"\xA6\x01\x0A\x0ABlockState\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12E\x0A\x0Aproperties\x18\x02 \x03(\x0B2%.df.plugin.BlockState.PropertiesEntryR\x0Aproperties\x1A=\x0A\x0FPropertiesEntry\x12\x10\x0A\x03key\x18\x01 \x01(\x09R\x03key\x12\x14\x0A\x05value\x18\x02 \x01(\x09R\x05value:\x028\x01\"\x8B\x01\x0A\x0BLiquidState\x12+\x0A\x05block\x18\x01 \x01(\x0B2\x15.df.plugin.BlockStateR\x05block\x12\x14\x0A\x05depth\x18\x02 \x01(\x05R\x05depth\x12\x18\x0A\x07falling\x18\x03 \x01(\x08R\x07falling\x12\x1F\x0A\x0Bliquid_type\x18\x04 \x01(\x09R\x0AliquidType\"<\x0A\x08WorldRef\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x1C\x0A\x09dimension\x18\x02 \x01(\x09R\x09dimension\"\xD7\x01\x0A\x09EntityRef\x12\x12\x0A\x04uuid\x18\x01 \x01(\x09R\x04uuid\x12\x12\x0A\x04type\x18\x02 \x01(\x09R\x04type\x12\x17\x0A\x04name\x18\x03 \x01(\x09H\x00R\x04name\x88\x01\x01\x120\x0A\x08position\x18\x04 \x01(\x0B2\x0F.df.plugin.Vec3H\x01R\x08position\x88\x01\x01\x124\x0A\x08rotation\x18\x05 \x01(\x0B2\x13.df.plugin.RotationH\x02R\x08rotation\x88\x01\x01B\x07\x0A\x05_nameB\x0B\x0A\x09_positionB\x0B\x0A\x09_rotation\"Y\x0A\x0CDamageSource\x12\x12\x0A\x04type\x18\x01 \x01(\x09R\x04type\x12%\x0A\x0Bdescription\x18\x02 \x01(\x09H\x00R\x0Bdescription\x88\x01\x01B\x0E\x0A\x0C_description\"Z\x0A\x0DHealingSource\x12\x12\x0A\x04type\x18\x01 \x01(\x09R\x04type\x12%\x0A\x0Bdescription\x18\x02 \x01(\x09H\x00R\x0Bdescription\x88\x01\x01B\x0E\x0A\x0C_description\"1\x0A\x07Address\x12\x12\x0A\x04host\x18\x01 \x01(\x09R\x04host\x12\x12\x0A\x04port\x18\x02 \x01(\x05R\x04port\"\xDA\x01\x0A\x14CustomItemDefinition\x12\x0E\x0A\x02id\x18\x01 \x01(\x09R\x02id\x12!\x0A\x0Cdisplay_name\x18\x02 \x01(\x09R\x0BdisplayName\x12!\x0A\x0Ctexture_data\x18\x03 \x01(\x0CR\x0BtextureData\x123\x0A\x08category\x18\x04 \x01(\x0E2\x17.df.plugin.ItemCategoryR\x08category\x12\x19\x0A\x05group\x18\x05 \x01(\x09H\x00R\x05group\x88\x01\x01\x12\x12\x0A\x04meta\x18\x06 \x01(\x05R\x04metaB\x08\x0A\x06_group*D\x0A\x08GameMode\x12\x0C\x0A\x08SURVIVAL\x10\x00\x12\x0C\x0A\x08CREATIVE\x10\x01\x12\x0D\x0A\x09ADVENTURE\x10\x02\x12\x0D\x0A\x09SPECTATOR\x10\x03*:\x0A\x0ADifficulty\x12\x0C\x0A\x08PEACEFUL\x10\x00\x12\x08\x0A\x04EASY\x10\x01\x12\x0A\x0A\x06NORMAL\x10\x02\x12\x08\x0A\x04HARD\x10\x03*\xE2\x03\x0A\x0AEffectType\x12\x12\x0A\x0EEFFECT_UNKNOWN\x10\x00\x12\x09\x0A\x05SPEED\x10\x01\x12\x0C\x0A\x08SLOWNESS\x10\x02\x12\x09\x0A\x05HASTE\x10\x03\x12\x12\x0A\x0EMINING_FATIGUE\x10\x04\x12\x0C\x0A\x08STRENGTH\x10\x05\x12\x12\x0A\x0EINSTANT_HEALTH\x10\x06\x12\x12\x0A\x0EINSTANT_DAMAGE\x10\x07\x12\x0E\x0A\x0AJUMP_BOOST\x10\x08\x12\x0A\x0A\x06NAUSEA\x10\x09\x12\x10\x0A\x0CREGENERATION\x10\x0A\x12\x0E\x0A\x0ARESISTANCE\x10\x0B\x12\x13\x0A\x0FFIRE_RESISTANCE\x10\x0C\x12\x13\x0A\x0FWATER_BREATHING\x10\x0D\x12\x10\x0A\x0CINVISIBILITY\x10\x0E\x12\x0D\x0A\x09BLINDNESS\x10\x0F\x12\x10\x0A\x0CNIGHT_VISION\x10\x10\x12\x0A\x0A\x06HUNGER\x10\x11\x12\x0C\x0A\x08WEAKNESS\x10\x12\x12\x0A\x0A\x06POISON\x10\x13\x12\x0A\x0A\x06WITHER\x10\x14\x12\x10\x0A\x0CHEALTH_BOOST\x10\x15\x12\x0E\x0A\x0AABSORPTION\x10\x16\x12\x0E\x0A\x0ASATURATION\x10\x17\x12\x0E\x0A\x0ALEVITATION\x10\x18\x12\x10\x0A\x0CFATAL_POISON\x10\x19\x12\x11\x0A\x0DCONDUIT_POWER\x10\x1A\x12\x10\x0A\x0CSLOW_FALLING\x10\x1B\x12\x0C\x0A\x08DARKNESS\x10\x1E*\xCD\x02\x0A\x05Sound\x12\x11\x0A\x0DSOUND_UNKNOWN\x10\x00\x12\x0A\x0A\x06ATTACK\x10\x01\x12\x0C\x0A\x08DROWNING\x10\x02\x12\x0B\x0A\x07BURNING\x10\x03\x12\x08\x0A\x04FALL\x10\x04\x12\x08\x0A\x04BURP\x10\x05\x12\x07\x0A\x03POP\x10\x06\x12\x0D\x0A\x09EXPLOSION\x10\x07\x12\x0B\x0A\x07THUNDER\x10\x08\x12\x0C\x0A\x08LEVEL_UP\x10\x09\x12\x0E\x0A\x0AEXPERIENCE\x10\x0A\x12\x13\x0A\x0FFIREWORK_LAUNCH\x10\x0B\x12\x17\x0A\x13FIREWORK_HUGE_BLAST\x10\x0C\x12\x12\x0A\x0EFIREWORK_BLAST\x10\x0D\x12\x14\x0A\x10FIREWORK_TWINKLE\x10\x0E\x12\x0C\x0A\x08TELEPORT\x10\x0F\x12\x0D\x0A\x09ARROW_HIT\x10\x10\x12\x0E\x0A\x0AITEM_BREAK\x10\x11\x12\x0E\x0A\x0AITEM_THROW\x10\x12\x12\x09\x0A\x05TOTEM\x10\x13\x12\x13\x0A\x0FFIRE_EXTINGUISH\x10\x14*~\x0A\x0CItemCategory\x12\x1E\x0A\x1AITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\x0A\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1B\x0A\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\x0A\x13ITEM_CATEGORY_ITEMS\x10\x03B\x8A\x01\x0A\x0Dcom.df.pluginB\x0BCommonProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" , true); static::$is_initialized = true; diff --git a/packages/php/src/generated/Df/Plugin/GPBMetadata/Plugin.php b/packages/php/src/generated/Df/Plugin/GPBMetadata/Plugin.php index 54385f6..e2e98e6 100644 --- a/packages/php/src/generated/Df/Plugin/GPBMetadata/Plugin.php +++ b/packages/php/src/generated/Df/Plugin/GPBMetadata/Plugin.php @@ -22,7 +22,7 @@ public static function initOnce() { \Df\Plugin\GPBMetadata\Mutations::initOnce(); \Df\Plugin\GPBMetadata\Common::initOnce(); $pool->internalAddGeneratedFile( - "\x0A\xE33\x0A\x0Cplugin.proto\x12\x09df.plugin\x1A\x12world_events.proto\x1A\x0Dcommand.proto\x1A\x0Dactions.proto\x1A\x0Fmutations.proto\x1A\x0Ccommon.proto\"\x96\x02\x0A\x0CHostToPlugin\x12\x1B\x0A\x09plugin_id\x18\x01 \x01(\x09R\x08pluginId\x12,\x0A\x05hello\x18\x0A \x01(\x0B2\x14.df.plugin.HostHelloH\x00R\x05hello\x125\x0A\x08shutdown\x18\x0B \x01(\x0B2\x17.df.plugin.HostShutdownH\x00R\x08shutdown\x12G\x0A\x0Bserver_info\x18\x0C \x01(\x0B2\$.df.plugin.ServerInformationResponseH\x00R\x0AserverInfo\x120\x0A\x05event\x18\x14 \x01(\x0B2\x18.df.plugin.EventEnvelopeH\x00R\x05eventB\x09\x0A\x07payload\"\x1A\x0A\x18ServerInformationRequest\"5\x0A\x19ServerInformationResponse\x12\x18\x0A\x07plugins\x18\x01 \x03(\x09R\x07plugins\",\x0A\x09HostHello\x12\x1F\x0A\x0Bapi_version\x18\x01 \x01(\x09R\x0AapiVersion\"&\x0A\x0CHostShutdown\x12\x16\x0A\x06reason\x18\x01 \x01(\x09R\x06reason\"\xE6\x1E\x0A\x0DEventEnvelope\x12\x19\x0A\x08event_id\x18\x01 \x01(\x09R\x07eventId\x12(\x0A\x04type\x18\x02 \x01(\x0E2\x14.df.plugin.EventTypeR\x04type\x12)\x0A\x10expects_response\x18\x03 \x01(\x08R\x0FexpectsResponse\x12=\x0A\x0Bplayer_join\x18\x0A \x01(\x0B2\x1A.df.plugin.PlayerJoinEventH\x00R\x0AplayerJoin\x12=\x0A\x0Bplayer_quit\x18\x0B \x01(\x0B2\x1A.df.plugin.PlayerQuitEventH\x00R\x0AplayerQuit\x12=\x0A\x0Bplayer_move\x18\x0C \x01(\x0B2\x1A.df.plugin.PlayerMoveEventH\x00R\x0AplayerMove\x12=\x0A\x0Bplayer_jump\x18\x0D \x01(\x0B2\x1A.df.plugin.PlayerJumpEventH\x00R\x0AplayerJump\x12I\x0A\x0Fplayer_teleport\x18\x0E \x01(\x0B2\x1E.df.plugin.PlayerTeleportEventH\x00R\x0EplayerTeleport\x12S\x0A\x13player_change_world\x18\x0F \x01(\x0B2!.df.plugin.PlayerChangeWorldEventH\x00R\x11playerChangeWorld\x12V\x0A\x14player_toggle_sprint\x18\x10 \x01(\x0B2\".df.plugin.PlayerToggleSprintEventH\x00R\x12playerToggleSprint\x12S\x0A\x13player_toggle_sneak\x18\x11 \x01(\x0B2!.df.plugin.PlayerToggleSneakEventH\x00R\x11playerToggleSneak\x12*\x0A\x04chat\x18\x12 \x01(\x0B2\x14.df.plugin.ChatEventH\x00R\x04chat\x12J\x0A\x10player_food_loss\x18\x13 \x01(\x0B2\x1E.df.plugin.PlayerFoodLossEventH\x00R\x0EplayerFoodLoss\x12=\x0A\x0Bplayer_heal\x18\x14 \x01(\x0B2\x1A.df.plugin.PlayerHealEventH\x00R\x0AplayerHeal\x12=\x0A\x0Bplayer_hurt\x18\x15 \x01(\x0B2\x1A.df.plugin.PlayerHurtEventH\x00R\x0AplayerHurt\x12@\x0A\x0Cplayer_death\x18\x16 \x01(\x0B2\x1B.df.plugin.PlayerDeathEventH\x00R\x0BplayerDeath\x12F\x0A\x0Eplayer_respawn\x18\x17 \x01(\x0B2\x1D.df.plugin.PlayerRespawnEventH\x00R\x0DplayerRespawn\x12P\x0A\x12player_skin_change\x18\x18 \x01(\x0B2 .df.plugin.PlayerSkinChangeEventH\x00R\x10playerSkinChange\x12\\\x0A\x16player_fire_extinguish\x18\x19 \x01(\x0B2\$.df.plugin.PlayerFireExtinguishEventH\x00R\x14playerFireExtinguish\x12P\x0A\x12player_start_break\x18\x1A \x01(\x0B2 .df.plugin.PlayerStartBreakEventH\x00R\x10playerStartBreak\x12=\x0A\x0Bblock_break\x18\x1B \x01(\x0B2\x1A.df.plugin.BlockBreakEventH\x00R\x0AblockBreak\x12P\x0A\x12player_block_place\x18\x1C \x01(\x0B2 .df.plugin.PlayerBlockPlaceEventH\x00R\x10playerBlockPlace\x12M\x0A\x11player_block_pick\x18\x1D \x01(\x0B2\x1F.df.plugin.PlayerBlockPickEventH\x00R\x0FplayerBlockPick\x12G\x0A\x0Fplayer_item_use\x18\x1E \x01(\x0B2\x1D.df.plugin.PlayerItemUseEventH\x00R\x0DplayerItemUse\x12^\x0A\x18player_item_use_on_block\x18\x1F \x01(\x0B2\$.df.plugin.PlayerItemUseOnBlockEventH\x00R\x14playerItemUseOnBlock\x12a\x0A\x19player_item_use_on_entity\x18 \x01(\x0B2%.df.plugin.PlayerItemUseOnEntityEventH\x00R\x15playerItemUseOnEntity\x12S\x0A\x13player_item_release\x18! \x01(\x0B2!.df.plugin.PlayerItemReleaseEventH\x00R\x11playerItemRelease\x12S\x0A\x13player_item_consume\x18\" \x01(\x0B2!.df.plugin.PlayerItemConsumeEventH\x00R\x11playerItemConsume\x12V\x0A\x14player_attack_entity\x18# \x01(\x0B2\".df.plugin.PlayerAttackEntityEventH\x00R\x12playerAttackEntity\x12\\\x0A\x16player_experience_gain\x18\$ \x01(\x0B2\$.df.plugin.PlayerExperienceGainEventH\x00R\x14playerExperienceGain\x12J\x0A\x10player_punch_air\x18% \x01(\x0B2\x1E.df.plugin.PlayerPunchAirEventH\x00R\x0EplayerPunchAir\x12J\x0A\x10player_sign_edit\x18& \x01(\x0B2\x1E.df.plugin.PlayerSignEditEventH\x00R\x0EplayerSignEdit\x12`\x0A\x18player_lectern_page_turn\x18' \x01(\x0B2%.df.plugin.PlayerLecternPageTurnEventH\x00R\x15playerLecternPageTurn\x12P\x0A\x12player_item_damage\x18( \x01(\x0B2 .df.plugin.PlayerItemDamageEventH\x00R\x10playerItemDamage\x12P\x0A\x12player_item_pickup\x18) \x01(\x0B2 .df.plugin.PlayerItemPickupEventH\x00R\x10playerItemPickup\x12]\x0A\x17player_held_slot_change\x18* \x01(\x0B2\$.df.plugin.PlayerHeldSlotChangeEventH\x00R\x14playerHeldSlotChange\x12J\x0A\x10player_item_drop\x18+ \x01(\x0B2\x1E.df.plugin.PlayerItemDropEventH\x00R\x0EplayerItemDrop\x12I\x0A\x0Fplayer_transfer\x18, \x01(\x0B2\x1E.df.plugin.PlayerTransferEventH\x00R\x0EplayerTransfer\x123\x0A\x07command\x18- \x01(\x0B2\x17.df.plugin.CommandEventH\x00R\x07command\x12R\x0A\x12player_diagnostics\x18. \x01(\x0B2!.df.plugin.PlayerDiagnosticsEventH\x00R\x11playerDiagnostics\x12M\x0A\x11world_liquid_flow\x18F \x01(\x0B2\x1F.df.plugin.WorldLiquidFlowEventH\x00R\x0FworldLiquidFlow\x12P\x0A\x12world_liquid_decay\x18G \x01(\x0B2 .df.plugin.WorldLiquidDecayEventH\x00R\x10worldLiquidDecay\x12S\x0A\x13world_liquid_harden\x18H \x01(\x0B2!.df.plugin.WorldLiquidHardenEventH\x00R\x11worldLiquidHarden\x12=\x0A\x0Bworld_sound\x18I \x01(\x0B2\x1A.df.plugin.WorldSoundEventH\x00R\x0AworldSound\x12M\x0A\x11world_fire_spread\x18J \x01(\x0B2\x1F.df.plugin.WorldFireSpreadEventH\x00R\x0FworldFireSpread\x12J\x0A\x10world_block_burn\x18K \x01(\x0B2\x1E.df.plugin.WorldBlockBurnEventH\x00R\x0EworldBlockBurn\x12P\x0A\x12world_crop_trample\x18L \x01(\x0B2 .df.plugin.WorldCropTrampleEventH\x00R\x10worldCropTrample\x12P\x0A\x12world_leaves_decay\x18M \x01(\x0B2 .df.plugin.WorldLeavesDecayEventH\x00R\x10worldLeavesDecay\x12P\x0A\x12world_entity_spawn\x18N \x01(\x0B2 .df.plugin.WorldEntitySpawnEventH\x00R\x10worldEntitySpawn\x12V\x0A\x14world_entity_despawn\x18O \x01(\x0B2\".df.plugin.WorldEntityDespawnEventH\x00R\x12worldEntityDespawn\x12I\x0A\x0Fworld_explosion\x18P \x01(\x0B2\x1E.df.plugin.WorldExplosionEventH\x00R\x0EworldExplosion\x12=\x0A\x0Bworld_close\x18Q \x01(\x0B2\x1A.df.plugin.WorldCloseEventH\x00R\x0AworldCloseB\x09\x0A\x07payload\"\x85\x03\x0A\x0CPluginToHost\x12\x1B\x0A\x09plugin_id\x18\x01 \x01(\x09R\x08pluginId\x12.\x0A\x05hello\x18\x0A \x01(\x0B2\x16.df.plugin.PluginHelloH\x00R\x05hello\x129\x0A\x09subscribe\x18\x0B \x01(\x0B2\x19.df.plugin.EventSubscribeH\x00R\x09subscribe\x12F\x0A\x0Bserver_info\x18\x0C \x01(\x0B2#.df.plugin.ServerInformationRequestH\x00R\x0AserverInfo\x122\x0A\x07actions\x18\x14 \x01(\x0B2\x16.df.plugin.ActionBatchH\x00R\x07actions\x12)\x0A\x03log\x18\x1E \x01(\x0B2\x15.df.plugin.LogMessageH\x00R\x03log\x12;\x0A\x0Cevent_result\x18( \x01(\x0B2\x16.df.plugin.EventResultH\x00R\x0BeventResultB\x09\x0A\x07payload\"\xD4\x01\x0A\x0BPluginHello\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x18\x0A\x07version\x18\x02 \x01(\x09R\x07version\x12\x1F\x0A\x0Bapi_version\x18\x03 \x01(\x09R\x0AapiVersion\x122\x0A\x08commands\x18\x04 \x03(\x0B2\x16.df.plugin.CommandSpecR\x08commands\x12B\x0A\x0Ccustom_items\x18\x05 \x03(\x0B2\x1F.df.plugin.CustomItemDefinitionR\x0BcustomItems\"<\x0A\x0ALogMessage\x12\x14\x0A\x05level\x18\x01 \x01(\x09R\x05level\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\">\x0A\x0EEventSubscribe\x12,\x0A\x06events\x18\x01 \x03(\x0E2\x14.df.plugin.EventTypeR\x06events*\x8A\x09\x0A\x09EventType\x12\x1A\x0A\x16EVENT_TYPE_UNSPECIFIED\x10\x00\x12\x12\x0A\x0EEVENT_TYPE_ALL\x10\x01\x12\x0F\x0A\x0BPLAYER_JOIN\x10\x0A\x12\x0F\x0A\x0BPLAYER_QUIT\x10\x0B\x12\x0F\x0A\x0BPLAYER_MOVE\x10\x0C\x12\x0F\x0A\x0BPLAYER_JUMP\x10\x0D\x12\x13\x0A\x0FPLAYER_TELEPORT\x10\x0E\x12\x17\x0A\x13PLAYER_CHANGE_WORLD\x10\x0F\x12\x18\x0A\x14PLAYER_TOGGLE_SPRINT\x10\x10\x12\x17\x0A\x13PLAYER_TOGGLE_SNEAK\x10\x11\x12\x08\x0A\x04CHAT\x10\x12\x12\x14\x0A\x10PLAYER_FOOD_LOSS\x10\x13\x12\x0F\x0A\x0BPLAYER_HEAL\x10\x14\x12\x0F\x0A\x0BPLAYER_HURT\x10\x15\x12\x10\x0A\x0CPLAYER_DEATH\x10\x16\x12\x12\x0A\x0EPLAYER_RESPAWN\x10\x17\x12\x16\x0A\x12PLAYER_SKIN_CHANGE\x10\x18\x12\x1A\x0A\x16PLAYER_FIRE_EXTINGUISH\x10\x19\x12\x16\x0A\x12PLAYER_START_BREAK\x10\x1A\x12\x16\x0A\x12PLAYER_BLOCK_BREAK\x10\x1B\x12\x16\x0A\x12PLAYER_BLOCK_PLACE\x10\x1C\x12\x15\x0A\x11PLAYER_BLOCK_PICK\x10\x1D\x12\x13\x0A\x0FPLAYER_ITEM_USE\x10\x1E\x12\x1C\x0A\x18PLAYER_ITEM_USE_ON_BLOCK\x10\x1F\x12\x1D\x0A\x19PLAYER_ITEM_USE_ON_ENTITY\x10 \x12\x17\x0A\x13PLAYER_ITEM_RELEASE\x10!\x12\x17\x0A\x13PLAYER_ITEM_CONSUME\x10\"\x12\x18\x0A\x14PLAYER_ATTACK_ENTITY\x10#\x12\x1A\x0A\x16PLAYER_EXPERIENCE_GAIN\x10\$\x12\x14\x0A\x10PLAYER_PUNCH_AIR\x10%\x12\x14\x0A\x10PLAYER_SIGN_EDIT\x10&\x12\x1C\x0A\x18PLAYER_LECTERN_PAGE_TURN\x10'\x12\x16\x0A\x12PLAYER_ITEM_DAMAGE\x10(\x12\x16\x0A\x12PLAYER_ITEM_PICKUP\x10)\x12\x1B\x0A\x17PLAYER_HELD_SLOT_CHANGE\x10*\x12\x14\x0A\x10PLAYER_ITEM_DROP\x10+\x12\x13\x0A\x0FPLAYER_TRANSFER\x10,\x12\x0B\x0A\x07COMMAND\x10-\x12\x16\x0A\x12PLAYER_DIAGNOSTICS\x10.\x12\x15\x0A\x11WORLD_LIQUID_FLOW\x10F\x12\x16\x0A\x12WORLD_LIQUID_DECAY\x10G\x12\x17\x0A\x13WORLD_LIQUID_HARDEN\x10H\x12\x0F\x0A\x0BWORLD_SOUND\x10I\x12\x15\x0A\x11WORLD_FIRE_SPREAD\x10J\x12\x14\x0A\x10WORLD_BLOCK_BURN\x10K\x12\x16\x0A\x12WORLD_CROP_TRAMPLE\x10L\x12\x16\x0A\x12WORLD_LEAVES_DECAY\x10M\x12\x16\x0A\x12WORLD_ENTITY_SPAWN\x10N\x12\x18\x0A\x14WORLD_ENTITY_DESPAWN\x10O\x12\x13\x0A\x0FWORLD_EXPLOSION\x10P\x12\x0F\x0A\x0BWORLD_CLOSE\x10Q2M\x0A\x06Plugin\x12C\x0A\x0BEventStream\x12\x17.df.plugin.PluginToHost\x1A\x17.df.plugin.HostToPlugin(\x010\x01B\x8A\x01\x0A\x0Dcom.df.pluginB\x0BPluginProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" + "\x0A\xA34\x0A\x0Cplugin.proto\x12\x09df.plugin\x1A\x12world_events.proto\x1A\x0Dcommand.proto\x1A\x0Dactions.proto\x1A\x0Fmutations.proto\x1A\x0Ccommon.proto\"\xD6\x02\x0A\x0CHostToPlugin\x12\x1B\x0A\x09plugin_id\x18\x01 \x01(\x09R\x08pluginId\x12,\x0A\x05hello\x18\x0A \x01(\x0B2\x14.df.plugin.HostHelloH\x00R\x05hello\x125\x0A\x08shutdown\x18\x0B \x01(\x0B2\x17.df.plugin.HostShutdownH\x00R\x08shutdown\x12G\x0A\x0Bserver_info\x18\x0C \x01(\x0B2\$.df.plugin.ServerInformationResponseH\x00R\x0AserverInfo\x120\x0A\x05event\x18\x14 \x01(\x0B2\x18.df.plugin.EventEnvelopeH\x00R\x05event\x12>\x0A\x0Daction_result\x18\x15 \x01(\x0B2\x17.df.plugin.ActionResultH\x00R\x0CactionResultB\x09\x0A\x07payload\"\x1A\x0A\x18ServerInformationRequest\"5\x0A\x19ServerInformationResponse\x12\x18\x0A\x07plugins\x18\x01 \x03(\x09R\x07plugins\",\x0A\x09HostHello\x12\x1F\x0A\x0Bapi_version\x18\x01 \x01(\x09R\x0AapiVersion\"&\x0A\x0CHostShutdown\x12\x16\x0A\x06reason\x18\x01 \x01(\x09R\x06reason\"\xE6\x1E\x0A\x0DEventEnvelope\x12\x19\x0A\x08event_id\x18\x01 \x01(\x09R\x07eventId\x12(\x0A\x04type\x18\x02 \x01(\x0E2\x14.df.plugin.EventTypeR\x04type\x12)\x0A\x10expects_response\x18\x03 \x01(\x08R\x0FexpectsResponse\x12=\x0A\x0Bplayer_join\x18\x0A \x01(\x0B2\x1A.df.plugin.PlayerJoinEventH\x00R\x0AplayerJoin\x12=\x0A\x0Bplayer_quit\x18\x0B \x01(\x0B2\x1A.df.plugin.PlayerQuitEventH\x00R\x0AplayerQuit\x12=\x0A\x0Bplayer_move\x18\x0C \x01(\x0B2\x1A.df.plugin.PlayerMoveEventH\x00R\x0AplayerMove\x12=\x0A\x0Bplayer_jump\x18\x0D \x01(\x0B2\x1A.df.plugin.PlayerJumpEventH\x00R\x0AplayerJump\x12I\x0A\x0Fplayer_teleport\x18\x0E \x01(\x0B2\x1E.df.plugin.PlayerTeleportEventH\x00R\x0EplayerTeleport\x12S\x0A\x13player_change_world\x18\x0F \x01(\x0B2!.df.plugin.PlayerChangeWorldEventH\x00R\x11playerChangeWorld\x12V\x0A\x14player_toggle_sprint\x18\x10 \x01(\x0B2\".df.plugin.PlayerToggleSprintEventH\x00R\x12playerToggleSprint\x12S\x0A\x13player_toggle_sneak\x18\x11 \x01(\x0B2!.df.plugin.PlayerToggleSneakEventH\x00R\x11playerToggleSneak\x12*\x0A\x04chat\x18\x12 \x01(\x0B2\x14.df.plugin.ChatEventH\x00R\x04chat\x12J\x0A\x10player_food_loss\x18\x13 \x01(\x0B2\x1E.df.plugin.PlayerFoodLossEventH\x00R\x0EplayerFoodLoss\x12=\x0A\x0Bplayer_heal\x18\x14 \x01(\x0B2\x1A.df.plugin.PlayerHealEventH\x00R\x0AplayerHeal\x12=\x0A\x0Bplayer_hurt\x18\x15 \x01(\x0B2\x1A.df.plugin.PlayerHurtEventH\x00R\x0AplayerHurt\x12@\x0A\x0Cplayer_death\x18\x16 \x01(\x0B2\x1B.df.plugin.PlayerDeathEventH\x00R\x0BplayerDeath\x12F\x0A\x0Eplayer_respawn\x18\x17 \x01(\x0B2\x1D.df.plugin.PlayerRespawnEventH\x00R\x0DplayerRespawn\x12P\x0A\x12player_skin_change\x18\x18 \x01(\x0B2 .df.plugin.PlayerSkinChangeEventH\x00R\x10playerSkinChange\x12\\\x0A\x16player_fire_extinguish\x18\x19 \x01(\x0B2\$.df.plugin.PlayerFireExtinguishEventH\x00R\x14playerFireExtinguish\x12P\x0A\x12player_start_break\x18\x1A \x01(\x0B2 .df.plugin.PlayerStartBreakEventH\x00R\x10playerStartBreak\x12=\x0A\x0Bblock_break\x18\x1B \x01(\x0B2\x1A.df.plugin.BlockBreakEventH\x00R\x0AblockBreak\x12P\x0A\x12player_block_place\x18\x1C \x01(\x0B2 .df.plugin.PlayerBlockPlaceEventH\x00R\x10playerBlockPlace\x12M\x0A\x11player_block_pick\x18\x1D \x01(\x0B2\x1F.df.plugin.PlayerBlockPickEventH\x00R\x0FplayerBlockPick\x12G\x0A\x0Fplayer_item_use\x18\x1E \x01(\x0B2\x1D.df.plugin.PlayerItemUseEventH\x00R\x0DplayerItemUse\x12^\x0A\x18player_item_use_on_block\x18\x1F \x01(\x0B2\$.df.plugin.PlayerItemUseOnBlockEventH\x00R\x14playerItemUseOnBlock\x12a\x0A\x19player_item_use_on_entity\x18 \x01(\x0B2%.df.plugin.PlayerItemUseOnEntityEventH\x00R\x15playerItemUseOnEntity\x12S\x0A\x13player_item_release\x18! \x01(\x0B2!.df.plugin.PlayerItemReleaseEventH\x00R\x11playerItemRelease\x12S\x0A\x13player_item_consume\x18\" \x01(\x0B2!.df.plugin.PlayerItemConsumeEventH\x00R\x11playerItemConsume\x12V\x0A\x14player_attack_entity\x18# \x01(\x0B2\".df.plugin.PlayerAttackEntityEventH\x00R\x12playerAttackEntity\x12\\\x0A\x16player_experience_gain\x18\$ \x01(\x0B2\$.df.plugin.PlayerExperienceGainEventH\x00R\x14playerExperienceGain\x12J\x0A\x10player_punch_air\x18% \x01(\x0B2\x1E.df.plugin.PlayerPunchAirEventH\x00R\x0EplayerPunchAir\x12J\x0A\x10player_sign_edit\x18& \x01(\x0B2\x1E.df.plugin.PlayerSignEditEventH\x00R\x0EplayerSignEdit\x12`\x0A\x18player_lectern_page_turn\x18' \x01(\x0B2%.df.plugin.PlayerLecternPageTurnEventH\x00R\x15playerLecternPageTurn\x12P\x0A\x12player_item_damage\x18( \x01(\x0B2 .df.plugin.PlayerItemDamageEventH\x00R\x10playerItemDamage\x12P\x0A\x12player_item_pickup\x18) \x01(\x0B2 .df.plugin.PlayerItemPickupEventH\x00R\x10playerItemPickup\x12]\x0A\x17player_held_slot_change\x18* \x01(\x0B2\$.df.plugin.PlayerHeldSlotChangeEventH\x00R\x14playerHeldSlotChange\x12J\x0A\x10player_item_drop\x18+ \x01(\x0B2\x1E.df.plugin.PlayerItemDropEventH\x00R\x0EplayerItemDrop\x12I\x0A\x0Fplayer_transfer\x18, \x01(\x0B2\x1E.df.plugin.PlayerTransferEventH\x00R\x0EplayerTransfer\x123\x0A\x07command\x18- \x01(\x0B2\x17.df.plugin.CommandEventH\x00R\x07command\x12R\x0A\x12player_diagnostics\x18. \x01(\x0B2!.df.plugin.PlayerDiagnosticsEventH\x00R\x11playerDiagnostics\x12M\x0A\x11world_liquid_flow\x18F \x01(\x0B2\x1F.df.plugin.WorldLiquidFlowEventH\x00R\x0FworldLiquidFlow\x12P\x0A\x12world_liquid_decay\x18G \x01(\x0B2 .df.plugin.WorldLiquidDecayEventH\x00R\x10worldLiquidDecay\x12S\x0A\x13world_liquid_harden\x18H \x01(\x0B2!.df.plugin.WorldLiquidHardenEventH\x00R\x11worldLiquidHarden\x12=\x0A\x0Bworld_sound\x18I \x01(\x0B2\x1A.df.plugin.WorldSoundEventH\x00R\x0AworldSound\x12M\x0A\x11world_fire_spread\x18J \x01(\x0B2\x1F.df.plugin.WorldFireSpreadEventH\x00R\x0FworldFireSpread\x12J\x0A\x10world_block_burn\x18K \x01(\x0B2\x1E.df.plugin.WorldBlockBurnEventH\x00R\x0EworldBlockBurn\x12P\x0A\x12world_crop_trample\x18L \x01(\x0B2 .df.plugin.WorldCropTrampleEventH\x00R\x10worldCropTrample\x12P\x0A\x12world_leaves_decay\x18M \x01(\x0B2 .df.plugin.WorldLeavesDecayEventH\x00R\x10worldLeavesDecay\x12P\x0A\x12world_entity_spawn\x18N \x01(\x0B2 .df.plugin.WorldEntitySpawnEventH\x00R\x10worldEntitySpawn\x12V\x0A\x14world_entity_despawn\x18O \x01(\x0B2\".df.plugin.WorldEntityDespawnEventH\x00R\x12worldEntityDespawn\x12I\x0A\x0Fworld_explosion\x18P \x01(\x0B2\x1E.df.plugin.WorldExplosionEventH\x00R\x0EworldExplosion\x12=\x0A\x0Bworld_close\x18Q \x01(\x0B2\x1A.df.plugin.WorldCloseEventH\x00R\x0AworldCloseB\x09\x0A\x07payload\"\x85\x03\x0A\x0CPluginToHost\x12\x1B\x0A\x09plugin_id\x18\x01 \x01(\x09R\x08pluginId\x12.\x0A\x05hello\x18\x0A \x01(\x0B2\x16.df.plugin.PluginHelloH\x00R\x05hello\x129\x0A\x09subscribe\x18\x0B \x01(\x0B2\x19.df.plugin.EventSubscribeH\x00R\x09subscribe\x12F\x0A\x0Bserver_info\x18\x0C \x01(\x0B2#.df.plugin.ServerInformationRequestH\x00R\x0AserverInfo\x122\x0A\x07actions\x18\x14 \x01(\x0B2\x16.df.plugin.ActionBatchH\x00R\x07actions\x12)\x0A\x03log\x18\x1E \x01(\x0B2\x15.df.plugin.LogMessageH\x00R\x03log\x12;\x0A\x0Cevent_result\x18( \x01(\x0B2\x16.df.plugin.EventResultH\x00R\x0BeventResultB\x09\x0A\x07payload\"\xD4\x01\x0A\x0BPluginHello\x12\x12\x0A\x04name\x18\x01 \x01(\x09R\x04name\x12\x18\x0A\x07version\x18\x02 \x01(\x09R\x07version\x12\x1F\x0A\x0Bapi_version\x18\x03 \x01(\x09R\x0AapiVersion\x122\x0A\x08commands\x18\x04 \x03(\x0B2\x16.df.plugin.CommandSpecR\x08commands\x12B\x0A\x0Ccustom_items\x18\x05 \x03(\x0B2\x1F.df.plugin.CustomItemDefinitionR\x0BcustomItems\"<\x0A\x0ALogMessage\x12\x14\x0A\x05level\x18\x01 \x01(\x09R\x05level\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\">\x0A\x0EEventSubscribe\x12,\x0A\x06events\x18\x01 \x03(\x0E2\x14.df.plugin.EventTypeR\x06events*\x8A\x09\x0A\x09EventType\x12\x1A\x0A\x16EVENT_TYPE_UNSPECIFIED\x10\x00\x12\x12\x0A\x0EEVENT_TYPE_ALL\x10\x01\x12\x0F\x0A\x0BPLAYER_JOIN\x10\x0A\x12\x0F\x0A\x0BPLAYER_QUIT\x10\x0B\x12\x0F\x0A\x0BPLAYER_MOVE\x10\x0C\x12\x0F\x0A\x0BPLAYER_JUMP\x10\x0D\x12\x13\x0A\x0FPLAYER_TELEPORT\x10\x0E\x12\x17\x0A\x13PLAYER_CHANGE_WORLD\x10\x0F\x12\x18\x0A\x14PLAYER_TOGGLE_SPRINT\x10\x10\x12\x17\x0A\x13PLAYER_TOGGLE_SNEAK\x10\x11\x12\x08\x0A\x04CHAT\x10\x12\x12\x14\x0A\x10PLAYER_FOOD_LOSS\x10\x13\x12\x0F\x0A\x0BPLAYER_HEAL\x10\x14\x12\x0F\x0A\x0BPLAYER_HURT\x10\x15\x12\x10\x0A\x0CPLAYER_DEATH\x10\x16\x12\x12\x0A\x0EPLAYER_RESPAWN\x10\x17\x12\x16\x0A\x12PLAYER_SKIN_CHANGE\x10\x18\x12\x1A\x0A\x16PLAYER_FIRE_EXTINGUISH\x10\x19\x12\x16\x0A\x12PLAYER_START_BREAK\x10\x1A\x12\x16\x0A\x12PLAYER_BLOCK_BREAK\x10\x1B\x12\x16\x0A\x12PLAYER_BLOCK_PLACE\x10\x1C\x12\x15\x0A\x11PLAYER_BLOCK_PICK\x10\x1D\x12\x13\x0A\x0FPLAYER_ITEM_USE\x10\x1E\x12\x1C\x0A\x18PLAYER_ITEM_USE_ON_BLOCK\x10\x1F\x12\x1D\x0A\x19PLAYER_ITEM_USE_ON_ENTITY\x10 \x12\x17\x0A\x13PLAYER_ITEM_RELEASE\x10!\x12\x17\x0A\x13PLAYER_ITEM_CONSUME\x10\"\x12\x18\x0A\x14PLAYER_ATTACK_ENTITY\x10#\x12\x1A\x0A\x16PLAYER_EXPERIENCE_GAIN\x10\$\x12\x14\x0A\x10PLAYER_PUNCH_AIR\x10%\x12\x14\x0A\x10PLAYER_SIGN_EDIT\x10&\x12\x1C\x0A\x18PLAYER_LECTERN_PAGE_TURN\x10'\x12\x16\x0A\x12PLAYER_ITEM_DAMAGE\x10(\x12\x16\x0A\x12PLAYER_ITEM_PICKUP\x10)\x12\x1B\x0A\x17PLAYER_HELD_SLOT_CHANGE\x10*\x12\x14\x0A\x10PLAYER_ITEM_DROP\x10+\x12\x13\x0A\x0FPLAYER_TRANSFER\x10,\x12\x0B\x0A\x07COMMAND\x10-\x12\x16\x0A\x12PLAYER_DIAGNOSTICS\x10.\x12\x15\x0A\x11WORLD_LIQUID_FLOW\x10F\x12\x16\x0A\x12WORLD_LIQUID_DECAY\x10G\x12\x17\x0A\x13WORLD_LIQUID_HARDEN\x10H\x12\x0F\x0A\x0BWORLD_SOUND\x10I\x12\x15\x0A\x11WORLD_FIRE_SPREAD\x10J\x12\x14\x0A\x10WORLD_BLOCK_BURN\x10K\x12\x16\x0A\x12WORLD_CROP_TRAMPLE\x10L\x12\x16\x0A\x12WORLD_LEAVES_DECAY\x10M\x12\x16\x0A\x12WORLD_ENTITY_SPAWN\x10N\x12\x18\x0A\x14WORLD_ENTITY_DESPAWN\x10O\x12\x13\x0A\x0FWORLD_EXPLOSION\x10P\x12\x0F\x0A\x0BWORLD_CLOSE\x10Q2M\x0A\x06Plugin\x12C\x0A\x0BEventStream\x12\x17.df.plugin.PluginToHost\x1A\x17.df.plugin.HostToPlugin(\x010\x01B\x8A\x01\x0A\x0Dcom.df.pluginB\x0BPluginProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" , true); static::$is_initialized = true; diff --git a/packages/php/src/generated/Df/Plugin/HostToPlugin.php b/packages/php/src/generated/Df/Plugin/HostToPlugin.php index a4b0482..b35d680 100644 --- a/packages/php/src/generated/Df/Plugin/HostToPlugin.php +++ b/packages/php/src/generated/Df/Plugin/HostToPlugin.php @@ -31,6 +31,7 @@ class HostToPlugin extends \Google\Protobuf\Internal\Message * @type \Df\Plugin\HostShutdown $shutdown * @type \Df\Plugin\ServerInformationResponse $server_info * @type \Df\Plugin\EventEnvelope $event + * @type \Df\Plugin\ActionResult $action_result * } */ public function __construct($data = NULL) { @@ -168,6 +169,33 @@ public function setEvent($var) return $this; } + /** + * Generated from protobuf field .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; + * @return \Df\Plugin\ActionResult|null + */ + public function getActionResult() + { + return $this->readOneof(21); + } + + public function hasActionResult() + { + return $this->hasOneof(21); + } + + /** + * Generated from protobuf field .df.plugin.ActionResult action_result = 21 [json_name = "actionResult"]; + * @param \Df\Plugin\ActionResult $var + * @return $this + */ + public function setActionResult($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\ActionResult::class); + $this->writeOneof(21, $var); + + return $this; + } + /** * @return string */ diff --git a/packages/php/src/generated/Df/Plugin/ParticleType.php b/packages/php/src/generated/Df/Plugin/ParticleType.php new file mode 100644 index 0000000..4a7c2e7 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/ParticleType.php @@ -0,0 +1,134 @@ +df.plugin.ParticleType + */ +class ParticleType +{ + /** + * Generated from protobuf enum PARTICLE_TYPE_UNSPECIFIED = 0; + */ + const PARTICLE_TYPE_UNSPECIFIED = 0; + /** + * Generated from protobuf enum PARTICLE_HUGE_EXPLOSION = 1; + */ + const PARTICLE_HUGE_EXPLOSION = 1; + /** + * Generated from protobuf enum PARTICLE_ENDERMAN_TELEPORT = 2; + */ + const PARTICLE_ENDERMAN_TELEPORT = 2; + /** + * Generated from protobuf enum PARTICLE_SNOWBALL_POOF = 3; + */ + const PARTICLE_SNOWBALL_POOF = 3; + /** + * Generated from protobuf enum PARTICLE_EGG_SMASH = 4; + */ + const PARTICLE_EGG_SMASH = 4; + /** + * Generated from protobuf enum PARTICLE_SPLASH = 5; + */ + const PARTICLE_SPLASH = 5; + /** + * Generated from protobuf enum PARTICLE_EFFECT = 6; + */ + const PARTICLE_EFFECT = 6; + /** + * Generated from protobuf enum PARTICLE_ENTITY_FLAME = 7; + */ + const PARTICLE_ENTITY_FLAME = 7; + /** + * Generated from protobuf enum PARTICLE_FLAME = 8; + */ + const PARTICLE_FLAME = 8; + /** + * Generated from protobuf enum PARTICLE_DUST = 9; + */ + const PARTICLE_DUST = 9; + /** + * Generated from protobuf enum PARTICLE_BLOCK_FORCE_FIELD = 10; + */ + const PARTICLE_BLOCK_FORCE_FIELD = 10; + /** + * Generated from protobuf enum PARTICLE_BONE_MEAL = 11; + */ + const PARTICLE_BONE_MEAL = 11; + /** + * Generated from protobuf enum PARTICLE_EVAPORATE = 12; + */ + const PARTICLE_EVAPORATE = 12; + /** + * Generated from protobuf enum PARTICLE_WATER_DRIP = 13; + */ + const PARTICLE_WATER_DRIP = 13; + /** + * Generated from protobuf enum PARTICLE_LAVA_DRIP = 14; + */ + const PARTICLE_LAVA_DRIP = 14; + /** + * Generated from protobuf enum PARTICLE_LAVA = 15; + */ + const PARTICLE_LAVA = 15; + /** + * Generated from protobuf enum PARTICLE_DUST_PLUME = 16; + */ + const PARTICLE_DUST_PLUME = 16; + /** + * Generated from protobuf enum PARTICLE_BLOCK_BREAK = 17; + */ + const PARTICLE_BLOCK_BREAK = 17; + /** + * Generated from protobuf enum PARTICLE_PUNCH_BLOCK = 18; + */ + const PARTICLE_PUNCH_BLOCK = 18; + + private static $valueToName = [ + self::PARTICLE_TYPE_UNSPECIFIED => 'PARTICLE_TYPE_UNSPECIFIED', + self::PARTICLE_HUGE_EXPLOSION => 'PARTICLE_HUGE_EXPLOSION', + self::PARTICLE_ENDERMAN_TELEPORT => 'PARTICLE_ENDERMAN_TELEPORT', + self::PARTICLE_SNOWBALL_POOF => 'PARTICLE_SNOWBALL_POOF', + self::PARTICLE_EGG_SMASH => 'PARTICLE_EGG_SMASH', + self::PARTICLE_SPLASH => 'PARTICLE_SPLASH', + self::PARTICLE_EFFECT => 'PARTICLE_EFFECT', + self::PARTICLE_ENTITY_FLAME => 'PARTICLE_ENTITY_FLAME', + self::PARTICLE_FLAME => 'PARTICLE_FLAME', + self::PARTICLE_DUST => 'PARTICLE_DUST', + self::PARTICLE_BLOCK_FORCE_FIELD => 'PARTICLE_BLOCK_FORCE_FIELD', + self::PARTICLE_BONE_MEAL => 'PARTICLE_BONE_MEAL', + self::PARTICLE_EVAPORATE => 'PARTICLE_EVAPORATE', + self::PARTICLE_WATER_DRIP => 'PARTICLE_WATER_DRIP', + self::PARTICLE_LAVA_DRIP => 'PARTICLE_LAVA_DRIP', + self::PARTICLE_LAVA => 'PARTICLE_LAVA', + self::PARTICLE_DUST_PLUME => 'PARTICLE_DUST_PLUME', + self::PARTICLE_BLOCK_BREAK => 'PARTICLE_BLOCK_BREAK', + self::PARTICLE_PUNCH_BLOCK => 'PARTICLE_PUNCH_BLOCK', + ]; + + public static function name($value) + { + if (!isset(self::$valueToName[$value])) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no name defined for value %s', __CLASS__, $value)); + } + return self::$valueToName[$value]; + } + + + public static function value($name) + { + $const = __CLASS__ . '::' . strtoupper($name); + if (!defined($const)) { + throw new UnexpectedValueException(sprintf( + 'Enum %s has no value defined for name %s', __CLASS__, $name)); + } + return constant($const); + } +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldAddParticleAction.php b/packages/php/src/generated/Df/Plugin/WorldAddParticleAction.php new file mode 100644 index 0000000..60cfdc9 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldAddParticleAction.php @@ -0,0 +1,221 @@ +df.plugin.WorldAddParticleAction + */ +class WorldAddParticleAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + */ + protected $position = null; + /** + * Generated from protobuf field .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + */ + protected $particle = 0; + /** + * used for block-based particles when provided + * + * Generated from protobuf field optional .df.plugin.BlockState block = 4 [json_name = "block"]; + */ + protected $block = null; + /** + * used for punch_block when provided + * + * Generated from protobuf field optional int32 face = 5 [json_name = "face"]; + */ + protected $face = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\Vec3 $position + * @type int $particle + * @type \Df\Plugin\BlockState $block + * used for block-based particles when provided + * @type int $face + * used for punch_block when provided + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @return \Df\Plugin\Vec3|null + */ + public function getPosition() + { + return $this->position; + } + + public function hasPosition() + { + return isset($this->position); + } + + public function clearPosition() + { + unset($this->position); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setPosition($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->position = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + * @return int + */ + public function getParticle() + { + return $this->particle; + } + + /** + * Generated from protobuf field .df.plugin.ParticleType particle = 3 [json_name = "particle"]; + * @param int $var + * @return $this + */ + public function setParticle($var) + { + GPBUtil::checkEnum($var, \Df\Plugin\ParticleType::class); + $this->particle = $var; + + return $this; + } + + /** + * used for block-based particles when provided + * + * Generated from protobuf field optional .df.plugin.BlockState block = 4 [json_name = "block"]; + * @return \Df\Plugin\BlockState|null + */ + public function getBlock() + { + return $this->block; + } + + public function hasBlock() + { + return isset($this->block); + } + + public function clearBlock() + { + unset($this->block); + } + + /** + * used for block-based particles when provided + * + * Generated from protobuf field optional .df.plugin.BlockState block = 4 [json_name = "block"]; + * @param \Df\Plugin\BlockState $var + * @return $this + */ + public function setBlock($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\BlockState::class); + $this->block = $var; + + return $this; + } + + /** + * used for punch_block when provided + * + * Generated from protobuf field optional int32 face = 5 [json_name = "face"]; + * @return int + */ + public function getFace() + { + return isset($this->face) ? $this->face : 0; + } + + public function hasFace() + { + return isset($this->face); + } + + public function clearFace() + { + unset($this->face); + } + + /** + * used for punch_block when provided + * + * Generated from protobuf field optional int32 face = 5 [json_name = "face"]; + * @param int $var + * @return $this + */ + public function setFace($var) + { + GPBUtil::checkInt32($var); + $this->face = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldEntitiesResult.php b/packages/php/src/generated/Df/Plugin/WorldEntitiesResult.php new file mode 100644 index 0000000..48c7808 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldEntitiesResult.php @@ -0,0 +1,96 @@ +df.plugin.WorldEntitiesResult + */ +class WorldEntitiesResult extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + */ + private $entities; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\EntityRef[] $entities + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + * @return RepeatedField<\Df\Plugin\EntityRef> + */ + public function getEntities() + { + return $this->entities; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + * @param \Df\Plugin\EntityRef[] $var + * @return $this + */ + public function setEntities($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Df\Plugin\EntityRef::class); + $this->entities = $arr; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldEntitiesWithinResult.php b/packages/php/src/generated/Df/Plugin/WorldEntitiesWithinResult.php new file mode 100644 index 0000000..69187ab --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldEntitiesWithinResult.php @@ -0,0 +1,133 @@ +df.plugin.WorldEntitiesWithinResult + */ +class WorldEntitiesWithinResult extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + */ + protected $box = null; + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + */ + private $entities; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\BBox $box + * @type \Df\Plugin\EntityRef[] $entities + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + * @return \Df\Plugin\BBox|null + */ + public function getBox() + { + return $this->box; + } + + public function hasBox() + { + return isset($this->box); + } + + public function clearBox() + { + unset($this->box); + } + + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + * @param \Df\Plugin\BBox $var + * @return $this + */ + public function setBox($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\BBox::class); + $this->box = $var; + + return $this; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + * @return RepeatedField<\Df\Plugin\EntityRef> + */ + public function getEntities() + { + return $this->entities; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + * @param \Df\Plugin\EntityRef[] $var + * @return $this + */ + public function setEntities($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Df\Plugin\EntityRef::class); + $this->entities = $arr; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldPlaySoundAction.php b/packages/php/src/generated/Df/Plugin/WorldPlaySoundAction.php new file mode 100644 index 0000000..2c8a99a --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldPlaySoundAction.php @@ -0,0 +1,133 @@ +df.plugin.WorldPlaySoundAction + */ +class WorldPlaySoundAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.Sound sound = 2 [json_name = "sound"]; + */ + protected $sound = 0; + /** + * Generated from protobuf field .df.plugin.Vec3 position = 3 [json_name = "position"]; + */ + protected $position = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type int $sound + * @type \Df\Plugin\Vec3 $position + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Sound sound = 2 [json_name = "sound"]; + * @return int + */ + public function getSound() + { + return $this->sound; + } + + /** + * Generated from protobuf field .df.plugin.Sound sound = 2 [json_name = "sound"]; + * @param int $var + * @return $this + */ + public function setSound($var) + { + GPBUtil::checkEnum($var, \Df\Plugin\Sound::class); + $this->sound = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 3 [json_name = "position"]; + * @return \Df\Plugin\Vec3|null + */ + public function getPosition() + { + return $this->position; + } + + public function hasPosition() + { + return isset($this->position); + } + + public function clearPosition() + { + unset($this->position); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 3 [json_name = "position"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setPosition($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->position = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldPlayersResult.php b/packages/php/src/generated/Df/Plugin/WorldPlayersResult.php new file mode 100644 index 0000000..cfc5bc5 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldPlayersResult.php @@ -0,0 +1,96 @@ +df.plugin.WorldPlayersResult + */ +class WorldPlayersResult extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + */ + private $players; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\EntityRef[] $players + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + * @return RepeatedField<\Df\Plugin\EntityRef> + */ + public function getPlayers() + { + return $this->players; + } + + /** + * Generated from protobuf field repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + * @param \Df\Plugin\EntityRef[] $var + * @return $this + */ + public function setPlayers($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Df\Plugin\EntityRef::class); + $this->players = $arr; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesAction.php b/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesAction.php new file mode 100644 index 0000000..3b888ef --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesAction.php @@ -0,0 +1,69 @@ +df.plugin.WorldQueryEntitiesAction + */ +class WorldQueryEntitiesAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesWithinAction.php b/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesWithinAction.php new file mode 100644 index 0000000..86b592f --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldQueryEntitiesWithinAction.php @@ -0,0 +1,106 @@ +df.plugin.WorldQueryEntitiesWithinAction + */ +class WorldQueryEntitiesWithinAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + */ + protected $box = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\BBox $box + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + * @return \Df\Plugin\BBox|null + */ + public function getBox() + { + return $this->box; + } + + public function hasBox() + { + return isset($this->box); + } + + public function clearBox() + { + unset($this->box); + } + + /** + * Generated from protobuf field .df.plugin.BBox box = 2 [json_name = "box"]; + * @param \Df\Plugin\BBox $var + * @return $this + */ + public function setBox($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\BBox::class); + $this->box = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldQueryPlayersAction.php b/packages/php/src/generated/Df/Plugin/WorldQueryPlayersAction.php new file mode 100644 index 0000000..fc7428a --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldQueryPlayersAction.php @@ -0,0 +1,69 @@ +df.plugin.WorldQueryPlayersAction + */ +class WorldQueryPlayersAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldQueryViewersAction.php b/packages/php/src/generated/Df/Plugin/WorldQueryViewersAction.php new file mode 100644 index 0000000..188f282 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldQueryViewersAction.php @@ -0,0 +1,106 @@ +df.plugin.WorldQueryViewersAction + */ +class WorldQueryViewersAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + */ + protected $position = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\Vec3 $position + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @return \Df\Plugin\Vec3|null + */ + public function getPosition() + { + return $this->position; + } + + public function hasPosition() + { + return isset($this->position); + } + + public function clearPosition() + { + unset($this->position); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setPosition($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->position = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldSetBlockAction.php b/packages/php/src/generated/Df/Plugin/WorldSetBlockAction.php new file mode 100644 index 0000000..b646ace --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldSetBlockAction.php @@ -0,0 +1,150 @@ +df.plugin.WorldSetBlockAction + */ +class WorldSetBlockAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.BlockPos position = 2 [json_name = "position"]; + */ + protected $position = null; + /** + * nil clears to air + * + * Generated from protobuf field optional .df.plugin.BlockState block = 3 [json_name = "block"]; + */ + protected $block = null; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\BlockPos $position + * @type \Df\Plugin\BlockState $block + * nil clears to air + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.BlockPos position = 2 [json_name = "position"]; + * @return \Df\Plugin\BlockPos|null + */ + public function getPosition() + { + return $this->position; + } + + public function hasPosition() + { + return isset($this->position); + } + + public function clearPosition() + { + unset($this->position); + } + + /** + * Generated from protobuf field .df.plugin.BlockPos position = 2 [json_name = "position"]; + * @param \Df\Plugin\BlockPos $var + * @return $this + */ + public function setPosition($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\BlockPos::class); + $this->position = $var; + + return $this; + } + + /** + * nil clears to air + * + * Generated from protobuf field optional .df.plugin.BlockState block = 3 [json_name = "block"]; + * @return \Df\Plugin\BlockState|null + */ + public function getBlock() + { + return $this->block; + } + + public function hasBlock() + { + return isset($this->block); + } + + public function clearBlock() + { + unset($this->block); + } + + /** + * nil clears to air + * + * Generated from protobuf field optional .df.plugin.BlockState block = 3 [json_name = "block"]; + * @param \Df\Plugin\BlockState $var + * @return $this + */ + public function setBlock($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\BlockState::class); + $this->block = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldSetDefaultGameModeAction.php b/packages/php/src/generated/Df/Plugin/WorldSetDefaultGameModeAction.php new file mode 100644 index 0000000..006a224 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldSetDefaultGameModeAction.php @@ -0,0 +1,96 @@ +df.plugin.WorldSetDefaultGameModeAction + */ +class WorldSetDefaultGameModeAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + */ + protected $game_mode = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type int $game_mode + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + * @return int + */ + public function getGameMode() + { + return $this->game_mode; + } + + /** + * Generated from protobuf field .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + * @param int $var + * @return $this + */ + public function setGameMode($var) + { + GPBUtil::checkEnum($var, \Df\Plugin\GameMode::class); + $this->game_mode = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldSetDifficultyAction.php b/packages/php/src/generated/Df/Plugin/WorldSetDifficultyAction.php new file mode 100644 index 0000000..8460e27 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldSetDifficultyAction.php @@ -0,0 +1,96 @@ +df.plugin.WorldSetDifficultyAction + */ +class WorldSetDifficultyAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + */ + protected $difficulty = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type int $difficulty + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + * @return int + */ + public function getDifficulty() + { + return $this->difficulty; + } + + /** + * Generated from protobuf field .df.plugin.Difficulty difficulty = 2 [json_name = "difficulty"]; + * @param int $var + * @return $this + */ + public function setDifficulty($var) + { + GPBUtil::checkEnum($var, \Df\Plugin\Difficulty::class); + $this->difficulty = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldSetTickRangeAction.php b/packages/php/src/generated/Df/Plugin/WorldSetTickRangeAction.php new file mode 100644 index 0000000..b16d6c0 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldSetTickRangeAction.php @@ -0,0 +1,96 @@ +df.plugin.WorldSetTickRangeAction + */ +class WorldSetTickRangeAction extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field int32 tick_range = 2 [json_name = "tickRange"]; + */ + protected $tick_range = 0; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type int $tick_range + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field int32 tick_range = 2 [json_name = "tickRange"]; + * @return int + */ + public function getTickRange() + { + return $this->tick_range; + } + + /** + * Generated from protobuf field int32 tick_range = 2 [json_name = "tickRange"]; + * @param int $var + * @return $this + */ + public function setTickRange($var) + { + GPBUtil::checkInt32($var); + $this->tick_range = $var; + + return $this; + } + +} + diff --git a/packages/php/src/generated/Df/Plugin/WorldViewersResult.php b/packages/php/src/generated/Df/Plugin/WorldViewersResult.php new file mode 100644 index 0000000..c7cf045 --- /dev/null +++ b/packages/php/src/generated/Df/Plugin/WorldViewersResult.php @@ -0,0 +1,133 @@ +df.plugin.WorldViewersResult + */ +class WorldViewersResult extends \Google\Protobuf\Internal\Message +{ + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + */ + protected $world = null; + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + */ + protected $position = null; + /** + * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + */ + private $viewer_uuids; + + /** + * Constructor. + * + * @param array $data { + * Optional. Data for populating the Message object. + * + * @type \Df\Plugin\WorldRef $world + * @type \Df\Plugin\Vec3 $position + * @type string[] $viewer_uuids + * } + */ + public function __construct($data = NULL) { + \Df\Plugin\GPBMetadata\Actions::initOnce(); + parent::__construct($data); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @return \Df\Plugin\WorldRef|null + */ + public function getWorld() + { + return $this->world; + } + + public function hasWorld() + { + return isset($this->world); + } + + public function clearWorld() + { + unset($this->world); + } + + /** + * Generated from protobuf field .df.plugin.WorldRef world = 1 [json_name = "world"]; + * @param \Df\Plugin\WorldRef $var + * @return $this + */ + public function setWorld($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\WorldRef::class); + $this->world = $var; + + return $this; + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @return \Df\Plugin\Vec3|null + */ + public function getPosition() + { + return $this->position; + } + + public function hasPosition() + { + return isset($this->position); + } + + public function clearPosition() + { + unset($this->position); + } + + /** + * Generated from protobuf field .df.plugin.Vec3 position = 2 [json_name = "position"]; + * @param \Df\Plugin\Vec3 $var + * @return $this + */ + public function setPosition($var) + { + GPBUtil::checkMessage($var, \Df\Plugin\Vec3::class); + $this->position = $var; + + return $this; + } + + /** + * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + * @return RepeatedField + */ + public function getViewerUuids() + { + return $this->viewer_uuids; + } + + /** + * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + * @param string[] $var + * @return $this + */ + public function setViewerUuids($var) + { + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::STRING); + $this->viewer_uuids = $arr; + + return $this; + } + +} + diff --git a/packages/python/src/generated/actions_pb2.py b/packages/python/src/generated/actions_pb2.py index 3dd2e29..e774bc8 100644 --- a/packages/python/src/generated/actions_pb2.py +++ b/packages/python/src/generated/actions_pb2.py @@ -25,7 +25,7 @@ import common_pb2 as common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ractions.proto\x12\tdf.plugin\x1a\x0c\x63ommon.proto\":\n\x0b\x41\x63tionBatch\x12+\n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x11.df.plugin.ActionR\x07\x61\x63tions\"\xba\t\n\x06\x41\x63tion\x12*\n\x0e\x63orrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x12\x38\n\tsend_chat\x18\n \x01(\x0b\x32\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x12\x37\n\x08teleport\x18\x0b \x01(\x0b\x32\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\n\x04kick\x18\x0c \x01(\x0b\x32\x15.df.plugin.KickActionH\x00R\x04kick\x12\x42\n\rset_game_mode\x18\r \x01(\x0b\x32\x1c.df.plugin.SetGameModeActionH\x00R\x0bsetGameMode\x12\x38\n\tgive_item\x18\x0e \x01(\x0b\x32\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\n\x0f\x63lear_inventory\x18\x0f \x01(\x0b\x32\x1f.df.plugin.ClearInventoryActionH\x00R\x0e\x63learInventory\x12\x42\n\rset_held_item\x18\x10 \x01(\x0b\x32\x1c.df.plugin.SetHeldItemActionH\x00R\x0bsetHeldItem\x12;\n\nset_health\x18\x14 \x01(\x0b\x32\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x12\x35\n\x08set_food\x18\x15 \x01(\x0b\x32\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\n\x0eset_experience\x18\x16 \x01(\x0b\x32\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12\x41\n\x0cset_velocity\x18\x17 \x01(\x0b\x32\x1c.df.plugin.SetVelocityActionH\x00R\x0bsetVelocity\x12;\n\nadd_effect\x18\x1e \x01(\x0b\x32\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12\x44\n\rremove_effect\x18\x1f \x01(\x0b\x32\x1d.df.plugin.RemoveEffectActionH\x00R\x0cremoveEffect\x12;\n\nsend_title\x18( \x01(\x0b\x32\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n\nsend_popup\x18) \x01(\x0b\x32\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x12\x35\n\x08send_tip\x18* \x01(\x0b\x32\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\n\nplay_sound\x18+ \x01(\x0b\x32\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n\x0f\x65xecute_command\x18\x32 \x01(\x0b\x32\x1f.df.plugin.ExecuteCommandActionH\x00R\x0e\x65xecuteCommandB\x06\n\x04kindB\x11\n\x0f_correlation_id\"K\n\x0eSendChatAction\x12\x1f\n\x0btarget_uuid\x18\x01 \x01(\tR\ntargetUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\x8b\x01\n\x0eTeleportAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12+\n\x08rotation\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08rotation\"E\n\nKickAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reason\"f\n\x11SetGameModeAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"[\n\x0eGiveItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12(\n\x04item\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackR\x04item\"7\n\x14\x43learInventoryAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\"\xad\x01\n\x11SetHeldItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12-\n\x04main\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x12\x33\n\x07offhand\x18\x03 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01\x42\x07\n\x05_mainB\n\n\x08_offhand\"}\n\x0fSetHealthAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n\nmax_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01\x42\r\n\x0b_max_health\"D\n\rSetFoodAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x12\n\x04\x66ood\x18\x02 \x01(\x05R\x04\x66ood\"\xb1\x01\n\x13SetExperienceAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x19\n\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1b\n\x06\x61mount\x18\x04 \x01(\x05H\x02R\x06\x61mount\x88\x01\x01\x42\x08\n\x06_levelB\x0b\n\t_progressB\t\n\x07_amount\"a\n\x11SetVelocityAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08velocity\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08velocity\"\xc8\x01\n\x0f\x41\x64\x64\x45\x66\x66\x65\x63tAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\x12\x14\n\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n\x0b\x64uration_ms\x18\x04 \x01(\x03R\ndurationMs\x12%\n\x0eshow_particles\x18\x05 \x01(\x08R\rshowParticles\"m\n\x12RemoveEffectAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\"\x93\x02\n\x0fSendTitleAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n\x08subtitle\x18\x03 \x01(\tH\x00R\x08subtitle\x88\x01\x01\x12!\n\nfade_in_ms\x18\x04 \x01(\x03H\x01R\x08\x66\x61\x64\x65InMs\x88\x01\x01\x12$\n\x0b\x64uration_ms\x18\x05 \x01(\x03H\x02R\ndurationMs\x88\x01\x01\x12#\n\x0b\x66\x61\x64\x65_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01\x42\x0b\n\t_subtitleB\r\n\x0b_fade_in_msB\x0e\n\x0c_duration_msB\x0e\n\x0c_fade_out_ms\"L\n\x0fSendPopupAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"J\n\rSendTipAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xe6\x01\n\x0fPlaySoundAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12\x30\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1b\n\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01\x42\x0b\n\t_positionB\t\n\x07_volumeB\x08\n\x06_pitch\"Q\n\x14\x45xecuteCommandAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07\x63ommand\x18\x02 \x01(\tR\x07\x63ommandB\x8b\x01\n\rcom.df.pluginB\x0c\x41\x63tionsProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ractions.proto\x12\tdf.plugin\x1a\x0c\x63ommon.proto\":\n\x0b\x41\x63tionBatch\x12+\n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x11.df.plugin.ActionR\x07\x61\x63tions\"\xaf\x10\n\x06\x41\x63tion\x12*\n\x0e\x63orrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x12\x38\n\tsend_chat\x18\n \x01(\x0b\x32\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x12\x37\n\x08teleport\x18\x0b \x01(\x0b\x32\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\n\x04kick\x18\x0c \x01(\x0b\x32\x15.df.plugin.KickActionH\x00R\x04kick\x12\x42\n\rset_game_mode\x18\r \x01(\x0b\x32\x1c.df.plugin.SetGameModeActionH\x00R\x0bsetGameMode\x12\x38\n\tgive_item\x18\x0e \x01(\x0b\x32\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\n\x0f\x63lear_inventory\x18\x0f \x01(\x0b\x32\x1f.df.plugin.ClearInventoryActionH\x00R\x0e\x63learInventory\x12\x42\n\rset_held_item\x18\x10 \x01(\x0b\x32\x1c.df.plugin.SetHeldItemActionH\x00R\x0bsetHeldItem\x12;\n\nset_health\x18\x14 \x01(\x0b\x32\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x12\x35\n\x08set_food\x18\x15 \x01(\x0b\x32\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\n\x0eset_experience\x18\x16 \x01(\x0b\x32\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12\x41\n\x0cset_velocity\x18\x17 \x01(\x0b\x32\x1c.df.plugin.SetVelocityActionH\x00R\x0bsetVelocity\x12;\n\nadd_effect\x18\x1e \x01(\x0b\x32\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12\x44\n\rremove_effect\x18\x1f \x01(\x0b\x32\x1d.df.plugin.RemoveEffectActionH\x00R\x0cremoveEffect\x12;\n\nsend_title\x18( \x01(\x0b\x32\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n\nsend_popup\x18) \x01(\x0b\x32\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x12\x35\n\x08send_tip\x18* \x01(\x0b\x32\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\n\nplay_sound\x18+ \x01(\x0b\x32\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n\x0f\x65xecute_command\x18\x32 \x01(\x0b\x32\x1f.df.plugin.ExecuteCommandActionH\x00R\x0e\x65xecuteCommand\x12h\n\x1bworld_set_default_game_mode\x18< \x01(\x0b\x32(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\n\x14world_set_difficulty\x18= \x01(\x0b\x32#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\n\x14world_set_tick_range\x18> \x01(\x0b\x32\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\n\x0fworld_set_block\x18? \x01(\x0b\x32\x1e.df.plugin.WorldSetBlockActionH\x00R\rworldSetBlock\x12K\n\x10world_play_sound\x18@ \x01(\x0b\x32\x1f.df.plugin.WorldPlaySoundActionH\x00R\x0eworldPlaySound\x12Q\n\x12world_add_particle\x18\x41 \x01(\x0b\x32!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\n\x14world_query_entities\x18\x46 \x01(\x0b\x32#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\n\x13world_query_players\x18G \x01(\x0b\x32\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\n\x1bworld_query_entities_within\x18H \x01(\x0b\x32).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\n\x13world_query_viewers\x18I \x01(\x0b\x32\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\n\x04kindB\x11\n\x0f_correlation_id\"K\n\x0eSendChatAction\x12\x1f\n\x0btarget_uuid\x18\x01 \x01(\tR\ntargetUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\x8b\x01\n\x0eTeleportAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12+\n\x08rotation\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08rotation\"E\n\nKickAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reason\"f\n\x11SetGameModeAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"[\n\x0eGiveItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12(\n\x04item\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackR\x04item\"7\n\x14\x43learInventoryAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\"\xad\x01\n\x11SetHeldItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12-\n\x04main\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x12\x33\n\x07offhand\x18\x03 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01\x42\x07\n\x05_mainB\n\n\x08_offhand\"}\n\x0fSetHealthAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n\nmax_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01\x42\r\n\x0b_max_health\"D\n\rSetFoodAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x12\n\x04\x66ood\x18\x02 \x01(\x05R\x04\x66ood\"\xb1\x01\n\x13SetExperienceAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x19\n\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1b\n\x06\x61mount\x18\x04 \x01(\x05H\x02R\x06\x61mount\x88\x01\x01\x42\x08\n\x06_levelB\x0b\n\t_progressB\t\n\x07_amount\"a\n\x11SetVelocityAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08velocity\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08velocity\"\xc8\x01\n\x0f\x41\x64\x64\x45\x66\x66\x65\x63tAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\x12\x14\n\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n\x0b\x64uration_ms\x18\x04 \x01(\x03R\ndurationMs\x12%\n\x0eshow_particles\x18\x05 \x01(\x08R\rshowParticles\"m\n\x12RemoveEffectAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\"\x93\x02\n\x0fSendTitleAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n\x08subtitle\x18\x03 \x01(\tH\x00R\x08subtitle\x88\x01\x01\x12!\n\nfade_in_ms\x18\x04 \x01(\x03H\x01R\x08\x66\x61\x64\x65InMs\x88\x01\x01\x12$\n\x0b\x64uration_ms\x18\x05 \x01(\x03H\x02R\ndurationMs\x88\x01\x01\x12#\n\x0b\x66\x61\x64\x65_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01\x42\x0b\n\t_subtitleB\r\n\x0b_fade_in_msB\x0e\n\x0c_duration_msB\x0e\n\x0c_fade_out_ms\"L\n\x0fSendPopupAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"J\n\rSendTipAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xe6\x01\n\x0fPlaySoundAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12\x30\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1b\n\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01\x42\x0b\n\t_positionB\t\n\x07_volumeB\x08\n\x06_pitch\"Q\n\x14\x45xecuteCommandAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07\x63ommand\x18\x02 \x01(\tR\x07\x63ommand\"|\n\x1dWorldSetDefaultGameModeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"|\n\x18WorldSetDifficultyAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x35\n\ndifficulty\x18\x02 \x01(\x0e\x32\x15.df.plugin.DifficultyR\ndifficulty\"c\n\x17WorldSetTickRangeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x1d\n\ntick_range\x18\x02 \x01(\x05R\ttickRange\"\xad\x01\n\x13WorldSetBlockAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12/\n\x08position\x18\x02 \x01(\x0b\x32\x13.df.plugin.BlockPosR\x08position\x12\x30\n\x05\x62lock\x18\x03 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x42\x08\n\x06_block\"\x96\x01\n\x14WorldPlaySoundAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12+\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\"\x83\x02\n\x16WorldAddParticleAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12\x33\n\x08particle\x18\x03 \x01(\x0e\x32\x17.df.plugin.ParticleTypeR\x08particle\x12\x30\n\x05\x62lock\x18\x04 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x12\x17\n\x04\x66\x61\x63\x65\x18\x05 \x01(\x05H\x01R\x04\x66\x61\x63\x65\x88\x01\x01\x42\x08\n\x06_blockB\x07\n\x05_face\"E\n\x18WorldQueryEntitiesAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"D\n\x17WorldQueryPlayersAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"n\n\x1eWorldQueryEntitiesWithinAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\"q\n\x17WorldQueryViewersAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\"C\n\x0c\x41\x63tionStatus\x12\x0e\n\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\n\x05\x65rror\x18\x02 \x01(\tH\x00R\x05\x65rror\x88\x01\x01\x42\x08\n\x06_error\"r\n\x13WorldEntitiesResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\x08\x65ntities\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"\x9b\x01\n\x19WorldEntitiesWithinResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\x12\x30\n\x08\x65ntities\x18\x03 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"o\n\x12WorldPlayersResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12.\n\x07players\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x07players\"\x8f\x01\n\x12WorldViewersResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12!\n\x0cviewer_uuids\x18\x03 \x03(\tR\x0bviewerUuids\"\xb1\x03\n\x0c\x41\x63tionResult\x12%\n\x0e\x63orrelation_id\x18\x01 \x01(\tR\rcorrelationId\x12\x34\n\x06status\x18\x02 \x01(\x0b\x32\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\n\x0eworld_entities\x18\n \x01(\x0b\x32\x1e.df.plugin.WorldEntitiesResultH\x00R\rworldEntities\x12\x44\n\rworld_players\x18\x0b \x01(\x0b\x32\x1d.df.plugin.WorldPlayersResultH\x00R\x0cworldPlayers\x12Z\n\x15world_entities_within\x18\x0c \x01(\x0b\x32$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12\x44\n\rworld_viewers\x18\r \x01(\x0b\x32\x1d.df.plugin.WorldViewersResultH\x00R\x0cworldViewersB\x08\n\x06resultB\t\n\x07_status*\xeb\x03\n\x0cParticleType\x12\x1d\n\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1e\n\x1aPARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1a\n\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\n\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\n\x0fPARTICLE_SPLASH\x10\x05\x12\x13\n\x0fPARTICLE_EFFECT\x10\x06\x12\x19\n\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\n\x0ePARTICLE_FLAME\x10\x08\x12\x11\n\rPARTICLE_DUST\x10\t\x12\x1e\n\x1aPARTICLE_BLOCK_FORCE_FIELD\x10\n\x12\x16\n\x12PARTICLE_BONE_MEAL\x10\x0b\x12\x16\n\x12PARTICLE_EVAPORATE\x10\x0c\x12\x17\n\x13PARTICLE_WATER_DRIP\x10\r\x12\x16\n\x12PARTICLE_LAVA_DRIP\x10\x0e\x12\x11\n\rPARTICLE_LAVA\x10\x0f\x12\x17\n\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\n\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\n\x14PARTICLE_PUNCH_BLOCK\x10\x12\x42\x8b\x01\n\rcom.df.pluginB\x0c\x41\x63tionsProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -33,44 +33,78 @@ if not _descriptor._USE_C_DESCRIPTORS: _globals['DESCRIPTOR']._loaded_options = None _globals['DESCRIPTOR']._serialized_options = b'\n\rcom.df.pluginB\014ActionsProtoP\001Z\'github.com/secmc/plugin/proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin' + _globals['_PARTICLETYPE']._serialized_start=6809 + _globals['_PARTICLETYPE']._serialized_end=7300 _globals['_ACTIONBATCH']._serialized_start=42 _globals['_ACTIONBATCH']._serialized_end=100 _globals['_ACTION']._serialized_start=103 - _globals['_ACTION']._serialized_end=1313 - _globals['_SENDCHATACTION']._serialized_start=1315 - _globals['_SENDCHATACTION']._serialized_end=1390 - _globals['_TELEPORTACTION']._serialized_start=1393 - _globals['_TELEPORTACTION']._serialized_end=1532 - _globals['_KICKACTION']._serialized_start=1534 - _globals['_KICKACTION']._serialized_end=1603 - _globals['_SETGAMEMODEACTION']._serialized_start=1605 - _globals['_SETGAMEMODEACTION']._serialized_end=1707 - _globals['_GIVEITEMACTION']._serialized_start=1709 - _globals['_GIVEITEMACTION']._serialized_end=1800 - _globals['_CLEARINVENTORYACTION']._serialized_start=1802 - _globals['_CLEARINVENTORYACTION']._serialized_end=1857 - _globals['_SETHELDITEMACTION']._serialized_start=1860 - _globals['_SETHELDITEMACTION']._serialized_end=2033 - _globals['_SETHEALTHACTION']._serialized_start=2035 - _globals['_SETHEALTHACTION']._serialized_end=2160 - _globals['_SETFOODACTION']._serialized_start=2162 - _globals['_SETFOODACTION']._serialized_end=2230 - _globals['_SETEXPERIENCEACTION']._serialized_start=2233 - _globals['_SETEXPERIENCEACTION']._serialized_end=2410 - _globals['_SETVELOCITYACTION']._serialized_start=2412 - _globals['_SETVELOCITYACTION']._serialized_end=2509 - _globals['_ADDEFFECTACTION']._serialized_start=2512 - _globals['_ADDEFFECTACTION']._serialized_end=2712 - _globals['_REMOVEEFFECTACTION']._serialized_start=2714 - _globals['_REMOVEEFFECTACTION']._serialized_end=2823 - _globals['_SENDTITLEACTION']._serialized_start=2826 - _globals['_SENDTITLEACTION']._serialized_end=3101 - _globals['_SENDPOPUPACTION']._serialized_start=3103 - _globals['_SENDPOPUPACTION']._serialized_end=3179 - _globals['_SENDTIPACTION']._serialized_start=3181 - _globals['_SENDTIPACTION']._serialized_end=3255 - _globals['_PLAYSOUNDACTION']._serialized_start=3258 - _globals['_PLAYSOUNDACTION']._serialized_end=3488 - _globals['_EXECUTECOMMANDACTION']._serialized_start=3490 - _globals['_EXECUTECOMMANDACTION']._serialized_end=3571 + _globals['_ACTION']._serialized_end=2198 + _globals['_SENDCHATACTION']._serialized_start=2200 + _globals['_SENDCHATACTION']._serialized_end=2275 + _globals['_TELEPORTACTION']._serialized_start=2278 + _globals['_TELEPORTACTION']._serialized_end=2417 + _globals['_KICKACTION']._serialized_start=2419 + _globals['_KICKACTION']._serialized_end=2488 + _globals['_SETGAMEMODEACTION']._serialized_start=2490 + _globals['_SETGAMEMODEACTION']._serialized_end=2592 + _globals['_GIVEITEMACTION']._serialized_start=2594 + _globals['_GIVEITEMACTION']._serialized_end=2685 + _globals['_CLEARINVENTORYACTION']._serialized_start=2687 + _globals['_CLEARINVENTORYACTION']._serialized_end=2742 + _globals['_SETHELDITEMACTION']._serialized_start=2745 + _globals['_SETHELDITEMACTION']._serialized_end=2918 + _globals['_SETHEALTHACTION']._serialized_start=2920 + _globals['_SETHEALTHACTION']._serialized_end=3045 + _globals['_SETFOODACTION']._serialized_start=3047 + _globals['_SETFOODACTION']._serialized_end=3115 + _globals['_SETEXPERIENCEACTION']._serialized_start=3118 + _globals['_SETEXPERIENCEACTION']._serialized_end=3295 + _globals['_SETVELOCITYACTION']._serialized_start=3297 + _globals['_SETVELOCITYACTION']._serialized_end=3394 + _globals['_ADDEFFECTACTION']._serialized_start=3397 + _globals['_ADDEFFECTACTION']._serialized_end=3597 + _globals['_REMOVEEFFECTACTION']._serialized_start=3599 + _globals['_REMOVEEFFECTACTION']._serialized_end=3708 + _globals['_SENDTITLEACTION']._serialized_start=3711 + _globals['_SENDTITLEACTION']._serialized_end=3986 + _globals['_SENDPOPUPACTION']._serialized_start=3988 + _globals['_SENDPOPUPACTION']._serialized_end=4064 + _globals['_SENDTIPACTION']._serialized_start=4066 + _globals['_SENDTIPACTION']._serialized_end=4140 + _globals['_PLAYSOUNDACTION']._serialized_start=4143 + _globals['_PLAYSOUNDACTION']._serialized_end=4373 + _globals['_EXECUTECOMMANDACTION']._serialized_start=4375 + _globals['_EXECUTECOMMANDACTION']._serialized_end=4456 + _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_start=4458 + _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_end=4582 + _globals['_WORLDSETDIFFICULTYACTION']._serialized_start=4584 + _globals['_WORLDSETDIFFICULTYACTION']._serialized_end=4708 + _globals['_WORLDSETTICKRANGEACTION']._serialized_start=4710 + _globals['_WORLDSETTICKRANGEACTION']._serialized_end=4809 + _globals['_WORLDSETBLOCKACTION']._serialized_start=4812 + _globals['_WORLDSETBLOCKACTION']._serialized_end=4985 + _globals['_WORLDPLAYSOUNDACTION']._serialized_start=4988 + _globals['_WORLDPLAYSOUNDACTION']._serialized_end=5138 + _globals['_WORLDADDPARTICLEACTION']._serialized_start=5141 + _globals['_WORLDADDPARTICLEACTION']._serialized_end=5400 + _globals['_WORLDQUERYENTITIESACTION']._serialized_start=5402 + _globals['_WORLDQUERYENTITIESACTION']._serialized_end=5471 + _globals['_WORLDQUERYPLAYERSACTION']._serialized_start=5473 + _globals['_WORLDQUERYPLAYERSACTION']._serialized_end=5541 + _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_start=5543 + _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_end=5653 + _globals['_WORLDQUERYVIEWERSACTION']._serialized_start=5655 + _globals['_WORLDQUERYVIEWERSACTION']._serialized_end=5768 + _globals['_ACTIONSTATUS']._serialized_start=5770 + _globals['_ACTIONSTATUS']._serialized_end=5837 + _globals['_WORLDENTITIESRESULT']._serialized_start=5839 + _globals['_WORLDENTITIESRESULT']._serialized_end=5953 + _globals['_WORLDENTITIESWITHINRESULT']._serialized_start=5956 + _globals['_WORLDENTITIESWITHINRESULT']._serialized_end=6111 + _globals['_WORLDPLAYERSRESULT']._serialized_start=6113 + _globals['_WORLDPLAYERSRESULT']._serialized_end=6224 + _globals['_WORLDVIEWERSRESULT']._serialized_start=6227 + _globals['_WORLDVIEWERSRESULT']._serialized_end=6370 + _globals['_ACTIONRESULT']._serialized_start=6373 + _globals['_ACTIONRESULT']._serialized_end=6806 # @@protoc_insertion_point(module_scope) diff --git a/packages/python/src/generated/common_pb2.py b/packages/python/src/generated/common_pb2.py index 5bf1f44..baa5ac7 100644 --- a/packages/python/src/generated/common_pb2.py +++ b/packages/python/src/generated/common_pb2.py @@ -24,7 +24,7 @@ -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x63ommon.proto\x12\tdf.plugin\"0\n\x04Vec3\x12\x0c\n\x01x\x18\x01 \x01(\x01R\x01x\x12\x0c\n\x01y\x18\x02 \x01(\x01R\x01y\x12\x0c\n\x01z\x18\x03 \x01(\x01R\x01z\"2\n\x08Rotation\x12\x10\n\x03yaw\x18\x01 \x01(\x02R\x03yaw\x12\x14\n\x05pitch\x18\x02 \x01(\x02R\x05pitch\"4\n\x08\x42lockPos\x12\x0c\n\x01x\x18\x01 \x01(\x05R\x01x\x12\x0c\n\x01y\x18\x02 \x01(\x05R\x01y\x12\x0c\n\x01z\x18\x03 \x01(\x05R\x01z\"I\n\tItemStack\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n\x04meta\x18\x02 \x01(\x05R\x04meta\x12\x14\n\x05\x63ount\x18\x03 \x01(\x05R\x05\x63ount\"\xa6\x01\n\nBlockState\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x45\n\nproperties\x18\x02 \x03(\x0b\x32%.df.plugin.BlockState.PropertiesEntryR\nproperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x8b\x01\n\x0bLiquidState\x12+\n\x05\x62lock\x18\x01 \x01(\x0b\x32\x15.df.plugin.BlockStateR\x05\x62lock\x12\x14\n\x05\x64\x65pth\x18\x02 \x01(\x05R\x05\x64\x65pth\x12\x18\n\x07\x66\x61lling\x18\x03 \x01(\x08R\x07\x66\x61lling\x12\x1f\n\x0bliquid_type\x18\x04 \x01(\tR\nliquidType\"<\n\x08WorldRef\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n\tdimension\x18\x02 \x01(\tR\tdimension\"\xd7\x01\n\tEntityRef\x12\x12\n\x04uuid\x18\x01 \x01(\tR\x04uuid\x12\x12\n\x04type\x18\x02 \x01(\tR\x04type\x12\x17\n\x04name\x18\x03 \x01(\tH\x00R\x04name\x88\x01\x01\x12\x30\n\x08position\x18\x04 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x01R\x08position\x88\x01\x01\x12\x34\n\x08rotation\x18\x05 \x01(\x0b\x32\x13.df.plugin.RotationH\x02R\x08rotation\x88\x01\x01\x42\x07\n\x05_nameB\x0b\n\t_positionB\x0b\n\t_rotation\"Y\n\x0c\x44\x61mageSource\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12%\n\x0b\x64\x65scription\x18\x02 \x01(\tH\x00R\x0b\x64\x65scription\x88\x01\x01\x42\x0e\n\x0c_description\"Z\n\rHealingSource\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12%\n\x0b\x64\x65scription\x18\x02 \x01(\tH\x00R\x0b\x64\x65scription\x88\x01\x01\x42\x0e\n\x0c_description\"1\n\x07\x41\x64\x64ress\x12\x12\n\x04host\x18\x01 \x01(\tR\x04host\x12\x12\n\x04port\x18\x02 \x01(\x05R\x04port\"\xda\x01\n\x14\x43ustomItemDefinition\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12!\n\x0c\x64isplay_name\x18\x02 \x01(\tR\x0b\x64isplayName\x12!\n\x0ctexture_data\x18\x03 \x01(\x0cR\x0btextureData\x12\x33\n\x08\x63\x61tegory\x18\x04 \x01(\x0e\x32\x17.df.plugin.ItemCategoryR\x08\x63\x61tegory\x12\x19\n\x05group\x18\x05 \x01(\tH\x00R\x05group\x88\x01\x01\x12\x12\n\x04meta\x18\x06 \x01(\x05R\x04metaB\x08\n\x06_group*D\n\x08GameMode\x12\x0c\n\x08SURVIVAL\x10\x00\x12\x0c\n\x08\x43REATIVE\x10\x01\x12\r\n\tADVENTURE\x10\x02\x12\r\n\tSPECTATOR\x10\x03*\xe2\x03\n\nEffectType\x12\x12\n\x0e\x45\x46\x46\x45\x43T_UNKNOWN\x10\x00\x12\t\n\x05SPEED\x10\x01\x12\x0c\n\x08SLOWNESS\x10\x02\x12\t\n\x05HASTE\x10\x03\x12\x12\n\x0eMINING_FATIGUE\x10\x04\x12\x0c\n\x08STRENGTH\x10\x05\x12\x12\n\x0eINSTANT_HEALTH\x10\x06\x12\x12\n\x0eINSTANT_DAMAGE\x10\x07\x12\x0e\n\nJUMP_BOOST\x10\x08\x12\n\n\x06NAUSEA\x10\t\x12\x10\n\x0cREGENERATION\x10\n\x12\x0e\n\nRESISTANCE\x10\x0b\x12\x13\n\x0f\x46IRE_RESISTANCE\x10\x0c\x12\x13\n\x0fWATER_BREATHING\x10\r\x12\x10\n\x0cINVISIBILITY\x10\x0e\x12\r\n\tBLINDNESS\x10\x0f\x12\x10\n\x0cNIGHT_VISION\x10\x10\x12\n\n\x06HUNGER\x10\x11\x12\x0c\n\x08WEAKNESS\x10\x12\x12\n\n\x06POISON\x10\x13\x12\n\n\x06WITHER\x10\x14\x12\x10\n\x0cHEALTH_BOOST\x10\x15\x12\x0e\n\nABSORPTION\x10\x16\x12\x0e\n\nSATURATION\x10\x17\x12\x0e\n\nLEVITATION\x10\x18\x12\x10\n\x0c\x46\x41TAL_POISON\x10\x19\x12\x11\n\rCONDUIT_POWER\x10\x1a\x12\x10\n\x0cSLOW_FALLING\x10\x1b\x12\x0c\n\x08\x44\x41RKNESS\x10\x1e*\xcd\x02\n\x05Sound\x12\x11\n\rSOUND_UNKNOWN\x10\x00\x12\n\n\x06\x41TTACK\x10\x01\x12\x0c\n\x08\x44ROWNING\x10\x02\x12\x0b\n\x07\x42URNING\x10\x03\x12\x08\n\x04\x46\x41LL\x10\x04\x12\x08\n\x04\x42URP\x10\x05\x12\x07\n\x03POP\x10\x06\x12\r\n\tEXPLOSION\x10\x07\x12\x0b\n\x07THUNDER\x10\x08\x12\x0c\n\x08LEVEL_UP\x10\t\x12\x0e\n\nEXPERIENCE\x10\n\x12\x13\n\x0f\x46IREWORK_LAUNCH\x10\x0b\x12\x17\n\x13\x46IREWORK_HUGE_BLAST\x10\x0c\x12\x12\n\x0e\x46IREWORK_BLAST\x10\r\x12\x14\n\x10\x46IREWORK_TWINKLE\x10\x0e\x12\x0c\n\x08TELEPORT\x10\x0f\x12\r\n\tARROW_HIT\x10\x10\x12\x0e\n\nITEM_BREAK\x10\x11\x12\x0e\n\nITEM_THROW\x10\x12\x12\t\n\x05TOTEM\x10\x13\x12\x13\n\x0f\x46IRE_EXTINGUISH\x10\x14*~\n\x0cItemCategory\x12\x1e\n\x1aITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\n\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1b\n\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\n\x13ITEM_CATEGORY_ITEMS\x10\x03\x42\x8a\x01\n\rcom.df.pluginB\x0b\x43ommonProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0c\x63ommon.proto\x12\tdf.plugin\"0\n\x04Vec3\x12\x0c\n\x01x\x18\x01 \x01(\x01R\x01x\x12\x0c\n\x01y\x18\x02 \x01(\x01R\x01y\x12\x0c\n\x01z\x18\x03 \x01(\x01R\x01z\"2\n\x08Rotation\x12\x10\n\x03yaw\x18\x01 \x01(\x02R\x03yaw\x12\x14\n\x05pitch\x18\x02 \x01(\x02R\x05pitch\"L\n\x04\x42\x42ox\x12!\n\x03min\x18\x01 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x03min\x12!\n\x03max\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x03max\"4\n\x08\x42lockPos\x12\x0c\n\x01x\x18\x01 \x01(\x05R\x01x\x12\x0c\n\x01y\x18\x02 \x01(\x05R\x01y\x12\x0c\n\x01z\x18\x03 \x01(\x05R\x01z\"I\n\tItemStack\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x12\n\x04meta\x18\x02 \x01(\x05R\x04meta\x12\x14\n\x05\x63ount\x18\x03 \x01(\x05R\x05\x63ount\"\xa6\x01\n\nBlockState\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x45\n\nproperties\x18\x02 \x03(\x0b\x32%.df.plugin.BlockState.PropertiesEntryR\nproperties\x1a=\n\x0fPropertiesEntry\x12\x10\n\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n\x05value\x18\x02 \x01(\tR\x05value:\x02\x38\x01\"\x8b\x01\n\x0bLiquidState\x12+\n\x05\x62lock\x18\x01 \x01(\x0b\x32\x15.df.plugin.BlockStateR\x05\x62lock\x12\x14\n\x05\x64\x65pth\x18\x02 \x01(\x05R\x05\x64\x65pth\x12\x18\n\x07\x66\x61lling\x18\x03 \x01(\x08R\x07\x66\x61lling\x12\x1f\n\x0bliquid_type\x18\x04 \x01(\tR\nliquidType\"<\n\x08WorldRef\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x1c\n\tdimension\x18\x02 \x01(\tR\tdimension\"\xd7\x01\n\tEntityRef\x12\x12\n\x04uuid\x18\x01 \x01(\tR\x04uuid\x12\x12\n\x04type\x18\x02 \x01(\tR\x04type\x12\x17\n\x04name\x18\x03 \x01(\tH\x00R\x04name\x88\x01\x01\x12\x30\n\x08position\x18\x04 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x01R\x08position\x88\x01\x01\x12\x34\n\x08rotation\x18\x05 \x01(\x0b\x32\x13.df.plugin.RotationH\x02R\x08rotation\x88\x01\x01\x42\x07\n\x05_nameB\x0b\n\t_positionB\x0b\n\t_rotation\"Y\n\x0c\x44\x61mageSource\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12%\n\x0b\x64\x65scription\x18\x02 \x01(\tH\x00R\x0b\x64\x65scription\x88\x01\x01\x42\x0e\n\x0c_description\"Z\n\rHealingSource\x12\x12\n\x04type\x18\x01 \x01(\tR\x04type\x12%\n\x0b\x64\x65scription\x18\x02 \x01(\tH\x00R\x0b\x64\x65scription\x88\x01\x01\x42\x0e\n\x0c_description\"1\n\x07\x41\x64\x64ress\x12\x12\n\x04host\x18\x01 \x01(\tR\x04host\x12\x12\n\x04port\x18\x02 \x01(\x05R\x04port\"\xda\x01\n\x14\x43ustomItemDefinition\x12\x0e\n\x02id\x18\x01 \x01(\tR\x02id\x12!\n\x0c\x64isplay_name\x18\x02 \x01(\tR\x0b\x64isplayName\x12!\n\x0ctexture_data\x18\x03 \x01(\x0cR\x0btextureData\x12\x33\n\x08\x63\x61tegory\x18\x04 \x01(\x0e\x32\x17.df.plugin.ItemCategoryR\x08\x63\x61tegory\x12\x19\n\x05group\x18\x05 \x01(\tH\x00R\x05group\x88\x01\x01\x12\x12\n\x04meta\x18\x06 \x01(\x05R\x04metaB\x08\n\x06_group*D\n\x08GameMode\x12\x0c\n\x08SURVIVAL\x10\x00\x12\x0c\n\x08\x43REATIVE\x10\x01\x12\r\n\tADVENTURE\x10\x02\x12\r\n\tSPECTATOR\x10\x03*:\n\nDifficulty\x12\x0c\n\x08PEACEFUL\x10\x00\x12\x08\n\x04\x45\x41SY\x10\x01\x12\n\n\x06NORMAL\x10\x02\x12\x08\n\x04HARD\x10\x03*\xe2\x03\n\nEffectType\x12\x12\n\x0e\x45\x46\x46\x45\x43T_UNKNOWN\x10\x00\x12\t\n\x05SPEED\x10\x01\x12\x0c\n\x08SLOWNESS\x10\x02\x12\t\n\x05HASTE\x10\x03\x12\x12\n\x0eMINING_FATIGUE\x10\x04\x12\x0c\n\x08STRENGTH\x10\x05\x12\x12\n\x0eINSTANT_HEALTH\x10\x06\x12\x12\n\x0eINSTANT_DAMAGE\x10\x07\x12\x0e\n\nJUMP_BOOST\x10\x08\x12\n\n\x06NAUSEA\x10\t\x12\x10\n\x0cREGENERATION\x10\n\x12\x0e\n\nRESISTANCE\x10\x0b\x12\x13\n\x0f\x46IRE_RESISTANCE\x10\x0c\x12\x13\n\x0fWATER_BREATHING\x10\r\x12\x10\n\x0cINVISIBILITY\x10\x0e\x12\r\n\tBLINDNESS\x10\x0f\x12\x10\n\x0cNIGHT_VISION\x10\x10\x12\n\n\x06HUNGER\x10\x11\x12\x0c\n\x08WEAKNESS\x10\x12\x12\n\n\x06POISON\x10\x13\x12\n\n\x06WITHER\x10\x14\x12\x10\n\x0cHEALTH_BOOST\x10\x15\x12\x0e\n\nABSORPTION\x10\x16\x12\x0e\n\nSATURATION\x10\x17\x12\x0e\n\nLEVITATION\x10\x18\x12\x10\n\x0c\x46\x41TAL_POISON\x10\x19\x12\x11\n\rCONDUIT_POWER\x10\x1a\x12\x10\n\x0cSLOW_FALLING\x10\x1b\x12\x0c\n\x08\x44\x41RKNESS\x10\x1e*\xcd\x02\n\x05Sound\x12\x11\n\rSOUND_UNKNOWN\x10\x00\x12\n\n\x06\x41TTACK\x10\x01\x12\x0c\n\x08\x44ROWNING\x10\x02\x12\x0b\n\x07\x42URNING\x10\x03\x12\x08\n\x04\x46\x41LL\x10\x04\x12\x08\n\x04\x42URP\x10\x05\x12\x07\n\x03POP\x10\x06\x12\r\n\tEXPLOSION\x10\x07\x12\x0b\n\x07THUNDER\x10\x08\x12\x0c\n\x08LEVEL_UP\x10\t\x12\x0e\n\nEXPERIENCE\x10\n\x12\x13\n\x0f\x46IREWORK_LAUNCH\x10\x0b\x12\x17\n\x13\x46IREWORK_HUGE_BLAST\x10\x0c\x12\x12\n\x0e\x46IREWORK_BLAST\x10\r\x12\x14\n\x10\x46IREWORK_TWINKLE\x10\x0e\x12\x0c\n\x08TELEPORT\x10\x0f\x12\r\n\tARROW_HIT\x10\x10\x12\x0e\n\nITEM_BREAK\x10\x11\x12\x0e\n\nITEM_THROW\x10\x12\x12\t\n\x05TOTEM\x10\x13\x12\x13\n\x0f\x46IRE_EXTINGUISH\x10\x14*~\n\x0cItemCategory\x12\x1e\n\x1aITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\n\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1b\n\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\n\x13ITEM_CATEGORY_ITEMS\x10\x03\x42\x8a\x01\n\rcom.df.pluginB\x0b\x43ommonProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -34,38 +34,42 @@ _globals['DESCRIPTOR']._serialized_options = b'\n\rcom.df.pluginB\013CommonProtoP\001Z\'github.com/secmc/plugin/proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin' _globals['_BLOCKSTATE_PROPERTIESENTRY']._loaded_options = None _globals['_BLOCKSTATE_PROPERTIESENTRY']._serialized_options = b'8\001' - _globals['_GAMEMODE']._serialized_start=1304 - _globals['_GAMEMODE']._serialized_end=1372 - _globals['_EFFECTTYPE']._serialized_start=1375 - _globals['_EFFECTTYPE']._serialized_end=1857 - _globals['_SOUND']._serialized_start=1860 - _globals['_SOUND']._serialized_end=2193 - _globals['_ITEMCATEGORY']._serialized_start=2195 - _globals['_ITEMCATEGORY']._serialized_end=2321 + _globals['_GAMEMODE']._serialized_start=1382 + _globals['_GAMEMODE']._serialized_end=1450 + _globals['_DIFFICULTY']._serialized_start=1452 + _globals['_DIFFICULTY']._serialized_end=1510 + _globals['_EFFECTTYPE']._serialized_start=1513 + _globals['_EFFECTTYPE']._serialized_end=1995 + _globals['_SOUND']._serialized_start=1998 + _globals['_SOUND']._serialized_end=2331 + _globals['_ITEMCATEGORY']._serialized_start=2333 + _globals['_ITEMCATEGORY']._serialized_end=2459 _globals['_VEC3']._serialized_start=27 _globals['_VEC3']._serialized_end=75 _globals['_ROTATION']._serialized_start=77 _globals['_ROTATION']._serialized_end=127 - _globals['_BLOCKPOS']._serialized_start=129 - _globals['_BLOCKPOS']._serialized_end=181 - _globals['_ITEMSTACK']._serialized_start=183 - _globals['_ITEMSTACK']._serialized_end=256 - _globals['_BLOCKSTATE']._serialized_start=259 - _globals['_BLOCKSTATE']._serialized_end=425 - _globals['_BLOCKSTATE_PROPERTIESENTRY']._serialized_start=364 - _globals['_BLOCKSTATE_PROPERTIESENTRY']._serialized_end=425 - _globals['_LIQUIDSTATE']._serialized_start=428 - _globals['_LIQUIDSTATE']._serialized_end=567 - _globals['_WORLDREF']._serialized_start=569 - _globals['_WORLDREF']._serialized_end=629 - _globals['_ENTITYREF']._serialized_start=632 - _globals['_ENTITYREF']._serialized_end=847 - _globals['_DAMAGESOURCE']._serialized_start=849 - _globals['_DAMAGESOURCE']._serialized_end=938 - _globals['_HEALINGSOURCE']._serialized_start=940 - _globals['_HEALINGSOURCE']._serialized_end=1030 - _globals['_ADDRESS']._serialized_start=1032 - _globals['_ADDRESS']._serialized_end=1081 - _globals['_CUSTOMITEMDEFINITION']._serialized_start=1084 - _globals['_CUSTOMITEMDEFINITION']._serialized_end=1302 + _globals['_BBOX']._serialized_start=129 + _globals['_BBOX']._serialized_end=205 + _globals['_BLOCKPOS']._serialized_start=207 + _globals['_BLOCKPOS']._serialized_end=259 + _globals['_ITEMSTACK']._serialized_start=261 + _globals['_ITEMSTACK']._serialized_end=334 + _globals['_BLOCKSTATE']._serialized_start=337 + _globals['_BLOCKSTATE']._serialized_end=503 + _globals['_BLOCKSTATE_PROPERTIESENTRY']._serialized_start=442 + _globals['_BLOCKSTATE_PROPERTIESENTRY']._serialized_end=503 + _globals['_LIQUIDSTATE']._serialized_start=506 + _globals['_LIQUIDSTATE']._serialized_end=645 + _globals['_WORLDREF']._serialized_start=647 + _globals['_WORLDREF']._serialized_end=707 + _globals['_ENTITYREF']._serialized_start=710 + _globals['_ENTITYREF']._serialized_end=925 + _globals['_DAMAGESOURCE']._serialized_start=927 + _globals['_DAMAGESOURCE']._serialized_end=1016 + _globals['_HEALINGSOURCE']._serialized_start=1018 + _globals['_HEALINGSOURCE']._serialized_end=1108 + _globals['_ADDRESS']._serialized_start=1110 + _globals['_ADDRESS']._serialized_end=1159 + _globals['_CUSTOMITEMDEFINITION']._serialized_start=1162 + _globals['_CUSTOMITEMDEFINITION']._serialized_end=1380 # @@protoc_insertion_point(module_scope) diff --git a/packages/python/src/generated/plugin_pb2.py b/packages/python/src/generated/plugin_pb2.py index 7632dd0..b5d9e4b 100644 --- a/packages/python/src/generated/plugin_pb2.py +++ b/packages/python/src/generated/plugin_pb2.py @@ -30,7 +30,7 @@ import common_pb2 as common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\x0c\x63ommon.proto\"\x96\x02\n\x0cHostToPlugin\x12\x1b\n\tplugin_id\x18\x01 \x01(\tR\x08pluginId\x12,\n\x05hello\x18\n \x01(\x0b\x32\x14.df.plugin.HostHelloH\x00R\x05hello\x12\x35\n\x08shutdown\x18\x0b \x01(\x0b\x32\x17.df.plugin.HostShutdownH\x00R\x08shutdown\x12G\n\x0bserver_info\x18\x0c \x01(\x0b\x32$.df.plugin.ServerInformationResponseH\x00R\nserverInfo\x12\x30\n\x05\x65vent\x18\x14 \x01(\x0b\x32\x18.df.plugin.EventEnvelopeH\x00R\x05\x65ventB\t\n\x07payload\"\x1a\n\x18ServerInformationRequest\"5\n\x19ServerInformationResponse\x12\x18\n\x07plugins\x18\x01 \x03(\tR\x07plugins\",\n\tHostHello\x12\x1f\n\x0b\x61pi_version\x18\x01 \x01(\tR\napiVersion\"&\n\x0cHostShutdown\x12\x16\n\x06reason\x18\x01 \x01(\tR\x06reason\"\xe6\x1e\n\rEventEnvelope\x12\x19\n\x08\x65vent_id\x18\x01 \x01(\tR\x07\x65ventId\x12(\n\x04type\x18\x02 \x01(\x0e\x32\x14.df.plugin.EventTypeR\x04type\x12)\n\x10\x65xpects_response\x18\x03 \x01(\x08R\x0f\x65xpectsResponse\x12=\n\x0bplayer_join\x18\n \x01(\x0b\x32\x1a.df.plugin.PlayerJoinEventH\x00R\nplayerJoin\x12=\n\x0bplayer_quit\x18\x0b \x01(\x0b\x32\x1a.df.plugin.PlayerQuitEventH\x00R\nplayerQuit\x12=\n\x0bplayer_move\x18\x0c \x01(\x0b\x32\x1a.df.plugin.PlayerMoveEventH\x00R\nplayerMove\x12=\n\x0bplayer_jump\x18\r \x01(\x0b\x32\x1a.df.plugin.PlayerJumpEventH\x00R\nplayerJump\x12I\n\x0fplayer_teleport\x18\x0e \x01(\x0b\x32\x1e.df.plugin.PlayerTeleportEventH\x00R\x0eplayerTeleport\x12S\n\x13player_change_world\x18\x0f \x01(\x0b\x32!.df.plugin.PlayerChangeWorldEventH\x00R\x11playerChangeWorld\x12V\n\x14player_toggle_sprint\x18\x10 \x01(\x0b\x32\".df.plugin.PlayerToggleSprintEventH\x00R\x12playerToggleSprint\x12S\n\x13player_toggle_sneak\x18\x11 \x01(\x0b\x32!.df.plugin.PlayerToggleSneakEventH\x00R\x11playerToggleSneak\x12*\n\x04\x63hat\x18\x12 \x01(\x0b\x32\x14.df.plugin.ChatEventH\x00R\x04\x63hat\x12J\n\x10player_food_loss\x18\x13 \x01(\x0b\x32\x1e.df.plugin.PlayerFoodLossEventH\x00R\x0eplayerFoodLoss\x12=\n\x0bplayer_heal\x18\x14 \x01(\x0b\x32\x1a.df.plugin.PlayerHealEventH\x00R\nplayerHeal\x12=\n\x0bplayer_hurt\x18\x15 \x01(\x0b\x32\x1a.df.plugin.PlayerHurtEventH\x00R\nplayerHurt\x12@\n\x0cplayer_death\x18\x16 \x01(\x0b\x32\x1b.df.plugin.PlayerDeathEventH\x00R\x0bplayerDeath\x12\x46\n\x0eplayer_respawn\x18\x17 \x01(\x0b\x32\x1d.df.plugin.PlayerRespawnEventH\x00R\rplayerRespawn\x12P\n\x12player_skin_change\x18\x18 \x01(\x0b\x32 .df.plugin.PlayerSkinChangeEventH\x00R\x10playerSkinChange\x12\\\n\x16player_fire_extinguish\x18\x19 \x01(\x0b\x32$.df.plugin.PlayerFireExtinguishEventH\x00R\x14playerFireExtinguish\x12P\n\x12player_start_break\x18\x1a \x01(\x0b\x32 .df.plugin.PlayerStartBreakEventH\x00R\x10playerStartBreak\x12=\n\x0b\x62lock_break\x18\x1b \x01(\x0b\x32\x1a.df.plugin.BlockBreakEventH\x00R\nblockBreak\x12P\n\x12player_block_place\x18\x1c \x01(\x0b\x32 .df.plugin.PlayerBlockPlaceEventH\x00R\x10playerBlockPlace\x12M\n\x11player_block_pick\x18\x1d \x01(\x0b\x32\x1f.df.plugin.PlayerBlockPickEventH\x00R\x0fplayerBlockPick\x12G\n\x0fplayer_item_use\x18\x1e \x01(\x0b\x32\x1d.df.plugin.PlayerItemUseEventH\x00R\rplayerItemUse\x12^\n\x18player_item_use_on_block\x18\x1f \x01(\x0b\x32$.df.plugin.PlayerItemUseOnBlockEventH\x00R\x14playerItemUseOnBlock\x12\x61\n\x19player_item_use_on_entity\x18 \x01(\x0b\x32%.df.plugin.PlayerItemUseOnEntityEventH\x00R\x15playerItemUseOnEntity\x12S\n\x13player_item_release\x18! \x01(\x0b\x32!.df.plugin.PlayerItemReleaseEventH\x00R\x11playerItemRelease\x12S\n\x13player_item_consume\x18\" \x01(\x0b\x32!.df.plugin.PlayerItemConsumeEventH\x00R\x11playerItemConsume\x12V\n\x14player_attack_entity\x18# \x01(\x0b\x32\".df.plugin.PlayerAttackEntityEventH\x00R\x12playerAttackEntity\x12\\\n\x16player_experience_gain\x18$ \x01(\x0b\x32$.df.plugin.PlayerExperienceGainEventH\x00R\x14playerExperienceGain\x12J\n\x10player_punch_air\x18% \x01(\x0b\x32\x1e.df.plugin.PlayerPunchAirEventH\x00R\x0eplayerPunchAir\x12J\n\x10player_sign_edit\x18& \x01(\x0b\x32\x1e.df.plugin.PlayerSignEditEventH\x00R\x0eplayerSignEdit\x12`\n\x18player_lectern_page_turn\x18\' \x01(\x0b\x32%.df.plugin.PlayerLecternPageTurnEventH\x00R\x15playerLecternPageTurn\x12P\n\x12player_item_damage\x18( \x01(\x0b\x32 .df.plugin.PlayerItemDamageEventH\x00R\x10playerItemDamage\x12P\n\x12player_item_pickup\x18) \x01(\x0b\x32 .df.plugin.PlayerItemPickupEventH\x00R\x10playerItemPickup\x12]\n\x17player_held_slot_change\x18* \x01(\x0b\x32$.df.plugin.PlayerHeldSlotChangeEventH\x00R\x14playerHeldSlotChange\x12J\n\x10player_item_drop\x18+ \x01(\x0b\x32\x1e.df.plugin.PlayerItemDropEventH\x00R\x0eplayerItemDrop\x12I\n\x0fplayer_transfer\x18, \x01(\x0b\x32\x1e.df.plugin.PlayerTransferEventH\x00R\x0eplayerTransfer\x12\x33\n\x07\x63ommand\x18- \x01(\x0b\x32\x17.df.plugin.CommandEventH\x00R\x07\x63ommand\x12R\n\x12player_diagnostics\x18. \x01(\x0b\x32!.df.plugin.PlayerDiagnosticsEventH\x00R\x11playerDiagnostics\x12M\n\x11world_liquid_flow\x18\x46 \x01(\x0b\x32\x1f.df.plugin.WorldLiquidFlowEventH\x00R\x0fworldLiquidFlow\x12P\n\x12world_liquid_decay\x18G \x01(\x0b\x32 .df.plugin.WorldLiquidDecayEventH\x00R\x10worldLiquidDecay\x12S\n\x13world_liquid_harden\x18H \x01(\x0b\x32!.df.plugin.WorldLiquidHardenEventH\x00R\x11worldLiquidHarden\x12=\n\x0bworld_sound\x18I \x01(\x0b\x32\x1a.df.plugin.WorldSoundEventH\x00R\nworldSound\x12M\n\x11world_fire_spread\x18J \x01(\x0b\x32\x1f.df.plugin.WorldFireSpreadEventH\x00R\x0fworldFireSpread\x12J\n\x10world_block_burn\x18K \x01(\x0b\x32\x1e.df.plugin.WorldBlockBurnEventH\x00R\x0eworldBlockBurn\x12P\n\x12world_crop_trample\x18L \x01(\x0b\x32 .df.plugin.WorldCropTrampleEventH\x00R\x10worldCropTrample\x12P\n\x12world_leaves_decay\x18M \x01(\x0b\x32 .df.plugin.WorldLeavesDecayEventH\x00R\x10worldLeavesDecay\x12P\n\x12world_entity_spawn\x18N \x01(\x0b\x32 .df.plugin.WorldEntitySpawnEventH\x00R\x10worldEntitySpawn\x12V\n\x14world_entity_despawn\x18O \x01(\x0b\x32\".df.plugin.WorldEntityDespawnEventH\x00R\x12worldEntityDespawn\x12I\n\x0fworld_explosion\x18P \x01(\x0b\x32\x1e.df.plugin.WorldExplosionEventH\x00R\x0eworldExplosion\x12=\n\x0bworld_close\x18Q \x01(\x0b\x32\x1a.df.plugin.WorldCloseEventH\x00R\nworldCloseB\t\n\x07payload\"\x85\x03\n\x0cPluginToHost\x12\x1b\n\tplugin_id\x18\x01 \x01(\tR\x08pluginId\x12.\n\x05hello\x18\n \x01(\x0b\x32\x16.df.plugin.PluginHelloH\x00R\x05hello\x12\x39\n\tsubscribe\x18\x0b \x01(\x0b\x32\x19.df.plugin.EventSubscribeH\x00R\tsubscribe\x12\x46\n\x0bserver_info\x18\x0c \x01(\x0b\x32#.df.plugin.ServerInformationRequestH\x00R\nserverInfo\x12\x32\n\x07\x61\x63tions\x18\x14 \x01(\x0b\x32\x16.df.plugin.ActionBatchH\x00R\x07\x61\x63tions\x12)\n\x03log\x18\x1e \x01(\x0b\x32\x15.df.plugin.LogMessageH\x00R\x03log\x12;\n\x0c\x65vent_result\x18( \x01(\x0b\x32\x16.df.plugin.EventResultH\x00R\x0b\x65ventResultB\t\n\x07payload\"\xd4\x01\n\x0bPluginHello\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n\x07version\x18\x02 \x01(\tR\x07version\x12\x1f\n\x0b\x61pi_version\x18\x03 \x01(\tR\napiVersion\x12\x32\n\x08\x63ommands\x18\x04 \x03(\x0b\x32\x16.df.plugin.CommandSpecR\x08\x63ommands\x12\x42\n\x0c\x63ustom_items\x18\x05 \x03(\x0b\x32\x1f.df.plugin.CustomItemDefinitionR\x0b\x63ustomItems\"<\n\nLogMessage\x12\x14\n\x05level\x18\x01 \x01(\tR\x05level\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\">\n\x0e\x45ventSubscribe\x12,\n\x06\x65vents\x18\x01 \x03(\x0e\x32\x14.df.plugin.EventTypeR\x06\x65vents*\x8a\t\n\tEventType\x12\x1a\n\x16\x45VENT_TYPE_UNSPECIFIED\x10\x00\x12\x12\n\x0e\x45VENT_TYPE_ALL\x10\x01\x12\x0f\n\x0bPLAYER_JOIN\x10\n\x12\x0f\n\x0bPLAYER_QUIT\x10\x0b\x12\x0f\n\x0bPLAYER_MOVE\x10\x0c\x12\x0f\n\x0bPLAYER_JUMP\x10\r\x12\x13\n\x0fPLAYER_TELEPORT\x10\x0e\x12\x17\n\x13PLAYER_CHANGE_WORLD\x10\x0f\x12\x18\n\x14PLAYER_TOGGLE_SPRINT\x10\x10\x12\x17\n\x13PLAYER_TOGGLE_SNEAK\x10\x11\x12\x08\n\x04\x43HAT\x10\x12\x12\x14\n\x10PLAYER_FOOD_LOSS\x10\x13\x12\x0f\n\x0bPLAYER_HEAL\x10\x14\x12\x0f\n\x0bPLAYER_HURT\x10\x15\x12\x10\n\x0cPLAYER_DEATH\x10\x16\x12\x12\n\x0ePLAYER_RESPAWN\x10\x17\x12\x16\n\x12PLAYER_SKIN_CHANGE\x10\x18\x12\x1a\n\x16PLAYER_FIRE_EXTINGUISH\x10\x19\x12\x16\n\x12PLAYER_START_BREAK\x10\x1a\x12\x16\n\x12PLAYER_BLOCK_BREAK\x10\x1b\x12\x16\n\x12PLAYER_BLOCK_PLACE\x10\x1c\x12\x15\n\x11PLAYER_BLOCK_PICK\x10\x1d\x12\x13\n\x0fPLAYER_ITEM_USE\x10\x1e\x12\x1c\n\x18PLAYER_ITEM_USE_ON_BLOCK\x10\x1f\x12\x1d\n\x19PLAYER_ITEM_USE_ON_ENTITY\x10 \x12\x17\n\x13PLAYER_ITEM_RELEASE\x10!\x12\x17\n\x13PLAYER_ITEM_CONSUME\x10\"\x12\x18\n\x14PLAYER_ATTACK_ENTITY\x10#\x12\x1a\n\x16PLAYER_EXPERIENCE_GAIN\x10$\x12\x14\n\x10PLAYER_PUNCH_AIR\x10%\x12\x14\n\x10PLAYER_SIGN_EDIT\x10&\x12\x1c\n\x18PLAYER_LECTERN_PAGE_TURN\x10\'\x12\x16\n\x12PLAYER_ITEM_DAMAGE\x10(\x12\x16\n\x12PLAYER_ITEM_PICKUP\x10)\x12\x1b\n\x17PLAYER_HELD_SLOT_CHANGE\x10*\x12\x14\n\x10PLAYER_ITEM_DROP\x10+\x12\x13\n\x0fPLAYER_TRANSFER\x10,\x12\x0b\n\x07\x43OMMAND\x10-\x12\x16\n\x12PLAYER_DIAGNOSTICS\x10.\x12\x15\n\x11WORLD_LIQUID_FLOW\x10\x46\x12\x16\n\x12WORLD_LIQUID_DECAY\x10G\x12\x17\n\x13WORLD_LIQUID_HARDEN\x10H\x12\x0f\n\x0bWORLD_SOUND\x10I\x12\x15\n\x11WORLD_FIRE_SPREAD\x10J\x12\x14\n\x10WORLD_BLOCK_BURN\x10K\x12\x16\n\x12WORLD_CROP_TRAMPLE\x10L\x12\x16\n\x12WORLD_LEAVES_DECAY\x10M\x12\x16\n\x12WORLD_ENTITY_SPAWN\x10N\x12\x18\n\x14WORLD_ENTITY_DESPAWN\x10O\x12\x13\n\x0fWORLD_EXPLOSION\x10P\x12\x0f\n\x0bWORLD_CLOSE\x10Q2M\n\x06Plugin\x12\x43\n\x0b\x45ventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x01\x30\x01\x42\x8a\x01\n\rcom.df.pluginB\x0bPluginProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\x0c\x63ommon.proto\"\xd6\x02\n\x0cHostToPlugin\x12\x1b\n\tplugin_id\x18\x01 \x01(\tR\x08pluginId\x12,\n\x05hello\x18\n \x01(\x0b\x32\x14.df.plugin.HostHelloH\x00R\x05hello\x12\x35\n\x08shutdown\x18\x0b \x01(\x0b\x32\x17.df.plugin.HostShutdownH\x00R\x08shutdown\x12G\n\x0bserver_info\x18\x0c \x01(\x0b\x32$.df.plugin.ServerInformationResponseH\x00R\nserverInfo\x12\x30\n\x05\x65vent\x18\x14 \x01(\x0b\x32\x18.df.plugin.EventEnvelopeH\x00R\x05\x65vent\x12>\n\raction_result\x18\x15 \x01(\x0b\x32\x17.df.plugin.ActionResultH\x00R\x0c\x61\x63tionResultB\t\n\x07payload\"\x1a\n\x18ServerInformationRequest\"5\n\x19ServerInformationResponse\x12\x18\n\x07plugins\x18\x01 \x03(\tR\x07plugins\",\n\tHostHello\x12\x1f\n\x0b\x61pi_version\x18\x01 \x01(\tR\napiVersion\"&\n\x0cHostShutdown\x12\x16\n\x06reason\x18\x01 \x01(\tR\x06reason\"\xe6\x1e\n\rEventEnvelope\x12\x19\n\x08\x65vent_id\x18\x01 \x01(\tR\x07\x65ventId\x12(\n\x04type\x18\x02 \x01(\x0e\x32\x14.df.plugin.EventTypeR\x04type\x12)\n\x10\x65xpects_response\x18\x03 \x01(\x08R\x0f\x65xpectsResponse\x12=\n\x0bplayer_join\x18\n \x01(\x0b\x32\x1a.df.plugin.PlayerJoinEventH\x00R\nplayerJoin\x12=\n\x0bplayer_quit\x18\x0b \x01(\x0b\x32\x1a.df.plugin.PlayerQuitEventH\x00R\nplayerQuit\x12=\n\x0bplayer_move\x18\x0c \x01(\x0b\x32\x1a.df.plugin.PlayerMoveEventH\x00R\nplayerMove\x12=\n\x0bplayer_jump\x18\r \x01(\x0b\x32\x1a.df.plugin.PlayerJumpEventH\x00R\nplayerJump\x12I\n\x0fplayer_teleport\x18\x0e \x01(\x0b\x32\x1e.df.plugin.PlayerTeleportEventH\x00R\x0eplayerTeleport\x12S\n\x13player_change_world\x18\x0f \x01(\x0b\x32!.df.plugin.PlayerChangeWorldEventH\x00R\x11playerChangeWorld\x12V\n\x14player_toggle_sprint\x18\x10 \x01(\x0b\x32\".df.plugin.PlayerToggleSprintEventH\x00R\x12playerToggleSprint\x12S\n\x13player_toggle_sneak\x18\x11 \x01(\x0b\x32!.df.plugin.PlayerToggleSneakEventH\x00R\x11playerToggleSneak\x12*\n\x04\x63hat\x18\x12 \x01(\x0b\x32\x14.df.plugin.ChatEventH\x00R\x04\x63hat\x12J\n\x10player_food_loss\x18\x13 \x01(\x0b\x32\x1e.df.plugin.PlayerFoodLossEventH\x00R\x0eplayerFoodLoss\x12=\n\x0bplayer_heal\x18\x14 \x01(\x0b\x32\x1a.df.plugin.PlayerHealEventH\x00R\nplayerHeal\x12=\n\x0bplayer_hurt\x18\x15 \x01(\x0b\x32\x1a.df.plugin.PlayerHurtEventH\x00R\nplayerHurt\x12@\n\x0cplayer_death\x18\x16 \x01(\x0b\x32\x1b.df.plugin.PlayerDeathEventH\x00R\x0bplayerDeath\x12\x46\n\x0eplayer_respawn\x18\x17 \x01(\x0b\x32\x1d.df.plugin.PlayerRespawnEventH\x00R\rplayerRespawn\x12P\n\x12player_skin_change\x18\x18 \x01(\x0b\x32 .df.plugin.PlayerSkinChangeEventH\x00R\x10playerSkinChange\x12\\\n\x16player_fire_extinguish\x18\x19 \x01(\x0b\x32$.df.plugin.PlayerFireExtinguishEventH\x00R\x14playerFireExtinguish\x12P\n\x12player_start_break\x18\x1a \x01(\x0b\x32 .df.plugin.PlayerStartBreakEventH\x00R\x10playerStartBreak\x12=\n\x0b\x62lock_break\x18\x1b \x01(\x0b\x32\x1a.df.plugin.BlockBreakEventH\x00R\nblockBreak\x12P\n\x12player_block_place\x18\x1c \x01(\x0b\x32 .df.plugin.PlayerBlockPlaceEventH\x00R\x10playerBlockPlace\x12M\n\x11player_block_pick\x18\x1d \x01(\x0b\x32\x1f.df.plugin.PlayerBlockPickEventH\x00R\x0fplayerBlockPick\x12G\n\x0fplayer_item_use\x18\x1e \x01(\x0b\x32\x1d.df.plugin.PlayerItemUseEventH\x00R\rplayerItemUse\x12^\n\x18player_item_use_on_block\x18\x1f \x01(\x0b\x32$.df.plugin.PlayerItemUseOnBlockEventH\x00R\x14playerItemUseOnBlock\x12\x61\n\x19player_item_use_on_entity\x18 \x01(\x0b\x32%.df.plugin.PlayerItemUseOnEntityEventH\x00R\x15playerItemUseOnEntity\x12S\n\x13player_item_release\x18! \x01(\x0b\x32!.df.plugin.PlayerItemReleaseEventH\x00R\x11playerItemRelease\x12S\n\x13player_item_consume\x18\" \x01(\x0b\x32!.df.plugin.PlayerItemConsumeEventH\x00R\x11playerItemConsume\x12V\n\x14player_attack_entity\x18# \x01(\x0b\x32\".df.plugin.PlayerAttackEntityEventH\x00R\x12playerAttackEntity\x12\\\n\x16player_experience_gain\x18$ \x01(\x0b\x32$.df.plugin.PlayerExperienceGainEventH\x00R\x14playerExperienceGain\x12J\n\x10player_punch_air\x18% \x01(\x0b\x32\x1e.df.plugin.PlayerPunchAirEventH\x00R\x0eplayerPunchAir\x12J\n\x10player_sign_edit\x18& \x01(\x0b\x32\x1e.df.plugin.PlayerSignEditEventH\x00R\x0eplayerSignEdit\x12`\n\x18player_lectern_page_turn\x18\' \x01(\x0b\x32%.df.plugin.PlayerLecternPageTurnEventH\x00R\x15playerLecternPageTurn\x12P\n\x12player_item_damage\x18( \x01(\x0b\x32 .df.plugin.PlayerItemDamageEventH\x00R\x10playerItemDamage\x12P\n\x12player_item_pickup\x18) \x01(\x0b\x32 .df.plugin.PlayerItemPickupEventH\x00R\x10playerItemPickup\x12]\n\x17player_held_slot_change\x18* \x01(\x0b\x32$.df.plugin.PlayerHeldSlotChangeEventH\x00R\x14playerHeldSlotChange\x12J\n\x10player_item_drop\x18+ \x01(\x0b\x32\x1e.df.plugin.PlayerItemDropEventH\x00R\x0eplayerItemDrop\x12I\n\x0fplayer_transfer\x18, \x01(\x0b\x32\x1e.df.plugin.PlayerTransferEventH\x00R\x0eplayerTransfer\x12\x33\n\x07\x63ommand\x18- \x01(\x0b\x32\x17.df.plugin.CommandEventH\x00R\x07\x63ommand\x12R\n\x12player_diagnostics\x18. \x01(\x0b\x32!.df.plugin.PlayerDiagnosticsEventH\x00R\x11playerDiagnostics\x12M\n\x11world_liquid_flow\x18\x46 \x01(\x0b\x32\x1f.df.plugin.WorldLiquidFlowEventH\x00R\x0fworldLiquidFlow\x12P\n\x12world_liquid_decay\x18G \x01(\x0b\x32 .df.plugin.WorldLiquidDecayEventH\x00R\x10worldLiquidDecay\x12S\n\x13world_liquid_harden\x18H \x01(\x0b\x32!.df.plugin.WorldLiquidHardenEventH\x00R\x11worldLiquidHarden\x12=\n\x0bworld_sound\x18I \x01(\x0b\x32\x1a.df.plugin.WorldSoundEventH\x00R\nworldSound\x12M\n\x11world_fire_spread\x18J \x01(\x0b\x32\x1f.df.plugin.WorldFireSpreadEventH\x00R\x0fworldFireSpread\x12J\n\x10world_block_burn\x18K \x01(\x0b\x32\x1e.df.plugin.WorldBlockBurnEventH\x00R\x0eworldBlockBurn\x12P\n\x12world_crop_trample\x18L \x01(\x0b\x32 .df.plugin.WorldCropTrampleEventH\x00R\x10worldCropTrample\x12P\n\x12world_leaves_decay\x18M \x01(\x0b\x32 .df.plugin.WorldLeavesDecayEventH\x00R\x10worldLeavesDecay\x12P\n\x12world_entity_spawn\x18N \x01(\x0b\x32 .df.plugin.WorldEntitySpawnEventH\x00R\x10worldEntitySpawn\x12V\n\x14world_entity_despawn\x18O \x01(\x0b\x32\".df.plugin.WorldEntityDespawnEventH\x00R\x12worldEntityDespawn\x12I\n\x0fworld_explosion\x18P \x01(\x0b\x32\x1e.df.plugin.WorldExplosionEventH\x00R\x0eworldExplosion\x12=\n\x0bworld_close\x18Q \x01(\x0b\x32\x1a.df.plugin.WorldCloseEventH\x00R\nworldCloseB\t\n\x07payload\"\x85\x03\n\x0cPluginToHost\x12\x1b\n\tplugin_id\x18\x01 \x01(\tR\x08pluginId\x12.\n\x05hello\x18\n \x01(\x0b\x32\x16.df.plugin.PluginHelloH\x00R\x05hello\x12\x39\n\tsubscribe\x18\x0b \x01(\x0b\x32\x19.df.plugin.EventSubscribeH\x00R\tsubscribe\x12\x46\n\x0bserver_info\x18\x0c \x01(\x0b\x32#.df.plugin.ServerInformationRequestH\x00R\nserverInfo\x12\x32\n\x07\x61\x63tions\x18\x14 \x01(\x0b\x32\x16.df.plugin.ActionBatchH\x00R\x07\x61\x63tions\x12)\n\x03log\x18\x1e \x01(\x0b\x32\x15.df.plugin.LogMessageH\x00R\x03log\x12;\n\x0c\x65vent_result\x18( \x01(\x0b\x32\x16.df.plugin.EventResultH\x00R\x0b\x65ventResultB\t\n\x07payload\"\xd4\x01\n\x0bPluginHello\x12\x12\n\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n\x07version\x18\x02 \x01(\tR\x07version\x12\x1f\n\x0b\x61pi_version\x18\x03 \x01(\tR\napiVersion\x12\x32\n\x08\x63ommands\x18\x04 \x03(\x0b\x32\x16.df.plugin.CommandSpecR\x08\x63ommands\x12\x42\n\x0c\x63ustom_items\x18\x05 \x03(\x0b\x32\x1f.df.plugin.CustomItemDefinitionR\x0b\x63ustomItems\"<\n\nLogMessage\x12\x14\n\x05level\x18\x01 \x01(\tR\x05level\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\">\n\x0e\x45ventSubscribe\x12,\n\x06\x65vents\x18\x01 \x03(\x0e\x32\x14.df.plugin.EventTypeR\x06\x65vents*\x8a\t\n\tEventType\x12\x1a\n\x16\x45VENT_TYPE_UNSPECIFIED\x10\x00\x12\x12\n\x0e\x45VENT_TYPE_ALL\x10\x01\x12\x0f\n\x0bPLAYER_JOIN\x10\n\x12\x0f\n\x0bPLAYER_QUIT\x10\x0b\x12\x0f\n\x0bPLAYER_MOVE\x10\x0c\x12\x0f\n\x0bPLAYER_JUMP\x10\r\x12\x13\n\x0fPLAYER_TELEPORT\x10\x0e\x12\x17\n\x13PLAYER_CHANGE_WORLD\x10\x0f\x12\x18\n\x14PLAYER_TOGGLE_SPRINT\x10\x10\x12\x17\n\x13PLAYER_TOGGLE_SNEAK\x10\x11\x12\x08\n\x04\x43HAT\x10\x12\x12\x14\n\x10PLAYER_FOOD_LOSS\x10\x13\x12\x0f\n\x0bPLAYER_HEAL\x10\x14\x12\x0f\n\x0bPLAYER_HURT\x10\x15\x12\x10\n\x0cPLAYER_DEATH\x10\x16\x12\x12\n\x0ePLAYER_RESPAWN\x10\x17\x12\x16\n\x12PLAYER_SKIN_CHANGE\x10\x18\x12\x1a\n\x16PLAYER_FIRE_EXTINGUISH\x10\x19\x12\x16\n\x12PLAYER_START_BREAK\x10\x1a\x12\x16\n\x12PLAYER_BLOCK_BREAK\x10\x1b\x12\x16\n\x12PLAYER_BLOCK_PLACE\x10\x1c\x12\x15\n\x11PLAYER_BLOCK_PICK\x10\x1d\x12\x13\n\x0fPLAYER_ITEM_USE\x10\x1e\x12\x1c\n\x18PLAYER_ITEM_USE_ON_BLOCK\x10\x1f\x12\x1d\n\x19PLAYER_ITEM_USE_ON_ENTITY\x10 \x12\x17\n\x13PLAYER_ITEM_RELEASE\x10!\x12\x17\n\x13PLAYER_ITEM_CONSUME\x10\"\x12\x18\n\x14PLAYER_ATTACK_ENTITY\x10#\x12\x1a\n\x16PLAYER_EXPERIENCE_GAIN\x10$\x12\x14\n\x10PLAYER_PUNCH_AIR\x10%\x12\x14\n\x10PLAYER_SIGN_EDIT\x10&\x12\x1c\n\x18PLAYER_LECTERN_PAGE_TURN\x10\'\x12\x16\n\x12PLAYER_ITEM_DAMAGE\x10(\x12\x16\n\x12PLAYER_ITEM_PICKUP\x10)\x12\x1b\n\x17PLAYER_HELD_SLOT_CHANGE\x10*\x12\x14\n\x10PLAYER_ITEM_DROP\x10+\x12\x13\n\x0fPLAYER_TRANSFER\x10,\x12\x0b\n\x07\x43OMMAND\x10-\x12\x16\n\x12PLAYER_DIAGNOSTICS\x10.\x12\x15\n\x11WORLD_LIQUID_FLOW\x10\x46\x12\x16\n\x12WORLD_LIQUID_DECAY\x10G\x12\x17\n\x13WORLD_LIQUID_HARDEN\x10H\x12\x0f\n\x0bWORLD_SOUND\x10I\x12\x15\n\x11WORLD_FIRE_SPREAD\x10J\x12\x14\n\x10WORLD_BLOCK_BURN\x10K\x12\x16\n\x12WORLD_CROP_TRAMPLE\x10L\x12\x16\n\x12WORLD_LEAVES_DECAY\x10M\x12\x16\n\x12WORLD_ENTITY_SPAWN\x10N\x12\x18\n\x14WORLD_ENTITY_DESPAWN\x10O\x12\x13\n\x0fWORLD_EXPLOSION\x10P\x12\x0f\n\x0bWORLD_CLOSE\x10Q2M\n\x06Plugin\x12\x43\n\x0b\x45ventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x01\x30\x01\x42\x8a\x01\n\rcom.df.pluginB\x0bPluginProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -38,28 +38,28 @@ if not _descriptor._USE_C_DESCRIPTORS: _globals['DESCRIPTOR']._loaded_options = None _globals['DESCRIPTOR']._serialized_options = b'\n\rcom.df.pluginB\013PluginProtoP\001Z\'github.com/secmc/plugin/proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin' - _globals['_EVENTTYPE']._serialized_start=5258 - _globals['_EVENTTYPE']._serialized_end=6420 + _globals['_EVENTTYPE']._serialized_start=5322 + _globals['_EVENTTYPE']._serialized_end=6484 _globals['_HOSTTOPLUGIN']._serialized_start=130 - _globals['_HOSTTOPLUGIN']._serialized_end=408 - _globals['_SERVERINFORMATIONREQUEST']._serialized_start=410 - _globals['_SERVERINFORMATIONREQUEST']._serialized_end=436 - _globals['_SERVERINFORMATIONRESPONSE']._serialized_start=438 - _globals['_SERVERINFORMATIONRESPONSE']._serialized_end=491 - _globals['_HOSTHELLO']._serialized_start=493 - _globals['_HOSTHELLO']._serialized_end=537 - _globals['_HOSTSHUTDOWN']._serialized_start=539 - _globals['_HOSTSHUTDOWN']._serialized_end=577 - _globals['_EVENTENVELOPE']._serialized_start=580 - _globals['_EVENTENVELOPE']._serialized_end=4522 - _globals['_PLUGINTOHOST']._serialized_start=4525 - _globals['_PLUGINTOHOST']._serialized_end=4914 - _globals['_PLUGINHELLO']._serialized_start=4917 - _globals['_PLUGINHELLO']._serialized_end=5129 - _globals['_LOGMESSAGE']._serialized_start=5131 - _globals['_LOGMESSAGE']._serialized_end=5191 - _globals['_EVENTSUBSCRIBE']._serialized_start=5193 - _globals['_EVENTSUBSCRIBE']._serialized_end=5255 - _globals['_PLUGIN']._serialized_start=6422 - _globals['_PLUGIN']._serialized_end=6499 + _globals['_HOSTTOPLUGIN']._serialized_end=472 + _globals['_SERVERINFORMATIONREQUEST']._serialized_start=474 + _globals['_SERVERINFORMATIONREQUEST']._serialized_end=500 + _globals['_SERVERINFORMATIONRESPONSE']._serialized_start=502 + _globals['_SERVERINFORMATIONRESPONSE']._serialized_end=555 + _globals['_HOSTHELLO']._serialized_start=557 + _globals['_HOSTHELLO']._serialized_end=601 + _globals['_HOSTSHUTDOWN']._serialized_start=603 + _globals['_HOSTSHUTDOWN']._serialized_end=641 + _globals['_EVENTENVELOPE']._serialized_start=644 + _globals['_EVENTENVELOPE']._serialized_end=4586 + _globals['_PLUGINTOHOST']._serialized_start=4589 + _globals['_PLUGINTOHOST']._serialized_end=4978 + _globals['_PLUGINHELLO']._serialized_start=4981 + _globals['_PLUGINHELLO']._serialized_end=5193 + _globals['_LOGMESSAGE']._serialized_start=5195 + _globals['_LOGMESSAGE']._serialized_end=5255 + _globals['_EVENTSUBSCRIBE']._serialized_start=5257 + _globals['_EVENTSUBSCRIBE']._serialized_end=5319 + _globals['_PLUGIN']._serialized_start=6486 + _globals['_PLUGIN']._serialized_end=6563 # @@protoc_insertion_point(module_scope) diff --git a/packages/rust/src/generated/df.plugin.rs b/packages/rust/src/generated/df.plugin.rs index 8942941..469dbfd 100644 --- a/packages/rust/src/generated/df.plugin.rs +++ b/packages/rust/src/generated/df.plugin.rs @@ -20,6 +20,14 @@ pub struct Rotation { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct BBox { + #[prost(message, optional, tag="1")] + pub min: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub max: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, Copy, PartialEq, ::prost::Message)] pub struct BlockPos { #[prost(int32, tag="1")] pub x: i32, @@ -160,6 +168,38 @@ impl GameMode { } } } +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum Difficulty { + Peaceful = 0, + Easy = 1, + Normal = 2, + Hard = 3, +} +impl Difficulty { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + Difficulty::Peaceful => "PEACEFUL", + Difficulty::Easy => "EASY", + Difficulty::Normal => "NORMAL", + Difficulty::Hard => "HARD", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PEACEFUL" => Some(Self::Peaceful), + "EASY" => Some(Self::Easy), + "NORMAL" => Some(Self::Normal), + "HARD" => Some(Self::Hard), + _ => None, + } + } +} /// EffectType mirrors Dragonfly's registered effect IDs for straightforward mapping. /// Keep numeric values aligned with dragonfly/server/entity/effect/register.go. #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] @@ -400,7 +440,7 @@ pub struct ActionBatch { pub struct Action { #[prost(string, optional, tag="1")] pub correlation_id: ::core::option::Option<::prost::alloc::string::String>, - #[prost(oneof="action::Kind", tags="10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 30, 31, 40, 41, 42, 43, 50")] + #[prost(oneof="action::Kind", tags="10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 30, 31, 40, 41, 42, 43, 50, 60, 61, 62, 63, 64, 65, 70, 71, 72, 73")] pub kind: ::core::option::Option, } /// Nested message and enum types in `Action`. @@ -449,6 +489,28 @@ pub mod action { /// Commands #[prost(message, tag="50")] ExecuteCommand(super::ExecuteCommandAction), + /// World configuration and effects + #[prost(message, tag="60")] + WorldSetDefaultGameMode(super::WorldSetDefaultGameModeAction), + #[prost(message, tag="61")] + WorldSetDifficulty(super::WorldSetDifficultyAction), + #[prost(message, tag="62")] + WorldSetTickRange(super::WorldSetTickRangeAction), + #[prost(message, tag="63")] + WorldSetBlock(super::WorldSetBlockAction), + #[prost(message, tag="64")] + WorldPlaySound(super::WorldPlaySoundAction), + #[prost(message, tag="65")] + WorldAddParticle(super::WorldAddParticleAction), + /// World queries + #[prost(message, tag="70")] + WorldQueryEntities(super::WorldQueryEntitiesAction), + #[prost(message, tag="71")] + WorldQueryPlayers(super::WorldQueryPlayersAction), + #[prost(message, tag="72")] + WorldQueryEntitiesWithin(super::WorldQueryEntitiesWithinAction), + #[prost(message, tag="73")] + WorldQueryViewers(super::WorldQueryViewersAction), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -643,6 +705,241 @@ pub struct ExecuteCommandAction { #[prost(string, tag="2")] pub command: ::prost::alloc::string::String, } +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldSetDefaultGameModeAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(enumeration="GameMode", tag="2")] + pub game_mode: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldSetDifficultyAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(enumeration="Difficulty", tag="2")] + pub difficulty: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldSetTickRangeAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(int32, tag="2")] + pub tick_range: i32, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldSetBlockAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub position: ::core::option::Option, + /// nil clears to air + #[prost(message, optional, tag="3")] + pub block: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldPlaySoundAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(enumeration="Sound", tag="2")] + pub sound: i32, + #[prost(message, optional, tag="3")] + pub position: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldAddParticleAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub position: ::core::option::Option, + #[prost(enumeration="ParticleType", tag="3")] + pub particle: i32, + /// used for block-based particles when provided + #[prost(message, optional, tag="4")] + pub block: ::core::option::Option, + /// used for punch_block when provided + #[prost(int32, optional, tag="5")] + pub face: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldQueryEntitiesAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldQueryPlayersAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldQueryEntitiesWithinAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub r#box: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldQueryViewersAction { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub position: ::core::option::Option, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionStatus { + #[prost(bool, tag="1")] + pub ok: bool, + #[prost(string, optional, tag="2")] + pub error: ::core::option::Option<::prost::alloc::string::String>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldEntitiesResult { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, repeated, tag="2")] + pub entities: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldEntitiesWithinResult { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub r#box: ::core::option::Option, + #[prost(message, repeated, tag="3")] + pub entities: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldPlayersResult { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, repeated, tag="2")] + pub players: ::prost::alloc::vec::Vec, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct WorldViewersResult { + #[prost(message, optional, tag="1")] + pub world: ::core::option::Option, + #[prost(message, optional, tag="2")] + pub position: ::core::option::Option, + #[prost(string, repeated, tag="3")] + pub viewer_uuids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, +} +#[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct ActionResult { + #[prost(string, tag="1")] + pub correlation_id: ::prost::alloc::string::String, + #[prost(message, optional, tag="2")] + pub status: ::core::option::Option, + #[prost(oneof="action_result::Result", tags="10, 11, 12, 13")] + pub result: ::core::option::Option, +} +/// Nested message and enum types in `ActionResult`. +pub mod action_result { + #[allow(clippy::derive_partial_eq_without_eq)] +#[derive(Clone, PartialEq, ::prost::Oneof)] + pub enum Result { + #[prost(message, tag="10")] + WorldEntities(super::WorldEntitiesResult), + #[prost(message, tag="11")] + WorldPlayers(super::WorldPlayersResult), + #[prost(message, tag="12")] + WorldEntitiesWithin(super::WorldEntitiesWithinResult), + #[prost(message, tag="13")] + WorldViewers(super::WorldViewersResult), + } +} +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] +#[repr(i32)] +pub enum ParticleType { + Unspecified = 0, + ParticleHugeExplosion = 1, + ParticleEndermanTeleport = 2, + ParticleSnowballPoof = 3, + ParticleEggSmash = 4, + ParticleSplash = 5, + ParticleEffect = 6, + ParticleEntityFlame = 7, + ParticleFlame = 8, + ParticleDust = 9, + ParticleBlockForceField = 10, + ParticleBoneMeal = 11, + ParticleEvaporate = 12, + ParticleWaterDrip = 13, + ParticleLavaDrip = 14, + ParticleLava = 15, + ParticleDustPlume = 16, + ParticleBlockBreak = 17, + ParticlePunchBlock = 18, +} +impl ParticleType { + /// String value of the enum field names used in the ProtoBuf definition. + /// + /// The values are not transformed in any way and thus are considered stable + /// (if the ProtoBuf definition does not change) and safe for programmatic use. + pub fn as_str_name(&self) -> &'static str { + match self { + ParticleType::Unspecified => "PARTICLE_TYPE_UNSPECIFIED", + ParticleType::ParticleHugeExplosion => "PARTICLE_HUGE_EXPLOSION", + ParticleType::ParticleEndermanTeleport => "PARTICLE_ENDERMAN_TELEPORT", + ParticleType::ParticleSnowballPoof => "PARTICLE_SNOWBALL_POOF", + ParticleType::ParticleEggSmash => "PARTICLE_EGG_SMASH", + ParticleType::ParticleSplash => "PARTICLE_SPLASH", + ParticleType::ParticleEffect => "PARTICLE_EFFECT", + ParticleType::ParticleEntityFlame => "PARTICLE_ENTITY_FLAME", + ParticleType::ParticleFlame => "PARTICLE_FLAME", + ParticleType::ParticleDust => "PARTICLE_DUST", + ParticleType::ParticleBlockForceField => "PARTICLE_BLOCK_FORCE_FIELD", + ParticleType::ParticleBoneMeal => "PARTICLE_BONE_MEAL", + ParticleType::ParticleEvaporate => "PARTICLE_EVAPORATE", + ParticleType::ParticleWaterDrip => "PARTICLE_WATER_DRIP", + ParticleType::ParticleLavaDrip => "PARTICLE_LAVA_DRIP", + ParticleType::ParticleLava => "PARTICLE_LAVA", + ParticleType::ParticleDustPlume => "PARTICLE_DUST_PLUME", + ParticleType::ParticleBlockBreak => "PARTICLE_BLOCK_BREAK", + ParticleType::ParticlePunchBlock => "PARTICLE_PUNCH_BLOCK", + } + } + /// Creates an enum from field names used in the ProtoBuf definition. + pub fn from_str_name(value: &str) -> ::core::option::Option { + match value { + "PARTICLE_TYPE_UNSPECIFIED" => Some(Self::Unspecified), + "PARTICLE_HUGE_EXPLOSION" => Some(Self::ParticleHugeExplosion), + "PARTICLE_ENDERMAN_TELEPORT" => Some(Self::ParticleEndermanTeleport), + "PARTICLE_SNOWBALL_POOF" => Some(Self::ParticleSnowballPoof), + "PARTICLE_EGG_SMASH" => Some(Self::ParticleEggSmash), + "PARTICLE_SPLASH" => Some(Self::ParticleSplash), + "PARTICLE_EFFECT" => Some(Self::ParticleEffect), + "PARTICLE_ENTITY_FLAME" => Some(Self::ParticleEntityFlame), + "PARTICLE_FLAME" => Some(Self::ParticleFlame), + "PARTICLE_DUST" => Some(Self::ParticleDust), + "PARTICLE_BLOCK_FORCE_FIELD" => Some(Self::ParticleBlockForceField), + "PARTICLE_BONE_MEAL" => Some(Self::ParticleBoneMeal), + "PARTICLE_EVAPORATE" => Some(Self::ParticleEvaporate), + "PARTICLE_WATER_DRIP" => Some(Self::ParticleWaterDrip), + "PARTICLE_LAVA_DRIP" => Some(Self::ParticleLavaDrip), + "PARTICLE_LAVA" => Some(Self::ParticleLava), + "PARTICLE_DUST_PLUME" => Some(Self::ParticleDustPlume), + "PARTICLE_BLOCK_BREAK" => Some(Self::ParticleBlockBreak), + "PARTICLE_PUNCH_BLOCK" => Some(Self::ParticlePunchBlock), + _ => None, + } + } +} /// Parameter specification for a command. #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] @@ -1488,7 +1785,7 @@ pub struct WorldCloseEvent { pub struct HostToPlugin { #[prost(string, tag="1")] pub plugin_id: ::prost::alloc::string::String, - #[prost(oneof="host_to_plugin::Payload", tags="10, 11, 12, 20")] + #[prost(oneof="host_to_plugin::Payload", tags="10, 11, 12, 20, 21")] pub payload: ::core::option::Option, } /// Nested message and enum types in `HostToPlugin`. @@ -1504,6 +1801,8 @@ pub mod host_to_plugin { ServerInfo(super::ServerInformationResponse), #[prost(message, tag="20")] Event(super::EventEnvelope), + #[prost(message, tag="21")] + ActionResult(super::ActionResult), } } #[allow(clippy::derive_partial_eq_without_eq)] diff --git a/proto/generated/go/actions.pb.go b/proto/generated/go/actions.pb.go index 3c3da9f..f9c48be 100644 --- a/proto/generated/go/actions.pb.go +++ b/proto/generated/go/actions.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: actions.proto package generated @@ -2923,7 +2923,9 @@ const file_actions_proto_rawDesc = "" + "\rPARTICLE_LAVA\x10\x0f\x12\x17\n" + "\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\n" + "\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\n" + - "\x14PARTICLE_PUNCH_BLOCK\x10\x12B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "\x14PARTICLE_PUNCH_BLOCK\x10\x12B\x8b\x01\n" + + "\rcom.df.pluginB\fActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_actions_proto_rawDescOnce sync.Once diff --git a/proto/generated/go/command.pb.go b/proto/generated/go/command.pb.go index 146a56e..4600f4a 100644 --- a/proto/generated/go/command.pb.go +++ b/proto/generated/go/command.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: command.proto package generated @@ -338,7 +338,9 @@ const file_command_proto_rawDesc = "" + "PARAM_BOOL\x10\x03\x12\x11\n" + "\rPARAM_VARARGS\x10\x04\x12\x0e\n" + "\n" + - "PARAM_ENUM\x10\x05B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "PARAM_ENUM\x10\x05B\x8b\x01\n" + + "\rcom.df.pluginB\fCommandProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_command_proto_rawDescOnce sync.Once diff --git a/proto/generated/go/common.pb.go b/proto/generated/go/common.pb.go index c5f177c..438d8d1 100644 --- a/proto/generated/go/common.pb.go +++ b/proto/generated/go/common.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: common.proto package generated @@ -1341,7 +1341,9 @@ const file_common_proto_rawDesc = "" + "\x1aITEM_CATEGORY_CONSTRUCTION\x10\x00\x12\x18\n" + "\x14ITEM_CATEGORY_NATURE\x10\x01\x12\x1b\n" + "\x17ITEM_CATEGORY_EQUIPMENT\x10\x02\x12\x17\n" + - "\x13ITEM_CATEGORY_ITEMS\x10\x03B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "\x13ITEM_CATEGORY_ITEMS\x10\x03B\x8a\x01\n" + + "\rcom.df.pluginB\vCommonProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_common_proto_rawDescOnce sync.Once diff --git a/proto/generated/go/mutations.pb.go b/proto/generated/go/mutations.pb.go index ae2e9de..f1c5768 100644 --- a/proto/generated/go/mutations.pb.go +++ b/proto/generated/go/mutations.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: mutations.proto package generated @@ -1155,7 +1155,9 @@ const file_mutations_proto_rawDesc = "" + "\r_entity_uuidsB\t\n" + "\a_blocksB\x13\n" + "\x11_item_drop_chanceB\r\n" + - "\v_spawn_fireB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "\v_spawn_fireB\x8d\x01\n" + + "\rcom.df.pluginB\x0eMutationsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_mutations_proto_rawDescOnce sync.Once diff --git a/proto/generated/go/player_events.pb.go b/proto/generated/go/player_events.pb.go index dc9d03f..fe2c301 100644 --- a/proto/generated/go/player_events.pb.go +++ b/proto/generated/go/player_events.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: player_events.proto package generated @@ -2902,7 +2902,9 @@ const file_player_events_proto_rawDesc = "" + "\x16average_end_frame_time\x18\t \x01(\x01R\x13averageEndFrameTime\x12C\n" + "\x1eaverage_remainder_time_percent\x18\n" + " \x01(\x01R\x1baverageRemainderTimePercent\x12G\n" + - " average_unaccounted_time_percent\x18\v \x01(\x01R\x1daverageUnaccountedTimePercentB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + " average_unaccounted_time_percent\x18\v \x01(\x01R\x1daverageUnaccountedTimePercentB\x90\x01\n" + + "\rcom.df.pluginB\x11PlayerEventsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_player_events_proto_rawDescOnce sync.Once diff --git a/proto/generated/go/plugin.pb.go b/proto/generated/go/plugin.pb.go index d323822..f441f06 100644 --- a/proto/generated/go/plugin.pb.go +++ b/proto/generated/go/plugin.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: plugin.proto package generated @@ -350,9 +350,8 @@ func (*HostToPlugin_ServerInfo) isHostToPlugin_Payload() {} func (*HostToPlugin_Event) isHostToPlugin_Payload() {} -<<<<<<< HEAD:proto/generated/plugin.pb.go func (*HostToPlugin_ActionResult) isHostToPlugin_Payload() {} -======= + type ServerInformationRequest struct { state protoimpl.MessageState `protogen:"open.v1"` unknownFields protoimpl.UnknownFields @@ -432,7 +431,6 @@ func (x *ServerInformationResponse) GetPlugins() []string { } return nil } ->>>>>>> main:proto/generated/go/plugin.pb.go type HostHello struct { state protoimpl.MessageState `protogen:"open.v1"` @@ -1710,30 +1708,20 @@ var File_plugin_proto protoreflect.FileDescriptor const file_plugin_proto_rawDesc = "" + "\n" + -<<<<<<< HEAD:proto/generated/plugin.pb.go - "\fplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\fcommon.proto\"\x8d\x02\n" + -======= - "\fplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\fcommon.proto\"\x96\x02\n" + ->>>>>>> main:proto/generated/go/plugin.pb.go + "\fplugin.proto\x12\tdf.plugin\x1a\x13player_events.proto\x1a\x12world_events.proto\x1a\rcommand.proto\x1a\ractions.proto\x1a\x0fmutations.proto\x1a\fcommon.proto\"\xd6\x02\n" + "\fHostToPlugin\x12\x1b\n" + "\tplugin_id\x18\x01 \x01(\tR\bpluginId\x12,\n" + "\x05hello\x18\n" + " \x01(\v2\x14.df.plugin.HostHelloH\x00R\x05hello\x125\n" + -<<<<<<< HEAD:proto/generated/plugin.pb.go - "\bshutdown\x18\v \x01(\v2\x17.df.plugin.HostShutdownH\x00R\bshutdown\x120\n" + - "\x05event\x18\x14 \x01(\v2\x18.df.plugin.EventEnvelopeH\x00R\x05event\x12>\n" + - "\raction_result\x18\x15 \x01(\v2\x17.df.plugin.ActionResultH\x00R\factionResultB\t\n" + - "\apayload\",\n" + -======= "\bshutdown\x18\v \x01(\v2\x17.df.plugin.HostShutdownH\x00R\bshutdown\x12G\n" + "\vserver_info\x18\f \x01(\v2$.df.plugin.ServerInformationResponseH\x00R\n" + "serverInfo\x120\n" + - "\x05event\x18\x14 \x01(\v2\x18.df.plugin.EventEnvelopeH\x00R\x05eventB\t\n" + + "\x05event\x18\x14 \x01(\v2\x18.df.plugin.EventEnvelopeH\x00R\x05event\x12>\n" + + "\raction_result\x18\x15 \x01(\v2\x17.df.plugin.ActionResultH\x00R\factionResultB\t\n" + "\apayload\"\x1a\n" + "\x18ServerInformationRequest\"5\n" + "\x19ServerInformationResponse\x12\x18\n" + "\aplugins\x18\x01 \x03(\tR\aplugins\",\n" + ->>>>>>> main:proto/generated/go/plugin.pb.go "\tHostHello\x12\x1f\n" + "\vapi_version\x18\x01 \x01(\tR\n" + "apiVersion\"&\n" + @@ -1881,7 +1869,9 @@ const file_plugin_proto_rawDesc = "" + "\x0fWORLD_EXPLOSION\x10P\x12\x0f\n" + "\vWORLD_CLOSE\x10Q2M\n" + "\x06Plugin\x12C\n" + - "\vEventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x010\x01B)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "\vEventStream\x12\x17.df.plugin.PluginToHost\x1a\x17.df.plugin.HostToPlugin(\x010\x01B\x8a\x01\n" + + "\rcom.df.pluginB\vPluginProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_plugin_proto_rawDescOnce sync.Once @@ -1900,140 +1890,6 @@ var file_plugin_proto_msgTypes = make([]protoimpl.MessageInfo, 10) var file_plugin_proto_goTypes = []any{ (EventType)(0), // 0: df.plugin.EventType (*HostToPlugin)(nil), // 1: df.plugin.HostToPlugin -<<<<<<< HEAD:proto/generated/plugin.pb.go - (*HostHello)(nil), // 2: df.plugin.HostHello - (*HostShutdown)(nil), // 3: df.plugin.HostShutdown - (*EventEnvelope)(nil), // 4: df.plugin.EventEnvelope - (*PluginToHost)(nil), // 5: df.plugin.PluginToHost - (*PluginHello)(nil), // 6: df.plugin.PluginHello - (*LogMessage)(nil), // 7: df.plugin.LogMessage - (*EventSubscribe)(nil), // 8: df.plugin.EventSubscribe - (*ActionResult)(nil), // 9: df.plugin.ActionResult - (*PlayerJoinEvent)(nil), // 10: df.plugin.PlayerJoinEvent - (*PlayerQuitEvent)(nil), // 11: df.plugin.PlayerQuitEvent - (*PlayerMoveEvent)(nil), // 12: df.plugin.PlayerMoveEvent - (*PlayerJumpEvent)(nil), // 13: df.plugin.PlayerJumpEvent - (*PlayerTeleportEvent)(nil), // 14: df.plugin.PlayerTeleportEvent - (*PlayerChangeWorldEvent)(nil), // 15: df.plugin.PlayerChangeWorldEvent - (*PlayerToggleSprintEvent)(nil), // 16: df.plugin.PlayerToggleSprintEvent - (*PlayerToggleSneakEvent)(nil), // 17: df.plugin.PlayerToggleSneakEvent - (*ChatEvent)(nil), // 18: df.plugin.ChatEvent - (*PlayerFoodLossEvent)(nil), // 19: df.plugin.PlayerFoodLossEvent - (*PlayerHealEvent)(nil), // 20: df.plugin.PlayerHealEvent - (*PlayerHurtEvent)(nil), // 21: df.plugin.PlayerHurtEvent - (*PlayerDeathEvent)(nil), // 22: df.plugin.PlayerDeathEvent - (*PlayerRespawnEvent)(nil), // 23: df.plugin.PlayerRespawnEvent - (*PlayerSkinChangeEvent)(nil), // 24: df.plugin.PlayerSkinChangeEvent - (*PlayerFireExtinguishEvent)(nil), // 25: df.plugin.PlayerFireExtinguishEvent - (*PlayerStartBreakEvent)(nil), // 26: df.plugin.PlayerStartBreakEvent - (*BlockBreakEvent)(nil), // 27: df.plugin.BlockBreakEvent - (*PlayerBlockPlaceEvent)(nil), // 28: df.plugin.PlayerBlockPlaceEvent - (*PlayerBlockPickEvent)(nil), // 29: df.plugin.PlayerBlockPickEvent - (*PlayerItemUseEvent)(nil), // 30: df.plugin.PlayerItemUseEvent - (*PlayerItemUseOnBlockEvent)(nil), // 31: df.plugin.PlayerItemUseOnBlockEvent - (*PlayerItemUseOnEntityEvent)(nil), // 32: df.plugin.PlayerItemUseOnEntityEvent - (*PlayerItemReleaseEvent)(nil), // 33: df.plugin.PlayerItemReleaseEvent - (*PlayerItemConsumeEvent)(nil), // 34: df.plugin.PlayerItemConsumeEvent - (*PlayerAttackEntityEvent)(nil), // 35: df.plugin.PlayerAttackEntityEvent - (*PlayerExperienceGainEvent)(nil), // 36: df.plugin.PlayerExperienceGainEvent - (*PlayerPunchAirEvent)(nil), // 37: df.plugin.PlayerPunchAirEvent - (*PlayerSignEditEvent)(nil), // 38: df.plugin.PlayerSignEditEvent - (*PlayerLecternPageTurnEvent)(nil), // 39: df.plugin.PlayerLecternPageTurnEvent - (*PlayerItemDamageEvent)(nil), // 40: df.plugin.PlayerItemDamageEvent - (*PlayerItemPickupEvent)(nil), // 41: df.plugin.PlayerItemPickupEvent - (*PlayerHeldSlotChangeEvent)(nil), // 42: df.plugin.PlayerHeldSlotChangeEvent - (*PlayerItemDropEvent)(nil), // 43: df.plugin.PlayerItemDropEvent - (*PlayerTransferEvent)(nil), // 44: df.plugin.PlayerTransferEvent - (*CommandEvent)(nil), // 45: df.plugin.CommandEvent - (*PlayerDiagnosticsEvent)(nil), // 46: df.plugin.PlayerDiagnosticsEvent - (*WorldLiquidFlowEvent)(nil), // 47: df.plugin.WorldLiquidFlowEvent - (*WorldLiquidDecayEvent)(nil), // 48: df.plugin.WorldLiquidDecayEvent - (*WorldLiquidHardenEvent)(nil), // 49: df.plugin.WorldLiquidHardenEvent - (*WorldSoundEvent)(nil), // 50: df.plugin.WorldSoundEvent - (*WorldFireSpreadEvent)(nil), // 51: df.plugin.WorldFireSpreadEvent - (*WorldBlockBurnEvent)(nil), // 52: df.plugin.WorldBlockBurnEvent - (*WorldCropTrampleEvent)(nil), // 53: df.plugin.WorldCropTrampleEvent - (*WorldLeavesDecayEvent)(nil), // 54: df.plugin.WorldLeavesDecayEvent - (*WorldEntitySpawnEvent)(nil), // 55: df.plugin.WorldEntitySpawnEvent - (*WorldEntityDespawnEvent)(nil), // 56: df.plugin.WorldEntityDespawnEvent - (*WorldExplosionEvent)(nil), // 57: df.plugin.WorldExplosionEvent - (*WorldCloseEvent)(nil), // 58: df.plugin.WorldCloseEvent - (*ActionBatch)(nil), // 59: df.plugin.ActionBatch - (*EventResult)(nil), // 60: df.plugin.EventResult - (*CommandSpec)(nil), // 61: df.plugin.CommandSpec - (*CustomItemDefinition)(nil), // 62: df.plugin.CustomItemDefinition -} -var file_plugin_proto_depIdxs = []int32{ - 2, // 0: df.plugin.HostToPlugin.hello:type_name -> df.plugin.HostHello - 3, // 1: df.plugin.HostToPlugin.shutdown:type_name -> df.plugin.HostShutdown - 4, // 2: df.plugin.HostToPlugin.event:type_name -> df.plugin.EventEnvelope - 9, // 3: df.plugin.HostToPlugin.action_result:type_name -> df.plugin.ActionResult - 0, // 4: df.plugin.EventEnvelope.type:type_name -> df.plugin.EventType - 10, // 5: df.plugin.EventEnvelope.player_join:type_name -> df.plugin.PlayerJoinEvent - 11, // 6: df.plugin.EventEnvelope.player_quit:type_name -> df.plugin.PlayerQuitEvent - 12, // 7: df.plugin.EventEnvelope.player_move:type_name -> df.plugin.PlayerMoveEvent - 13, // 8: df.plugin.EventEnvelope.player_jump:type_name -> df.plugin.PlayerJumpEvent - 14, // 9: df.plugin.EventEnvelope.player_teleport:type_name -> df.plugin.PlayerTeleportEvent - 15, // 10: df.plugin.EventEnvelope.player_change_world:type_name -> df.plugin.PlayerChangeWorldEvent - 16, // 11: df.plugin.EventEnvelope.player_toggle_sprint:type_name -> df.plugin.PlayerToggleSprintEvent - 17, // 12: df.plugin.EventEnvelope.player_toggle_sneak:type_name -> df.plugin.PlayerToggleSneakEvent - 18, // 13: df.plugin.EventEnvelope.chat:type_name -> df.plugin.ChatEvent - 19, // 14: df.plugin.EventEnvelope.player_food_loss:type_name -> df.plugin.PlayerFoodLossEvent - 20, // 15: df.plugin.EventEnvelope.player_heal:type_name -> df.plugin.PlayerHealEvent - 21, // 16: df.plugin.EventEnvelope.player_hurt:type_name -> df.plugin.PlayerHurtEvent - 22, // 17: df.plugin.EventEnvelope.player_death:type_name -> df.plugin.PlayerDeathEvent - 23, // 18: df.plugin.EventEnvelope.player_respawn:type_name -> df.plugin.PlayerRespawnEvent - 24, // 19: df.plugin.EventEnvelope.player_skin_change:type_name -> df.plugin.PlayerSkinChangeEvent - 25, // 20: df.plugin.EventEnvelope.player_fire_extinguish:type_name -> df.plugin.PlayerFireExtinguishEvent - 26, // 21: df.plugin.EventEnvelope.player_start_break:type_name -> df.plugin.PlayerStartBreakEvent - 27, // 22: df.plugin.EventEnvelope.block_break:type_name -> df.plugin.BlockBreakEvent - 28, // 23: df.plugin.EventEnvelope.player_block_place:type_name -> df.plugin.PlayerBlockPlaceEvent - 29, // 24: df.plugin.EventEnvelope.player_block_pick:type_name -> df.plugin.PlayerBlockPickEvent - 30, // 25: df.plugin.EventEnvelope.player_item_use:type_name -> df.plugin.PlayerItemUseEvent - 31, // 26: df.plugin.EventEnvelope.player_item_use_on_block:type_name -> df.plugin.PlayerItemUseOnBlockEvent - 32, // 27: df.plugin.EventEnvelope.player_item_use_on_entity:type_name -> df.plugin.PlayerItemUseOnEntityEvent - 33, // 28: df.plugin.EventEnvelope.player_item_release:type_name -> df.plugin.PlayerItemReleaseEvent - 34, // 29: df.plugin.EventEnvelope.player_item_consume:type_name -> df.plugin.PlayerItemConsumeEvent - 35, // 30: df.plugin.EventEnvelope.player_attack_entity:type_name -> df.plugin.PlayerAttackEntityEvent - 36, // 31: df.plugin.EventEnvelope.player_experience_gain:type_name -> df.plugin.PlayerExperienceGainEvent - 37, // 32: df.plugin.EventEnvelope.player_punch_air:type_name -> df.plugin.PlayerPunchAirEvent - 38, // 33: df.plugin.EventEnvelope.player_sign_edit:type_name -> df.plugin.PlayerSignEditEvent - 39, // 34: df.plugin.EventEnvelope.player_lectern_page_turn:type_name -> df.plugin.PlayerLecternPageTurnEvent - 40, // 35: df.plugin.EventEnvelope.player_item_damage:type_name -> df.plugin.PlayerItemDamageEvent - 41, // 36: df.plugin.EventEnvelope.player_item_pickup:type_name -> df.plugin.PlayerItemPickupEvent - 42, // 37: df.plugin.EventEnvelope.player_held_slot_change:type_name -> df.plugin.PlayerHeldSlotChangeEvent - 43, // 38: df.plugin.EventEnvelope.player_item_drop:type_name -> df.plugin.PlayerItemDropEvent - 44, // 39: df.plugin.EventEnvelope.player_transfer:type_name -> df.plugin.PlayerTransferEvent - 45, // 40: df.plugin.EventEnvelope.command:type_name -> df.plugin.CommandEvent - 46, // 41: df.plugin.EventEnvelope.player_diagnostics:type_name -> df.plugin.PlayerDiagnosticsEvent - 47, // 42: df.plugin.EventEnvelope.world_liquid_flow:type_name -> df.plugin.WorldLiquidFlowEvent - 48, // 43: df.plugin.EventEnvelope.world_liquid_decay:type_name -> df.plugin.WorldLiquidDecayEvent - 49, // 44: df.plugin.EventEnvelope.world_liquid_harden:type_name -> df.plugin.WorldLiquidHardenEvent - 50, // 45: df.plugin.EventEnvelope.world_sound:type_name -> df.plugin.WorldSoundEvent - 51, // 46: df.plugin.EventEnvelope.world_fire_spread:type_name -> df.plugin.WorldFireSpreadEvent - 52, // 47: df.plugin.EventEnvelope.world_block_burn:type_name -> df.plugin.WorldBlockBurnEvent - 53, // 48: df.plugin.EventEnvelope.world_crop_trample:type_name -> df.plugin.WorldCropTrampleEvent - 54, // 49: df.plugin.EventEnvelope.world_leaves_decay:type_name -> df.plugin.WorldLeavesDecayEvent - 55, // 50: df.plugin.EventEnvelope.world_entity_spawn:type_name -> df.plugin.WorldEntitySpawnEvent - 56, // 51: df.plugin.EventEnvelope.world_entity_despawn:type_name -> df.plugin.WorldEntityDespawnEvent - 57, // 52: df.plugin.EventEnvelope.world_explosion:type_name -> df.plugin.WorldExplosionEvent - 58, // 53: df.plugin.EventEnvelope.world_close:type_name -> df.plugin.WorldCloseEvent - 6, // 54: df.plugin.PluginToHost.hello:type_name -> df.plugin.PluginHello - 8, // 55: df.plugin.PluginToHost.subscribe:type_name -> df.plugin.EventSubscribe - 59, // 56: df.plugin.PluginToHost.actions:type_name -> df.plugin.ActionBatch - 7, // 57: df.plugin.PluginToHost.log:type_name -> df.plugin.LogMessage - 60, // 58: df.plugin.PluginToHost.event_result:type_name -> df.plugin.EventResult - 61, // 59: df.plugin.PluginHello.commands:type_name -> df.plugin.CommandSpec - 62, // 60: df.plugin.PluginHello.custom_items:type_name -> df.plugin.CustomItemDefinition - 0, // 61: df.plugin.EventSubscribe.events:type_name -> df.plugin.EventType - 5, // 62: df.plugin.Plugin.EventStream:input_type -> df.plugin.PluginToHost - 1, // 63: df.plugin.Plugin.EventStream:output_type -> df.plugin.HostToPlugin - 63, // [63:64] is the sub-list for method output_type - 62, // [62:63] is the sub-list for method input_type - 62, // [62:62] is the sub-list for extension type_name - 62, // [62:62] is the sub-list for extension extendee - 0, // [0:62] is the sub-list for field type_name -======= (*ServerInformationRequest)(nil), // 2: df.plugin.ServerInformationRequest (*ServerInformationResponse)(nil), // 3: df.plugin.ServerInformationResponse (*HostHello)(nil), // 4: df.plugin.HostHello @@ -2043,132 +1899,133 @@ var file_plugin_proto_depIdxs = []int32{ (*PluginHello)(nil), // 8: df.plugin.PluginHello (*LogMessage)(nil), // 9: df.plugin.LogMessage (*EventSubscribe)(nil), // 10: df.plugin.EventSubscribe - (*PlayerJoinEvent)(nil), // 11: df.plugin.PlayerJoinEvent - (*PlayerQuitEvent)(nil), // 12: df.plugin.PlayerQuitEvent - (*PlayerMoveEvent)(nil), // 13: df.plugin.PlayerMoveEvent - (*PlayerJumpEvent)(nil), // 14: df.plugin.PlayerJumpEvent - (*PlayerTeleportEvent)(nil), // 15: df.plugin.PlayerTeleportEvent - (*PlayerChangeWorldEvent)(nil), // 16: df.plugin.PlayerChangeWorldEvent - (*PlayerToggleSprintEvent)(nil), // 17: df.plugin.PlayerToggleSprintEvent - (*PlayerToggleSneakEvent)(nil), // 18: df.plugin.PlayerToggleSneakEvent - (*ChatEvent)(nil), // 19: df.plugin.ChatEvent - (*PlayerFoodLossEvent)(nil), // 20: df.plugin.PlayerFoodLossEvent - (*PlayerHealEvent)(nil), // 21: df.plugin.PlayerHealEvent - (*PlayerHurtEvent)(nil), // 22: df.plugin.PlayerHurtEvent - (*PlayerDeathEvent)(nil), // 23: df.plugin.PlayerDeathEvent - (*PlayerRespawnEvent)(nil), // 24: df.plugin.PlayerRespawnEvent - (*PlayerSkinChangeEvent)(nil), // 25: df.plugin.PlayerSkinChangeEvent - (*PlayerFireExtinguishEvent)(nil), // 26: df.plugin.PlayerFireExtinguishEvent - (*PlayerStartBreakEvent)(nil), // 27: df.plugin.PlayerStartBreakEvent - (*BlockBreakEvent)(nil), // 28: df.plugin.BlockBreakEvent - (*PlayerBlockPlaceEvent)(nil), // 29: df.plugin.PlayerBlockPlaceEvent - (*PlayerBlockPickEvent)(nil), // 30: df.plugin.PlayerBlockPickEvent - (*PlayerItemUseEvent)(nil), // 31: df.plugin.PlayerItemUseEvent - (*PlayerItemUseOnBlockEvent)(nil), // 32: df.plugin.PlayerItemUseOnBlockEvent - (*PlayerItemUseOnEntityEvent)(nil), // 33: df.plugin.PlayerItemUseOnEntityEvent - (*PlayerItemReleaseEvent)(nil), // 34: df.plugin.PlayerItemReleaseEvent - (*PlayerItemConsumeEvent)(nil), // 35: df.plugin.PlayerItemConsumeEvent - (*PlayerAttackEntityEvent)(nil), // 36: df.plugin.PlayerAttackEntityEvent - (*PlayerExperienceGainEvent)(nil), // 37: df.plugin.PlayerExperienceGainEvent - (*PlayerPunchAirEvent)(nil), // 38: df.plugin.PlayerPunchAirEvent - (*PlayerSignEditEvent)(nil), // 39: df.plugin.PlayerSignEditEvent - (*PlayerLecternPageTurnEvent)(nil), // 40: df.plugin.PlayerLecternPageTurnEvent - (*PlayerItemDamageEvent)(nil), // 41: df.plugin.PlayerItemDamageEvent - (*PlayerItemPickupEvent)(nil), // 42: df.plugin.PlayerItemPickupEvent - (*PlayerHeldSlotChangeEvent)(nil), // 43: df.plugin.PlayerHeldSlotChangeEvent - (*PlayerItemDropEvent)(nil), // 44: df.plugin.PlayerItemDropEvent - (*PlayerTransferEvent)(nil), // 45: df.plugin.PlayerTransferEvent - (*CommandEvent)(nil), // 46: df.plugin.CommandEvent - (*PlayerDiagnosticsEvent)(nil), // 47: df.plugin.PlayerDiagnosticsEvent - (*WorldLiquidFlowEvent)(nil), // 48: df.plugin.WorldLiquidFlowEvent - (*WorldLiquidDecayEvent)(nil), // 49: df.plugin.WorldLiquidDecayEvent - (*WorldLiquidHardenEvent)(nil), // 50: df.plugin.WorldLiquidHardenEvent - (*WorldSoundEvent)(nil), // 51: df.plugin.WorldSoundEvent - (*WorldFireSpreadEvent)(nil), // 52: df.plugin.WorldFireSpreadEvent - (*WorldBlockBurnEvent)(nil), // 53: df.plugin.WorldBlockBurnEvent - (*WorldCropTrampleEvent)(nil), // 54: df.plugin.WorldCropTrampleEvent - (*WorldLeavesDecayEvent)(nil), // 55: df.plugin.WorldLeavesDecayEvent - (*WorldEntitySpawnEvent)(nil), // 56: df.plugin.WorldEntitySpawnEvent - (*WorldEntityDespawnEvent)(nil), // 57: df.plugin.WorldEntityDespawnEvent - (*WorldExplosionEvent)(nil), // 58: df.plugin.WorldExplosionEvent - (*WorldCloseEvent)(nil), // 59: df.plugin.WorldCloseEvent - (*ActionBatch)(nil), // 60: df.plugin.ActionBatch - (*EventResult)(nil), // 61: df.plugin.EventResult - (*CommandSpec)(nil), // 62: df.plugin.CommandSpec - (*CustomItemDefinition)(nil), // 63: df.plugin.CustomItemDefinition + (*ActionResult)(nil), // 11: df.plugin.ActionResult + (*PlayerJoinEvent)(nil), // 12: df.plugin.PlayerJoinEvent + (*PlayerQuitEvent)(nil), // 13: df.plugin.PlayerQuitEvent + (*PlayerMoveEvent)(nil), // 14: df.plugin.PlayerMoveEvent + (*PlayerJumpEvent)(nil), // 15: df.plugin.PlayerJumpEvent + (*PlayerTeleportEvent)(nil), // 16: df.plugin.PlayerTeleportEvent + (*PlayerChangeWorldEvent)(nil), // 17: df.plugin.PlayerChangeWorldEvent + (*PlayerToggleSprintEvent)(nil), // 18: df.plugin.PlayerToggleSprintEvent + (*PlayerToggleSneakEvent)(nil), // 19: df.plugin.PlayerToggleSneakEvent + (*ChatEvent)(nil), // 20: df.plugin.ChatEvent + (*PlayerFoodLossEvent)(nil), // 21: df.plugin.PlayerFoodLossEvent + (*PlayerHealEvent)(nil), // 22: df.plugin.PlayerHealEvent + (*PlayerHurtEvent)(nil), // 23: df.plugin.PlayerHurtEvent + (*PlayerDeathEvent)(nil), // 24: df.plugin.PlayerDeathEvent + (*PlayerRespawnEvent)(nil), // 25: df.plugin.PlayerRespawnEvent + (*PlayerSkinChangeEvent)(nil), // 26: df.plugin.PlayerSkinChangeEvent + (*PlayerFireExtinguishEvent)(nil), // 27: df.plugin.PlayerFireExtinguishEvent + (*PlayerStartBreakEvent)(nil), // 28: df.plugin.PlayerStartBreakEvent + (*BlockBreakEvent)(nil), // 29: df.plugin.BlockBreakEvent + (*PlayerBlockPlaceEvent)(nil), // 30: df.plugin.PlayerBlockPlaceEvent + (*PlayerBlockPickEvent)(nil), // 31: df.plugin.PlayerBlockPickEvent + (*PlayerItemUseEvent)(nil), // 32: df.plugin.PlayerItemUseEvent + (*PlayerItemUseOnBlockEvent)(nil), // 33: df.plugin.PlayerItemUseOnBlockEvent + (*PlayerItemUseOnEntityEvent)(nil), // 34: df.plugin.PlayerItemUseOnEntityEvent + (*PlayerItemReleaseEvent)(nil), // 35: df.plugin.PlayerItemReleaseEvent + (*PlayerItemConsumeEvent)(nil), // 36: df.plugin.PlayerItemConsumeEvent + (*PlayerAttackEntityEvent)(nil), // 37: df.plugin.PlayerAttackEntityEvent + (*PlayerExperienceGainEvent)(nil), // 38: df.plugin.PlayerExperienceGainEvent + (*PlayerPunchAirEvent)(nil), // 39: df.plugin.PlayerPunchAirEvent + (*PlayerSignEditEvent)(nil), // 40: df.plugin.PlayerSignEditEvent + (*PlayerLecternPageTurnEvent)(nil), // 41: df.plugin.PlayerLecternPageTurnEvent + (*PlayerItemDamageEvent)(nil), // 42: df.plugin.PlayerItemDamageEvent + (*PlayerItemPickupEvent)(nil), // 43: df.plugin.PlayerItemPickupEvent + (*PlayerHeldSlotChangeEvent)(nil), // 44: df.plugin.PlayerHeldSlotChangeEvent + (*PlayerItemDropEvent)(nil), // 45: df.plugin.PlayerItemDropEvent + (*PlayerTransferEvent)(nil), // 46: df.plugin.PlayerTransferEvent + (*CommandEvent)(nil), // 47: df.plugin.CommandEvent + (*PlayerDiagnosticsEvent)(nil), // 48: df.plugin.PlayerDiagnosticsEvent + (*WorldLiquidFlowEvent)(nil), // 49: df.plugin.WorldLiquidFlowEvent + (*WorldLiquidDecayEvent)(nil), // 50: df.plugin.WorldLiquidDecayEvent + (*WorldLiquidHardenEvent)(nil), // 51: df.plugin.WorldLiquidHardenEvent + (*WorldSoundEvent)(nil), // 52: df.plugin.WorldSoundEvent + (*WorldFireSpreadEvent)(nil), // 53: df.plugin.WorldFireSpreadEvent + (*WorldBlockBurnEvent)(nil), // 54: df.plugin.WorldBlockBurnEvent + (*WorldCropTrampleEvent)(nil), // 55: df.plugin.WorldCropTrampleEvent + (*WorldLeavesDecayEvent)(nil), // 56: df.plugin.WorldLeavesDecayEvent + (*WorldEntitySpawnEvent)(nil), // 57: df.plugin.WorldEntitySpawnEvent + (*WorldEntityDespawnEvent)(nil), // 58: df.plugin.WorldEntityDespawnEvent + (*WorldExplosionEvent)(nil), // 59: df.plugin.WorldExplosionEvent + (*WorldCloseEvent)(nil), // 60: df.plugin.WorldCloseEvent + (*ActionBatch)(nil), // 61: df.plugin.ActionBatch + (*EventResult)(nil), // 62: df.plugin.EventResult + (*CommandSpec)(nil), // 63: df.plugin.CommandSpec + (*CustomItemDefinition)(nil), // 64: df.plugin.CustomItemDefinition } var file_plugin_proto_depIdxs = []int32{ 4, // 0: df.plugin.HostToPlugin.hello:type_name -> df.plugin.HostHello 5, // 1: df.plugin.HostToPlugin.shutdown:type_name -> df.plugin.HostShutdown 3, // 2: df.plugin.HostToPlugin.server_info:type_name -> df.plugin.ServerInformationResponse 6, // 3: df.plugin.HostToPlugin.event:type_name -> df.plugin.EventEnvelope - 0, // 4: df.plugin.EventEnvelope.type:type_name -> df.plugin.EventType - 11, // 5: df.plugin.EventEnvelope.player_join:type_name -> df.plugin.PlayerJoinEvent - 12, // 6: df.plugin.EventEnvelope.player_quit:type_name -> df.plugin.PlayerQuitEvent - 13, // 7: df.plugin.EventEnvelope.player_move:type_name -> df.plugin.PlayerMoveEvent - 14, // 8: df.plugin.EventEnvelope.player_jump:type_name -> df.plugin.PlayerJumpEvent - 15, // 9: df.plugin.EventEnvelope.player_teleport:type_name -> df.plugin.PlayerTeleportEvent - 16, // 10: df.plugin.EventEnvelope.player_change_world:type_name -> df.plugin.PlayerChangeWorldEvent - 17, // 11: df.plugin.EventEnvelope.player_toggle_sprint:type_name -> df.plugin.PlayerToggleSprintEvent - 18, // 12: df.plugin.EventEnvelope.player_toggle_sneak:type_name -> df.plugin.PlayerToggleSneakEvent - 19, // 13: df.plugin.EventEnvelope.chat:type_name -> df.plugin.ChatEvent - 20, // 14: df.plugin.EventEnvelope.player_food_loss:type_name -> df.plugin.PlayerFoodLossEvent - 21, // 15: df.plugin.EventEnvelope.player_heal:type_name -> df.plugin.PlayerHealEvent - 22, // 16: df.plugin.EventEnvelope.player_hurt:type_name -> df.plugin.PlayerHurtEvent - 23, // 17: df.plugin.EventEnvelope.player_death:type_name -> df.plugin.PlayerDeathEvent - 24, // 18: df.plugin.EventEnvelope.player_respawn:type_name -> df.plugin.PlayerRespawnEvent - 25, // 19: df.plugin.EventEnvelope.player_skin_change:type_name -> df.plugin.PlayerSkinChangeEvent - 26, // 20: df.plugin.EventEnvelope.player_fire_extinguish:type_name -> df.plugin.PlayerFireExtinguishEvent - 27, // 21: df.plugin.EventEnvelope.player_start_break:type_name -> df.plugin.PlayerStartBreakEvent - 28, // 22: df.plugin.EventEnvelope.block_break:type_name -> df.plugin.BlockBreakEvent - 29, // 23: df.plugin.EventEnvelope.player_block_place:type_name -> df.plugin.PlayerBlockPlaceEvent - 30, // 24: df.plugin.EventEnvelope.player_block_pick:type_name -> df.plugin.PlayerBlockPickEvent - 31, // 25: df.plugin.EventEnvelope.player_item_use:type_name -> df.plugin.PlayerItemUseEvent - 32, // 26: df.plugin.EventEnvelope.player_item_use_on_block:type_name -> df.plugin.PlayerItemUseOnBlockEvent - 33, // 27: df.plugin.EventEnvelope.player_item_use_on_entity:type_name -> df.plugin.PlayerItemUseOnEntityEvent - 34, // 28: df.plugin.EventEnvelope.player_item_release:type_name -> df.plugin.PlayerItemReleaseEvent - 35, // 29: df.plugin.EventEnvelope.player_item_consume:type_name -> df.plugin.PlayerItemConsumeEvent - 36, // 30: df.plugin.EventEnvelope.player_attack_entity:type_name -> df.plugin.PlayerAttackEntityEvent - 37, // 31: df.plugin.EventEnvelope.player_experience_gain:type_name -> df.plugin.PlayerExperienceGainEvent - 38, // 32: df.plugin.EventEnvelope.player_punch_air:type_name -> df.plugin.PlayerPunchAirEvent - 39, // 33: df.plugin.EventEnvelope.player_sign_edit:type_name -> df.plugin.PlayerSignEditEvent - 40, // 34: df.plugin.EventEnvelope.player_lectern_page_turn:type_name -> df.plugin.PlayerLecternPageTurnEvent - 41, // 35: df.plugin.EventEnvelope.player_item_damage:type_name -> df.plugin.PlayerItemDamageEvent - 42, // 36: df.plugin.EventEnvelope.player_item_pickup:type_name -> df.plugin.PlayerItemPickupEvent - 43, // 37: df.plugin.EventEnvelope.player_held_slot_change:type_name -> df.plugin.PlayerHeldSlotChangeEvent - 44, // 38: df.plugin.EventEnvelope.player_item_drop:type_name -> df.plugin.PlayerItemDropEvent - 45, // 39: df.plugin.EventEnvelope.player_transfer:type_name -> df.plugin.PlayerTransferEvent - 46, // 40: df.plugin.EventEnvelope.command:type_name -> df.plugin.CommandEvent - 47, // 41: df.plugin.EventEnvelope.player_diagnostics:type_name -> df.plugin.PlayerDiagnosticsEvent - 48, // 42: df.plugin.EventEnvelope.world_liquid_flow:type_name -> df.plugin.WorldLiquidFlowEvent - 49, // 43: df.plugin.EventEnvelope.world_liquid_decay:type_name -> df.plugin.WorldLiquidDecayEvent - 50, // 44: df.plugin.EventEnvelope.world_liquid_harden:type_name -> df.plugin.WorldLiquidHardenEvent - 51, // 45: df.plugin.EventEnvelope.world_sound:type_name -> df.plugin.WorldSoundEvent - 52, // 46: df.plugin.EventEnvelope.world_fire_spread:type_name -> df.plugin.WorldFireSpreadEvent - 53, // 47: df.plugin.EventEnvelope.world_block_burn:type_name -> df.plugin.WorldBlockBurnEvent - 54, // 48: df.plugin.EventEnvelope.world_crop_trample:type_name -> df.plugin.WorldCropTrampleEvent - 55, // 49: df.plugin.EventEnvelope.world_leaves_decay:type_name -> df.plugin.WorldLeavesDecayEvent - 56, // 50: df.plugin.EventEnvelope.world_entity_spawn:type_name -> df.plugin.WorldEntitySpawnEvent - 57, // 51: df.plugin.EventEnvelope.world_entity_despawn:type_name -> df.plugin.WorldEntityDespawnEvent - 58, // 52: df.plugin.EventEnvelope.world_explosion:type_name -> df.plugin.WorldExplosionEvent - 59, // 53: df.plugin.EventEnvelope.world_close:type_name -> df.plugin.WorldCloseEvent - 8, // 54: df.plugin.PluginToHost.hello:type_name -> df.plugin.PluginHello - 10, // 55: df.plugin.PluginToHost.subscribe:type_name -> df.plugin.EventSubscribe - 2, // 56: df.plugin.PluginToHost.server_info:type_name -> df.plugin.ServerInformationRequest - 60, // 57: df.plugin.PluginToHost.actions:type_name -> df.plugin.ActionBatch - 9, // 58: df.plugin.PluginToHost.log:type_name -> df.plugin.LogMessage - 61, // 59: df.plugin.PluginToHost.event_result:type_name -> df.plugin.EventResult - 62, // 60: df.plugin.PluginHello.commands:type_name -> df.plugin.CommandSpec - 63, // 61: df.plugin.PluginHello.custom_items:type_name -> df.plugin.CustomItemDefinition - 0, // 62: df.plugin.EventSubscribe.events:type_name -> df.plugin.EventType - 7, // 63: df.plugin.Plugin.EventStream:input_type -> df.plugin.PluginToHost - 1, // 64: df.plugin.Plugin.EventStream:output_type -> df.plugin.HostToPlugin - 64, // [64:65] is the sub-list for method output_type - 63, // [63:64] is the sub-list for method input_type - 63, // [63:63] is the sub-list for extension type_name - 63, // [63:63] is the sub-list for extension extendee - 0, // [0:63] is the sub-list for field type_name ->>>>>>> main:proto/generated/go/plugin.pb.go + 11, // 4: df.plugin.HostToPlugin.action_result:type_name -> df.plugin.ActionResult + 0, // 5: df.plugin.EventEnvelope.type:type_name -> df.plugin.EventType + 12, // 6: df.plugin.EventEnvelope.player_join:type_name -> df.plugin.PlayerJoinEvent + 13, // 7: df.plugin.EventEnvelope.player_quit:type_name -> df.plugin.PlayerQuitEvent + 14, // 8: df.plugin.EventEnvelope.player_move:type_name -> df.plugin.PlayerMoveEvent + 15, // 9: df.plugin.EventEnvelope.player_jump:type_name -> df.plugin.PlayerJumpEvent + 16, // 10: df.plugin.EventEnvelope.player_teleport:type_name -> df.plugin.PlayerTeleportEvent + 17, // 11: df.plugin.EventEnvelope.player_change_world:type_name -> df.plugin.PlayerChangeWorldEvent + 18, // 12: df.plugin.EventEnvelope.player_toggle_sprint:type_name -> df.plugin.PlayerToggleSprintEvent + 19, // 13: df.plugin.EventEnvelope.player_toggle_sneak:type_name -> df.plugin.PlayerToggleSneakEvent + 20, // 14: df.plugin.EventEnvelope.chat:type_name -> df.plugin.ChatEvent + 21, // 15: df.plugin.EventEnvelope.player_food_loss:type_name -> df.plugin.PlayerFoodLossEvent + 22, // 16: df.plugin.EventEnvelope.player_heal:type_name -> df.plugin.PlayerHealEvent + 23, // 17: df.plugin.EventEnvelope.player_hurt:type_name -> df.plugin.PlayerHurtEvent + 24, // 18: df.plugin.EventEnvelope.player_death:type_name -> df.plugin.PlayerDeathEvent + 25, // 19: df.plugin.EventEnvelope.player_respawn:type_name -> df.plugin.PlayerRespawnEvent + 26, // 20: df.plugin.EventEnvelope.player_skin_change:type_name -> df.plugin.PlayerSkinChangeEvent + 27, // 21: df.plugin.EventEnvelope.player_fire_extinguish:type_name -> df.plugin.PlayerFireExtinguishEvent + 28, // 22: df.plugin.EventEnvelope.player_start_break:type_name -> df.plugin.PlayerStartBreakEvent + 29, // 23: df.plugin.EventEnvelope.block_break:type_name -> df.plugin.BlockBreakEvent + 30, // 24: df.plugin.EventEnvelope.player_block_place:type_name -> df.plugin.PlayerBlockPlaceEvent + 31, // 25: df.plugin.EventEnvelope.player_block_pick:type_name -> df.plugin.PlayerBlockPickEvent + 32, // 26: df.plugin.EventEnvelope.player_item_use:type_name -> df.plugin.PlayerItemUseEvent + 33, // 27: df.plugin.EventEnvelope.player_item_use_on_block:type_name -> df.plugin.PlayerItemUseOnBlockEvent + 34, // 28: df.plugin.EventEnvelope.player_item_use_on_entity:type_name -> df.plugin.PlayerItemUseOnEntityEvent + 35, // 29: df.plugin.EventEnvelope.player_item_release:type_name -> df.plugin.PlayerItemReleaseEvent + 36, // 30: df.plugin.EventEnvelope.player_item_consume:type_name -> df.plugin.PlayerItemConsumeEvent + 37, // 31: df.plugin.EventEnvelope.player_attack_entity:type_name -> df.plugin.PlayerAttackEntityEvent + 38, // 32: df.plugin.EventEnvelope.player_experience_gain:type_name -> df.plugin.PlayerExperienceGainEvent + 39, // 33: df.plugin.EventEnvelope.player_punch_air:type_name -> df.plugin.PlayerPunchAirEvent + 40, // 34: df.plugin.EventEnvelope.player_sign_edit:type_name -> df.plugin.PlayerSignEditEvent + 41, // 35: df.plugin.EventEnvelope.player_lectern_page_turn:type_name -> df.plugin.PlayerLecternPageTurnEvent + 42, // 36: df.plugin.EventEnvelope.player_item_damage:type_name -> df.plugin.PlayerItemDamageEvent + 43, // 37: df.plugin.EventEnvelope.player_item_pickup:type_name -> df.plugin.PlayerItemPickupEvent + 44, // 38: df.plugin.EventEnvelope.player_held_slot_change:type_name -> df.plugin.PlayerHeldSlotChangeEvent + 45, // 39: df.plugin.EventEnvelope.player_item_drop:type_name -> df.plugin.PlayerItemDropEvent + 46, // 40: df.plugin.EventEnvelope.player_transfer:type_name -> df.plugin.PlayerTransferEvent + 47, // 41: df.plugin.EventEnvelope.command:type_name -> df.plugin.CommandEvent + 48, // 42: df.plugin.EventEnvelope.player_diagnostics:type_name -> df.plugin.PlayerDiagnosticsEvent + 49, // 43: df.plugin.EventEnvelope.world_liquid_flow:type_name -> df.plugin.WorldLiquidFlowEvent + 50, // 44: df.plugin.EventEnvelope.world_liquid_decay:type_name -> df.plugin.WorldLiquidDecayEvent + 51, // 45: df.plugin.EventEnvelope.world_liquid_harden:type_name -> df.plugin.WorldLiquidHardenEvent + 52, // 46: df.plugin.EventEnvelope.world_sound:type_name -> df.plugin.WorldSoundEvent + 53, // 47: df.plugin.EventEnvelope.world_fire_spread:type_name -> df.plugin.WorldFireSpreadEvent + 54, // 48: df.plugin.EventEnvelope.world_block_burn:type_name -> df.plugin.WorldBlockBurnEvent + 55, // 49: df.plugin.EventEnvelope.world_crop_trample:type_name -> df.plugin.WorldCropTrampleEvent + 56, // 50: df.plugin.EventEnvelope.world_leaves_decay:type_name -> df.plugin.WorldLeavesDecayEvent + 57, // 51: df.plugin.EventEnvelope.world_entity_spawn:type_name -> df.plugin.WorldEntitySpawnEvent + 58, // 52: df.plugin.EventEnvelope.world_entity_despawn:type_name -> df.plugin.WorldEntityDespawnEvent + 59, // 53: df.plugin.EventEnvelope.world_explosion:type_name -> df.plugin.WorldExplosionEvent + 60, // 54: df.plugin.EventEnvelope.world_close:type_name -> df.plugin.WorldCloseEvent + 8, // 55: df.plugin.PluginToHost.hello:type_name -> df.plugin.PluginHello + 10, // 56: df.plugin.PluginToHost.subscribe:type_name -> df.plugin.EventSubscribe + 2, // 57: df.plugin.PluginToHost.server_info:type_name -> df.plugin.ServerInformationRequest + 61, // 58: df.plugin.PluginToHost.actions:type_name -> df.plugin.ActionBatch + 9, // 59: df.plugin.PluginToHost.log:type_name -> df.plugin.LogMessage + 62, // 60: df.plugin.PluginToHost.event_result:type_name -> df.plugin.EventResult + 63, // 61: df.plugin.PluginHello.commands:type_name -> df.plugin.CommandSpec + 64, // 62: df.plugin.PluginHello.custom_items:type_name -> df.plugin.CustomItemDefinition + 0, // 63: df.plugin.EventSubscribe.events:type_name -> df.plugin.EventType + 7, // 64: df.plugin.Plugin.EventStream:input_type -> df.plugin.PluginToHost + 1, // 65: df.plugin.Plugin.EventStream:output_type -> df.plugin.HostToPlugin + 65, // [65:66] is the sub-list for method output_type + 64, // [64:65] is the sub-list for method input_type + 64, // [64:64] is the sub-list for extension type_name + 64, // [64:64] is the sub-list for extension extendee + 0, // [0:64] is the sub-list for field type_name } func init() { file_plugin_proto_init() } diff --git a/proto/generated/go/world_events.pb.go b/proto/generated/go/world_events.pb.go index 446acad..61164c5 100644 --- a/proto/generated/go/world_events.pb.go +++ b/proto/generated/go/world_events.pb.go @@ -1,7 +1,7 @@ // Code generated by protoc-gen-go. DO NOT EDIT. // versions: // protoc-gen-go v1.36.10 -// protoc v3.21.12 +// protoc (unknown) // source: world_events.proto package generated @@ -809,7 +809,9 @@ const file_world_events_proto_rawDesc = "" + "\n" + "spawn_fire\x18\x06 \x01(\bR\tspawnFire\"<\n" + "\x0fWorldCloseEvent\x12)\n" + - "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05worldB)Z'github.com/secmc/plugin/proto/generatedb\x06proto3" + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05worldB\x8f\x01\n" + + "\rcom.df.pluginB\x10WorldEventsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xa2\x02\x03DPX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15Df\\Plugin\\GPBMetadata\xea\x02\n" + + "Df::Pluginb\x06proto3" var ( file_world_events_proto_rawDescOnce sync.Once From b6c0a198ccca22000e3b5663a2e1356e7fead607 Mon Sep 17 00:00:00 2001 From: HashimTheArab Date: Mon, 24 Nov 2025 21:02:32 +0300 Subject: [PATCH 3/3] remove viewers method --- packages/cpp/src/generated/actions.pb.cc | 2192 +++++------------ packages/cpp/src/generated/actions.pb.h | 1192 +-------- packages/node/src/generated/actions.js | 199 -- packages/node/src/generated/actions.ts | 231 -- .../php/src/generated/Df/Plugin/Action.php | 28 - .../src/generated/Df/Plugin/ActionResult.php | 28 - .../Df/Plugin/GPBMetadata/Actions.php | 2 +- .../Df/Plugin/WorldViewersResult.php | 24 +- packages/python/src/generated/actions_pb2.py | 140 +- packages/rust/src/generated/df.plugin.rs | 26 +- plugin/adapters/plugin/actions.go | 33 +- proto/generated/go/actions.pb.go | 335 +-- proto/types/actions.proto | 13 - 13 files changed, 853 insertions(+), 3590 deletions(-) diff --git a/packages/cpp/src/generated/actions.pb.cc b/packages/cpp/src/generated/actions.pb.cc index 1670c27..b62b8dc 100644 --- a/packages/cpp/src/generated/actions.pb.cc +++ b/packages/cpp/src/generated/actions.pb.cc @@ -442,33 +442,6 @@ struct ActionStatusDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ActionStatusDefaultTypeInternal _ActionStatus_default_instance_; -inline constexpr WorldViewersResult::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0}, - viewer_uuids_{}, - world_{nullptr}, - position_{nullptr} {} - -template -PROTOBUF_CONSTEXPR WorldViewersResult::WorldViewersResult(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(WorldViewersResult_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct WorldViewersResultDefaultTypeInternal { - PROTOBUF_CONSTEXPR WorldViewersResultDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~WorldViewersResultDefaultTypeInternal() {} - union { - WorldViewersResult _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldViewersResultDefaultTypeInternal _WorldViewersResult_default_instance_; - inline constexpr WorldSetTickRangeAction::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -547,32 +520,6 @@ struct WorldSetDefaultGameModeActionDefaultTypeInternal { PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldSetDefaultGameModeActionDefaultTypeInternal _WorldSetDefaultGameModeAction_default_instance_; -inline constexpr WorldQueryViewersAction::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0}, - world_{nullptr}, - position_{nullptr} {} - -template -PROTOBUF_CONSTEXPR WorldQueryViewersAction::WorldQueryViewersAction(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(WorldQueryViewersAction_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct WorldQueryViewersActionDefaultTypeInternal { - PROTOBUF_CONSTEXPR WorldQueryViewersActionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~WorldQueryViewersActionDefaultTypeInternal() {} - union { - WorldQueryViewersAction _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 WorldQueryViewersActionDefaultTypeInternal _WorldQueryViewersAction_default_instance_; - inline constexpr WorldQueryPlayersAction::Impl_::Impl_( ::_pbi::ConstantInitialized) noexcept : _cached_size_{0}, @@ -1056,7 +1003,7 @@ const ::uint32_t 0x085, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_._oneof_case_[0]), - 34, // hasbit index offset + 33, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.correlation_id_), PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), @@ -1086,7 +1033,6 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), - PROTOBUF_FIELD_OFFSET(::df::plugin::Action, _impl_.kind_), 0, ~0u, ~0u, @@ -1115,7 +1061,6 @@ const ::uint32_t ~0u, ~0u, ~0u, - ~0u, 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::SendChatAction, _impl_._has_bits_), 5, // hasbit index offset @@ -1340,13 +1285,6 @@ const ::uint32_t 0, 1, 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_._has_bits_), - 5, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_.world_), - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldQueryViewersAction, _impl_.position_), - 0, - 1, - 0x081, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::ActionStatus, _impl_._has_bits_), 5, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::ActionStatus, _impl_.ok_), @@ -1376,72 +1314,59 @@ const ::uint32_t PROTOBUF_FIELD_OFFSET(::df::plugin::WorldPlayersResult, _impl_.players_), 1, 0, - 0x081, // bitmap - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_._has_bits_), - 6, // hasbit index offset - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.world_), - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.position_), - PROTOBUF_FIELD_OFFSET(::df::plugin::WorldViewersResult, _impl_.viewer_uuids_), - 1, - 2, - 0, 0x085, // bitmap PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_._has_bits_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_._oneof_case_[0]), - 11, // hasbit index offset + 10, // hasbit index offset PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.correlation_id_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.status_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), - PROTOBUF_FIELD_OFFSET(::df::plugin::ActionResult, _impl_.result_), 0, 1, ~0u, ~0u, ~0u, - ~0u, }; static const ::_pbi::MigrationSchema schemas[] ABSL_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { {0, sizeof(::df::plugin::ActionBatch)}, {5, sizeof(::df::plugin::Action)}, - {68, sizeof(::df::plugin::SendChatAction)}, - {75, sizeof(::df::plugin::TeleportAction)}, - {84, sizeof(::df::plugin::KickAction)}, - {91, sizeof(::df::plugin::SetGameModeAction)}, - {98, sizeof(::df::plugin::GiveItemAction)}, - {105, sizeof(::df::plugin::ClearInventoryAction)}, - {110, sizeof(::df::plugin::SetHeldItemAction)}, - {119, sizeof(::df::plugin::SetHealthAction)}, - {128, sizeof(::df::plugin::SetFoodAction)}, - {135, sizeof(::df::plugin::SetExperienceAction)}, - {146, sizeof(::df::plugin::SetVelocityAction)}, - {153, sizeof(::df::plugin::AddEffectAction)}, - {166, sizeof(::df::plugin::RemoveEffectAction)}, - {173, sizeof(::df::plugin::SendTitleAction)}, - {188, sizeof(::df::plugin::SendPopupAction)}, - {195, sizeof(::df::plugin::SendTipAction)}, - {202, sizeof(::df::plugin::PlaySoundAction)}, - {215, sizeof(::df::plugin::ExecuteCommandAction)}, - {222, sizeof(::df::plugin::WorldSetDefaultGameModeAction)}, - {229, sizeof(::df::plugin::WorldSetDifficultyAction)}, - {236, sizeof(::df::plugin::WorldSetTickRangeAction)}, - {243, sizeof(::df::plugin::WorldSetBlockAction)}, - {252, sizeof(::df::plugin::WorldPlaySoundAction)}, - {261, sizeof(::df::plugin::WorldAddParticleAction)}, - {274, sizeof(::df::plugin::WorldQueryEntitiesAction)}, - {279, sizeof(::df::plugin::WorldQueryPlayersAction)}, - {284, sizeof(::df::plugin::WorldQueryEntitiesWithinAction)}, - {291, sizeof(::df::plugin::WorldQueryViewersAction)}, - {298, sizeof(::df::plugin::ActionStatus)}, - {305, sizeof(::df::plugin::WorldEntitiesResult)}, - {312, sizeof(::df::plugin::WorldEntitiesWithinResult)}, - {321, sizeof(::df::plugin::WorldPlayersResult)}, - {328, sizeof(::df::plugin::WorldViewersResult)}, - {337, sizeof(::df::plugin::ActionResult)}, + {66, sizeof(::df::plugin::SendChatAction)}, + {73, sizeof(::df::plugin::TeleportAction)}, + {82, sizeof(::df::plugin::KickAction)}, + {89, sizeof(::df::plugin::SetGameModeAction)}, + {96, sizeof(::df::plugin::GiveItemAction)}, + {103, sizeof(::df::plugin::ClearInventoryAction)}, + {108, sizeof(::df::plugin::SetHeldItemAction)}, + {117, sizeof(::df::plugin::SetHealthAction)}, + {126, sizeof(::df::plugin::SetFoodAction)}, + {133, sizeof(::df::plugin::SetExperienceAction)}, + {144, sizeof(::df::plugin::SetVelocityAction)}, + {151, sizeof(::df::plugin::AddEffectAction)}, + {164, sizeof(::df::plugin::RemoveEffectAction)}, + {171, sizeof(::df::plugin::SendTitleAction)}, + {186, sizeof(::df::plugin::SendPopupAction)}, + {193, sizeof(::df::plugin::SendTipAction)}, + {200, sizeof(::df::plugin::PlaySoundAction)}, + {213, sizeof(::df::plugin::ExecuteCommandAction)}, + {220, sizeof(::df::plugin::WorldSetDefaultGameModeAction)}, + {227, sizeof(::df::plugin::WorldSetDifficultyAction)}, + {234, sizeof(::df::plugin::WorldSetTickRangeAction)}, + {241, sizeof(::df::plugin::WorldSetBlockAction)}, + {250, sizeof(::df::plugin::WorldPlaySoundAction)}, + {259, sizeof(::df::plugin::WorldAddParticleAction)}, + {272, sizeof(::df::plugin::WorldQueryEntitiesAction)}, + {277, sizeof(::df::plugin::WorldQueryPlayersAction)}, + {282, sizeof(::df::plugin::WorldQueryEntitiesWithinAction)}, + {289, sizeof(::df::plugin::ActionStatus)}, + {296, sizeof(::df::plugin::WorldEntitiesResult)}, + {303, sizeof(::df::plugin::WorldEntitiesWithinResult)}, + {312, sizeof(::df::plugin::WorldPlayersResult)}, + {319, sizeof(::df::plugin::ActionResult)}, }; static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::df::plugin::_ActionBatch_default_instance_._instance, @@ -1473,19 +1398,17 @@ static const ::_pb::Message* PROTOBUF_NONNULL const file_default_instances[] = { &::df::plugin::_WorldQueryEntitiesAction_default_instance_._instance, &::df::plugin::_WorldQueryPlayersAction_default_instance_._instance, &::df::plugin::_WorldQueryEntitiesWithinAction_default_instance_._instance, - &::df::plugin::_WorldQueryViewersAction_default_instance_._instance, &::df::plugin::_ActionStatus_default_instance_._instance, &::df::plugin::_WorldEntitiesResult_default_instance_._instance, &::df::plugin::_WorldEntitiesWithinResult_default_instance_._instance, &::df::plugin::_WorldPlayersResult_default_instance_._instance, - &::df::plugin::_WorldViewersResult_default_instance_._instance, &::df::plugin::_ActionResult_default_instance_._instance, }; const char descriptor_table_protodef_actions_2eproto[] ABSL_ATTRIBUTE_SECTION_VARIABLE( protodesc_cold) = { "\n\ractions.proto\022\tdf.plugin\032\014common.proto" "\":\n\013ActionBatch\022+\n\007actions\030\001 \003(\0132\021.df.pl" - "ugin.ActionR\007actions\"\257\020\n\006Action\022*\n\016corre" + "ugin.ActionR\007actions\"\331\017\n\006Action\022*\n\016corre" "lation_id\030\001 \001(\tH\001R\rcorrelationId\210\001\001\0228\n\ts" "end_chat\030\n \001(\0132\031.df.plugin.SendChatActio" "nH\000R\010sendChat\0227\n\010teleport\030\013 \001(\0132\031.df.plu" @@ -1535,141 +1458,130 @@ const char descriptor_table_protodef_actions_2eproto[] ABSL_ATTRIBUTE_SECTION_VA "worldQueryPlayers\022j\n\033world_query_entitie" "s_within\030H \001(\0132).df.plugin.WorldQueryEnt" "itiesWithinActionH\000R\030worldQueryEntitiesW" - "ithin\022T\n\023world_query_viewers\030I \001(\0132\".df." - "plugin.WorldQueryViewersActionH\000R\021worldQ" - "ueryViewersB\006\n\004kindB\021\n\017_correlation_id\"K" - "\n\016SendChatAction\022\037\n\013target_uuid\030\001 \001(\tR\nt" - "argetUuid\022\030\n\007message\030\002 \001(\tR\007message\"\213\001\n\016" - "TeleportAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" - "yerUuid\022+\n\010position\030\002 \001(\0132\017.df.plugin.Ve" - "c3R\010position\022+\n\010rotation\030\003 \001(\0132\017.df.plug" - "in.Vec3R\010rotation\"E\n\nKickAction\022\037\n\013playe" - "r_uuid\030\001 \001(\tR\nplayerUuid\022\026\n\006reason\030\002 \001(\t" - "R\006reason\"f\n\021SetGameModeAction\022\037\n\013player_" - "uuid\030\001 \001(\tR\nplayerUuid\0220\n\tgame_mode\030\002 \001(" - "\0162\023.df.plugin.GameModeR\010gameMode\"[\n\016Give" - "ItemAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerU" - "uid\022(\n\004item\030\002 \001(\0132\024.df.plugin.ItemStackR" - "\004item\"7\n\024ClearInventoryAction\022\037\n\013player_" - "uuid\030\001 \001(\tR\nplayerUuid\"\255\001\n\021SetHeldItemAc" - "tion\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022-\n" - "\004main\030\002 \001(\0132\024.df.plugin.ItemStackH\000R\004mai" - "n\210\001\001\0223\n\007offhand\030\003 \001(\0132\024.df.plugin.ItemSt" - "ackH\001R\007offhand\210\001\001B\007\n\005_mainB\n\n\010_offhand\"}" - "\n\017SetHealthAction\022\037\n\013player_uuid\030\001 \001(\tR\n" - "playerUuid\022\026\n\006health\030\002 \001(\001R\006health\022\"\n\nma" - "x_health\030\003 \001(\001H\000R\tmaxHealth\210\001\001B\r\n\013_max_h" - "ealth\"D\n\rSetFoodAction\022\037\n\013player_uuid\030\001 " - "\001(\tR\nplayerUuid\022\022\n\004food\030\002 \001(\005R\004food\"\261\001\n\023" - "SetExperienceAction\022\037\n\013player_uuid\030\001 \001(\t" - "R\nplayerUuid\022\031\n\005level\030\002 \001(\005H\000R\005level\210\001\001\022" - "\037\n\010progress\030\003 \001(\002H\001R\010progress\210\001\001\022\033\n\006amou" - "nt\030\004 \001(\005H\002R\006amount\210\001\001B\010\n\006_levelB\013\n\t_prog" - "ressB\t\n\007_amount\"a\n\021SetVelocityAction\022\037\n\013" - "player_uuid\030\001 \001(\tR\nplayerUuid\022+\n\010velocit" - "y\030\002 \001(\0132\017.df.plugin.Vec3R\010velocity\"\310\001\n\017A" - "ddEffectAction\022\037\n\013player_uuid\030\001 \001(\tR\npla" - "yerUuid\0226\n\013effect_type\030\002 \001(\0162\025.df.plugin" - ".EffectTypeR\neffectType\022\024\n\005level\030\003 \001(\005R\005" - "level\022\037\n\013duration_ms\030\004 \001(\003R\ndurationMs\022%" - "\n\016show_particles\030\005 \001(\010R\rshowParticles\"m\n" - "\022RemoveEffectAction\022\037\n\013player_uuid\030\001 \001(\t" - "R\nplayerUuid\0226\n\013effect_type\030\002 \001(\0162\025.df.p" - "lugin.EffectTypeR\neffectType\"\223\002\n\017SendTit" - "leAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUui" - "d\022\024\n\005title\030\002 \001(\tR\005title\022\037\n\010subtitle\030\003 \001(" - "\tH\000R\010subtitle\210\001\001\022!\n\nfade_in_ms\030\004 \001(\003H\001R\010" - "fadeInMs\210\001\001\022$\n\013duration_ms\030\005 \001(\003H\002R\ndura" - "tionMs\210\001\001\022#\n\013fade_out_ms\030\006 \001(\003H\003R\tfadeOu" - "tMs\210\001\001B\013\n\t_subtitleB\r\n\013_fade_in_msB\016\n\014_d" - "uration_msB\016\n\014_fade_out_ms\"L\n\017SendPopupA" - "ction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030" - "\n\007message\030\002 \001(\tR\007message\"J\n\rSendTipActio" - "n\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007me" - "ssage\030\002 \001(\tR\007message\"\346\001\n\017PlaySoundAction" - "\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022&\n\005sou" - "nd\030\002 \001(\0162\020.df.plugin.SoundR\005sound\0220\n\010pos" - "ition\030\003 \001(\0132\017.df.plugin.Vec3H\000R\010position" - "\210\001\001\022\033\n\006volume\030\004 \001(\002H\001R\006volume\210\001\001\022\031\n\005pitc" - "h\030\005 \001(\002H\002R\005pitch\210\001\001B\013\n\t_positionB\t\n\007_vol" - "umeB\010\n\006_pitch\"Q\n\024ExecuteCommandAction\022\037\n" - "\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007comman" - "d\030\002 \001(\tR\007command\"|\n\035WorldSetDefaultGameM" - "odeAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wor" - "ldRefR\005world\0220\n\tgame_mode\030\002 \001(\0162\023.df.plu" - "gin.GameModeR\010gameMode\"|\n\030WorldSetDiffic" - "ultyAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wo" - "rldRefR\005world\0225\n\ndifficulty\030\002 \001(\0162\025.df.p" - "lugin.DifficultyR\ndifficulty\"c\n\027WorldSet" - "TickRangeAction\022)\n\005world\030\001 \001(\0132\023.df.plug" - "in.WorldRefR\005world\022\035\n\ntick_range\030\002 \001(\005R\t" - "tickRange\"\255\001\n\023WorldSetBlockAction\022)\n\005wor" - "ld\030\001 \001(\0132\023.df.plugin.WorldRefR\005world\022/\n\010" - "position\030\002 \001(\0132\023.df.plugin.BlockPosR\010pos" - "ition\0220\n\005block\030\003 \001(\0132\025.df.plugin.BlockSt" - "ateH\000R\005block\210\001\001B\010\n\006_block\"\226\001\n\024WorldPlayS" - "oundAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wo" - "rldRefR\005world\022&\n\005sound\030\002 \001(\0162\020.df.plugin" - ".SoundR\005sound\022+\n\010position\030\003 \001(\0132\017.df.plu" - "gin.Vec3R\010position\"\203\002\n\026WorldAddParticleA" - "ction\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRe" - "fR\005world\022+\n\010position\030\002 \001(\0132\017.df.plugin.V" - "ec3R\010position\0223\n\010particle\030\003 \001(\0162\027.df.plu" - "gin.ParticleTypeR\010particle\0220\n\005block\030\004 \001(" - "\0132\025.df.plugin.BlockStateH\000R\005block\210\001\001\022\027\n\004" - "face\030\005 \001(\005H\001R\004face\210\001\001B\010\n\006_blockB\007\n\005_face" - "\"E\n\030WorldQueryEntitiesAction\022)\n\005world\030\001 " - "\001(\0132\023.df.plugin.WorldRefR\005world\"D\n\027World" - "QueryPlayersAction\022)\n\005world\030\001 \001(\0132\023.df.p" - "lugin.WorldRefR\005world\"n\n\036WorldQueryEntit" - "iesWithinAction\022)\n\005world\030\001 \001(\0132\023.df.plug" - "in.WorldRefR\005world\022!\n\003box\030\002 \001(\0132\017.df.plu" - "gin.BBoxR\003box\"q\n\027WorldQueryViewersAction" - "\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRefR\005wo" - "rld\022+\n\010position\030\002 \001(\0132\017.df.plugin.Vec3R\010" - "position\"C\n\014ActionStatus\022\016\n\002ok\030\001 \001(\010R\002ok" - "\022\031\n\005error\030\002 \001(\tH\000R\005error\210\001\001B\010\n\006_error\"r\n" - "\023WorldEntitiesResult\022)\n\005world\030\001 \001(\0132\023.df" - ".plugin.WorldRefR\005world\0220\n\010entities\030\002 \003(" - "\0132\024.df.plugin.EntityRefR\010entities\"\233\001\n\031Wo" - "rldEntitiesWithinResult\022)\n\005world\030\001 \001(\0132\023" - ".df.plugin.WorldRefR\005world\022!\n\003box\030\002 \001(\0132" - "\017.df.plugin.BBoxR\003box\0220\n\010entities\030\003 \003(\0132" - "\024.df.plugin.EntityRefR\010entities\"o\n\022World" - "PlayersResult\022)\n\005world\030\001 \001(\0132\023.df.plugin" - ".WorldRefR\005world\022.\n\007players\030\002 \003(\0132\024.df.p" - "lugin.EntityRefR\007players\"\217\001\n\022WorldViewer" - "sResult\022)\n\005world\030\001 \001(\0132\023.df.plugin.World" - "RefR\005world\022+\n\010position\030\002 \001(\0132\017.df.plugin" - ".Vec3R\010position\022!\n\014viewer_uuids\030\003 \003(\tR\013v" - "iewerUuids\"\261\003\n\014ActionResult\022%\n\016correlati" - "on_id\030\001 \001(\tR\rcorrelationId\0224\n\006status\030\002 \001" - "(\0132\027.df.plugin.ActionStatusH\001R\006status\210\001\001" - "\022G\n\016world_entities\030\n \001(\0132\036.df.plugin.Wor" - "ldEntitiesResultH\000R\rworldEntities\022D\n\rwor" - "ld_players\030\013 \001(\0132\035.df.plugin.WorldPlayer" - "sResultH\000R\014worldPlayers\022Z\n\025world_entitie" - "s_within\030\014 \001(\0132$.df.plugin.WorldEntities" - "WithinResultH\000R\023worldEntitiesWithin\022D\n\rw" - "orld_viewers\030\r \001(\0132\035.df.plugin.WorldView" - "ersResultH\000R\014worldViewersB\010\n\006resultB\t\n\007_" - "status*\353\003\n\014ParticleType\022\035\n\031PARTICLE_TYPE" - "_UNSPECIFIED\020\000\022\033\n\027PARTICLE_HUGE_EXPLOSIO" - "N\020\001\022\036\n\032PARTICLE_ENDERMAN_TELEPORT\020\002\022\032\n\026P" - "ARTICLE_SNOWBALL_POOF\020\003\022\026\n\022PARTICLE_EGG_" - "SMASH\020\004\022\023\n\017PARTICLE_SPLASH\020\005\022\023\n\017PARTICLE" - "_EFFECT\020\006\022\031\n\025PARTICLE_ENTITY_FLAME\020\007\022\022\n\016" - "PARTICLE_FLAME\020\010\022\021\n\rPARTICLE_DUST\020\t\022\036\n\032P" - "ARTICLE_BLOCK_FORCE_FIELD\020\n\022\026\n\022PARTICLE_" - "BONE_MEAL\020\013\022\026\n\022PARTICLE_EVAPORATE\020\014\022\027\n\023P" - "ARTICLE_WATER_DRIP\020\r\022\026\n\022PARTICLE_LAVA_DR" - "IP\020\016\022\021\n\rPARTICLE_LAVA\020\017\022\027\n\023PARTICLE_DUST" - "_PLUME\020\020\022\030\n\024PARTICLE_BLOCK_BREAK\020\021\022\030\n\024PA" - "RTICLE_PUNCH_BLOCK\020\022B\213\001\n\rcom.df.pluginB\014" - "ActionsProtoP\001Z\'github.com/secmc/plugin/" - "proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\P" - "lugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plug" - "inb\006proto3" + "ithinB\006\n\004kindB\021\n\017_correlation_id\"K\n\016Send" + "ChatAction\022\037\n\013target_uuid\030\001 \001(\tR\ntargetU" + "uid\022\030\n\007message\030\002 \001(\tR\007message\"\213\001\n\016Telepo" + "rtAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUui" + "d\022+\n\010position\030\002 \001(\0132\017.df.plugin.Vec3R\010po" + "sition\022+\n\010rotation\030\003 \001(\0132\017.df.plugin.Vec" + "3R\010rotation\"E\n\nKickAction\022\037\n\013player_uuid" + "\030\001 \001(\tR\nplayerUuid\022\026\n\006reason\030\002 \001(\tR\006reas" + "on\"f\n\021SetGameModeAction\022\037\n\013player_uuid\030\001" + " \001(\tR\nplayerUuid\0220\n\tgame_mode\030\002 \001(\0162\023.df" + ".plugin.GameModeR\010gameMode\"[\n\016GiveItemAc" + "tion\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022(\n" + "\004item\030\002 \001(\0132\024.df.plugin.ItemStackR\004item\"" + "7\n\024ClearInventoryAction\022\037\n\013player_uuid\030\001" + " \001(\tR\nplayerUuid\"\255\001\n\021SetHeldItemAction\022\037" + "\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022-\n\004main\030" + "\002 \001(\0132\024.df.plugin.ItemStackH\000R\004main\210\001\001\0223" + "\n\007offhand\030\003 \001(\0132\024.df.plugin.ItemStackH\001R" + "\007offhand\210\001\001B\007\n\005_mainB\n\n\010_offhand\"}\n\017SetH" + "ealthAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayer" + "Uuid\022\026\n\006health\030\002 \001(\001R\006health\022\"\n\nmax_heal" + "th\030\003 \001(\001H\000R\tmaxHealth\210\001\001B\r\n\013_max_health\"" + "D\n\rSetFoodAction\022\037\n\013player_uuid\030\001 \001(\tR\np" + "layerUuid\022\022\n\004food\030\002 \001(\005R\004food\"\261\001\n\023SetExp" + "erienceAction\022\037\n\013player_uuid\030\001 \001(\tR\nplay" + "erUuid\022\031\n\005level\030\002 \001(\005H\000R\005level\210\001\001\022\037\n\010pro" + "gress\030\003 \001(\002H\001R\010progress\210\001\001\022\033\n\006amount\030\004 \001" + "(\005H\002R\006amount\210\001\001B\010\n\006_levelB\013\n\t_progressB\t" + "\n\007_amount\"a\n\021SetVelocityAction\022\037\n\013player" + "_uuid\030\001 \001(\tR\nplayerUuid\022+\n\010velocity\030\002 \001(" + "\0132\017.df.plugin.Vec3R\010velocity\"\310\001\n\017AddEffe" + "ctAction\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUui" + "d\0226\n\013effect_type\030\002 \001(\0162\025.df.plugin.Effec" + "tTypeR\neffectType\022\024\n\005level\030\003 \001(\005R\005level\022" + "\037\n\013duration_ms\030\004 \001(\003R\ndurationMs\022%\n\016show" + "_particles\030\005 \001(\010R\rshowParticles\"m\n\022Remov" + "eEffectAction\022\037\n\013player_uuid\030\001 \001(\tR\nplay" + "erUuid\0226\n\013effect_type\030\002 \001(\0162\025.df.plugin." + "EffectTypeR\neffectType\"\223\002\n\017SendTitleActi" + "on\022\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\024\n\005t" + "itle\030\002 \001(\tR\005title\022\037\n\010subtitle\030\003 \001(\tH\000R\010s" + "ubtitle\210\001\001\022!\n\nfade_in_ms\030\004 \001(\003H\001R\010fadeIn" + "Ms\210\001\001\022$\n\013duration_ms\030\005 \001(\003H\002R\ndurationMs" + "\210\001\001\022#\n\013fade_out_ms\030\006 \001(\003H\003R\tfadeOutMs\210\001\001" + "B\013\n\t_subtitleB\r\n\013_fade_in_msB\016\n\014_duratio" + "n_msB\016\n\014_fade_out_ms\"L\n\017SendPopupAction\022" + "\037\n\013player_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007mess" + "age\030\002 \001(\tR\007message\"J\n\rSendTipAction\022\037\n\013p" + "layer_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007message\030" + "\002 \001(\tR\007message\"\346\001\n\017PlaySoundAction\022\037\n\013pl" + "ayer_uuid\030\001 \001(\tR\nplayerUuid\022&\n\005sound\030\002 \001" + "(\0162\020.df.plugin.SoundR\005sound\0220\n\010position\030" + "\003 \001(\0132\017.df.plugin.Vec3H\000R\010position\210\001\001\022\033\n" + "\006volume\030\004 \001(\002H\001R\006volume\210\001\001\022\031\n\005pitch\030\005 \001(" + "\002H\002R\005pitch\210\001\001B\013\n\t_positionB\t\n\007_volumeB\010\n" + "\006_pitch\"Q\n\024ExecuteCommandAction\022\037\n\013playe" + "r_uuid\030\001 \001(\tR\nplayerUuid\022\030\n\007command\030\002 \001(" + "\tR\007command\"|\n\035WorldSetDefaultGameModeAct" + "ion\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRefR" + "\005world\0220\n\tgame_mode\030\002 \001(\0162\023.df.plugin.Ga" + "meModeR\010gameMode\"|\n\030WorldSetDifficultyAc" + "tion\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRef" + "R\005world\0225\n\ndifficulty\030\002 \001(\0162\025.df.plugin." + "DifficultyR\ndifficulty\"c\n\027WorldSetTickRa" + "ngeAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wor" + "ldRefR\005world\022\035\n\ntick_range\030\002 \001(\005R\ttickRa" + "nge\"\255\001\n\023WorldSetBlockAction\022)\n\005world\030\001 \001" + "(\0132\023.df.plugin.WorldRefR\005world\022/\n\010positi" + "on\030\002 \001(\0132\023.df.plugin.BlockPosR\010position\022" + "0\n\005block\030\003 \001(\0132\025.df.plugin.BlockStateH\000R" + "\005block\210\001\001B\010\n\006_block\"\226\001\n\024WorldPlaySoundAc" + "tion\022)\n\005world\030\001 \001(\0132\023.df.plugin.WorldRef" + "R\005world\022&\n\005sound\030\002 \001(\0162\020.df.plugin.Sound" + "R\005sound\022+\n\010position\030\003 \001(\0132\017.df.plugin.Ve" + "c3R\010position\"\203\002\n\026WorldAddParticleAction\022" + ")\n\005world\030\001 \001(\0132\023.df.plugin.WorldRefR\005wor" + "ld\022+\n\010position\030\002 \001(\0132\017.df.plugin.Vec3R\010p" + "osition\0223\n\010particle\030\003 \001(\0162\027.df.plugin.Pa" + "rticleTypeR\010particle\0220\n\005block\030\004 \001(\0132\025.df" + ".plugin.BlockStateH\000R\005block\210\001\001\022\027\n\004face\030\005" + " \001(\005H\001R\004face\210\001\001B\010\n\006_blockB\007\n\005_face\"E\n\030Wo" + "rldQueryEntitiesAction\022)\n\005world\030\001 \001(\0132\023." + "df.plugin.WorldRefR\005world\"D\n\027WorldQueryP" + "layersAction\022)\n\005world\030\001 \001(\0132\023.df.plugin." + "WorldRefR\005world\"n\n\036WorldQueryEntitiesWit" + "hinAction\022)\n\005world\030\001 \001(\0132\023.df.plugin.Wor" + "ldRefR\005world\022!\n\003box\030\002 \001(\0132\017.df.plugin.BB" + "oxR\003box\"C\n\014ActionStatus\022\016\n\002ok\030\001 \001(\010R\002ok\022" + "\031\n\005error\030\002 \001(\tH\000R\005error\210\001\001B\010\n\006_error\"r\n\023" + "WorldEntitiesResult\022)\n\005world\030\001 \001(\0132\023.df." + "plugin.WorldRefR\005world\0220\n\010entities\030\002 \003(\013" + "2\024.df.plugin.EntityRefR\010entities\"\233\001\n\031Wor" + "ldEntitiesWithinResult\022)\n\005world\030\001 \001(\0132\023." + "df.plugin.WorldRefR\005world\022!\n\003box\030\002 \001(\0132\017" + ".df.plugin.BBoxR\003box\0220\n\010entities\030\003 \003(\0132\024" + ".df.plugin.EntityRefR\010entities\"o\n\022WorldP" + "layersResult\022)\n\005world\030\001 \001(\0132\023.df.plugin." + "WorldRefR\005world\022.\n\007players\030\002 \003(\0132\024.df.pl" + "ugin.EntityRefR\007players\"\353\002\n\014ActionResult" + "\022%\n\016correlation_id\030\001 \001(\tR\rcorrelationId\022" + "4\n\006status\030\002 \001(\0132\027.df.plugin.ActionStatus" + "H\001R\006status\210\001\001\022G\n\016world_entities\030\n \001(\0132\036." + "df.plugin.WorldEntitiesResultH\000R\rworldEn" + "tities\022D\n\rworld_players\030\013 \001(\0132\035.df.plugi" + "n.WorldPlayersResultH\000R\014worldPlayers\022Z\n\025" + "world_entities_within\030\014 \001(\0132$.df.plugin." + "WorldEntitiesWithinResultH\000R\023worldEntiti" + "esWithinB\010\n\006resultB\t\n\007_status*\353\003\n\014Partic" + "leType\022\035\n\031PARTICLE_TYPE_UNSPECIFIED\020\000\022\033\n" + "\027PARTICLE_HUGE_EXPLOSION\020\001\022\036\n\032PARTICLE_E" + "NDERMAN_TELEPORT\020\002\022\032\n\026PARTICLE_SNOWBALL_" + "POOF\020\003\022\026\n\022PARTICLE_EGG_SMASH\020\004\022\023\n\017PARTIC" + "LE_SPLASH\020\005\022\023\n\017PARTICLE_EFFECT\020\006\022\031\n\025PART" + "ICLE_ENTITY_FLAME\020\007\022\022\n\016PARTICLE_FLAME\020\010\022" + "\021\n\rPARTICLE_DUST\020\t\022\036\n\032PARTICLE_BLOCK_FOR" + "CE_FIELD\020\n\022\026\n\022PARTICLE_BONE_MEAL\020\013\022\026\n\022PA" + "RTICLE_EVAPORATE\020\014\022\027\n\023PARTICLE_WATER_DRI" + "P\020\r\022\026\n\022PARTICLE_LAVA_DRIP\020\016\022\021\n\rPARTICLE_" + "LAVA\020\017\022\027\n\023PARTICLE_DUST_PLUME\020\020\022\030\n\024PARTI" + "CLE_BLOCK_BREAK\020\021\022\030\n\024PARTICLE_PUNCH_BLOC" + "K\020\022B\213\001\n\rcom.df.pluginB\014ActionsProtoP\001Z\'g" + "ithub.com/secmc/plugin/proto/generated\242\002" + "\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin" + "\\GPBMetadata\352\002\nDf::Pluginb\006proto3" }; static const ::_pbi::DescriptorTable* PROTOBUF_NONNULL const descriptor_table_actions_2eproto_deps[1] = { @@ -1679,13 +1591,13 @@ static ::absl::once_flag descriptor_table_actions_2eproto_once; PROTOBUF_CONSTINIT const ::_pbi::DescriptorTable descriptor_table_actions_2eproto = { false, false, - 7450, + 7033, descriptor_table_protodef_actions_2eproto, "actions.proto", &descriptor_table_actions_2eproto_once, descriptor_table_actions_2eproto_deps, 1, - 36, + 34, schemas, file_default_instances, TableStruct_actions_2eproto::offsets, @@ -2347,19 +2259,6 @@ void Action::set_allocated_world_query_entities_within(::df::plugin::WorldQueryE } // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_entities_within) } -void Action::set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE world_query_viewers) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_kind(); - if (world_query_viewers) { - ::google::protobuf::Arena* submessage_arena = world_query_viewers->GetArena(); - if (message_arena != submessage_arena) { - world_query_viewers = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_query_viewers, submessage_arena); - } - set_has_world_query_viewers(); - _impl_.kind_.world_query_viewers_ = world_query_viewers; - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.Action.world_query_viewers) -} Action::Action(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) : ::google::protobuf::Message(arena, Action_class_data_.base()) { @@ -2476,9 +2375,6 @@ Action::Action( case kWorldQueryEntitiesWithin: _impl_.kind_.world_query_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_entities_within_); break; - case kWorldQueryViewers: - _impl_.kind_.world_query_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_viewers_); - break; } // @@protoc_insertion_point(copy_constructor:df.plugin.Action) @@ -2732,14 +2628,6 @@ void Action::clear_kind() { } break; } - case kWorldQueryViewers: { - if (GetArena() == nullptr) { - delete _impl_.kind_.world_query_viewers_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_viewers_); - } - break; - } case KIND_NOT_SET: { break; } @@ -2791,17 +2679,17 @@ Action::GetClassData() const { return Action_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 29, 28, 63, 11> +const ::_pbi::TcParseTable<0, 28, 27, 63, 11> Action::_table_ = { { PROTOBUF_FIELD_OFFSET(Action, _impl_._has_bits_), 0, // no _extensions_ - 73, 0, // max_field_number, fast_idx_mask + 72, 0, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 2676425214, // skipmap offsetof(decltype(_table_), field_entries), - 29, // num_field_entries - 28, // num_aux_entries + 28, // num_field_entries + 27, // num_aux_entries offsetof(decltype(_table_), aux_entries), Action_class_data_.base(), nullptr, // post_loop_handler @@ -2818,7 +2706,7 @@ Action::_table_ = { 40, 0, 3, 64496, 14, 15375, 19, - 65532, 27, + 65534, 27, 65535, 65535 }}, {{ // optional string correlation_id = 1 [json_name = "correlationId"]; @@ -2877,8 +2765,6 @@ Action::_table_ = { {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_players_), _Internal::kOneofCaseOffset + 0, 25, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, // .df.plugin.WorldQueryEntitiesWithinAction world_query_entities_within = 72 [json_name = "worldQueryEntitiesWithin"]; {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_entities_within_), _Internal::kOneofCaseOffset + 0, 26, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; - {PROTOBUF_FIELD_OFFSET(Action, _impl_.kind_.world_query_viewers_), _Internal::kOneofCaseOffset + 0, 27, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::SendChatAction>()}, @@ -2908,7 +2794,6 @@ Action::_table_ = { {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesAction>()}, {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryPlayersAction>()}, {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryEntitiesWithinAction>()}, - {::_pbi::TcParser::GetTable<::df::plugin::WorldQueryViewersAction>()}, }}, {{ "\20\16\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" @@ -3122,12 +3007,6 @@ ::uint8_t* PROTOBUF_NONNULL Action::_InternalSerialize( stream); break; } - case kWorldQueryViewers: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 73, *this_._impl_.kind_.world_query_viewers_, this_._impl_.kind_.world_query_viewers_->GetCachedSize(), target, - stream); - break; - } default: break; } @@ -3325,12 +3204,6 @@ ::size_t Action::ByteSizeLong() const { ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_entities_within_); break; } - // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; - case kWorldQueryViewers: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.kind_.world_query_viewers_); - break; - } case KIND_NOT_SET: { break; } @@ -3586,14 +3459,6 @@ void Action::MergeImpl(::google::protobuf::MessageLite& to_msg, } break; } - case kWorldQueryViewers: { - if (oneof_needs_init) { - _this->_impl_.kind_.world_query_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.kind_.world_query_viewers_); - } else { - _this->_impl_.kind_.world_query_viewers_->MergeFrom(*from._impl_.kind_.world_query_viewers_); - } - break; - } case KIND_NOT_SET: break; } @@ -12824,233 +12689,208 @@ ::google::protobuf::Metadata WorldQueryEntitiesWithinAction::GetMetadata() const } // =================================================================== -class WorldQueryViewersAction::_Internal { +class ActionStatus::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_); }; -void WorldQueryViewersAction::clear_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.world_ != nullptr) _impl_.world_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000001U); -} -void WorldQueryViewersAction::clear_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ != nullptr) _impl_.position_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); -} -WorldQueryViewersAction::WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +ActionStatus::ActionStatus(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldQueryViewersAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(arena_constructor:df.plugin.ActionStatus) } -PROTOBUF_NDEBUG_INLINE WorldQueryViewersAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::WorldQueryViewersAction& from_msg) + [[maybe_unused]] const ::df::plugin::ActionStatus& from_msg) : _has_bits_{from._has_bits_}, - _cached_size_{0} {} + _cached_size_{0}, + error_(arena, from.error_) {} -WorldQueryViewersAction::WorldQueryViewersAction( +ActionStatus::ActionStatus( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const WorldQueryViewersAction& from) + const ActionStatus& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldQueryViewersAction_class_data_.base()) { + : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - WorldQueryViewersAction* const _this = this; + ActionStatus* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000001U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) - : nullptr; - _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) - : nullptr; + _impl_.ok_ = from._impl_.ok_; - // @@protoc_insertion_point(copy_constructor:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(copy_constructor:df.plugin.ActionStatus) } -PROTOBUF_NDEBUG_INLINE WorldQueryViewersAction::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0} {} + : _cached_size_{0}, + error_(arena) {} -inline void WorldQueryViewersAction::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void ActionStatus::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, world_), - 0, - offsetof(Impl_, position_) - - offsetof(Impl_, world_) + - sizeof(Impl_::position_)); + _impl_.ok_ = {}; } -WorldQueryViewersAction::~WorldQueryViewersAction() { - // @@protoc_insertion_point(destructor:df.plugin.WorldQueryViewersAction) +ActionStatus::~ActionStatus() { + // @@protoc_insertion_point(destructor:df.plugin.ActionStatus) SharedDtor(*this); } -inline void WorldQueryViewersAction::SharedDtor(MessageLite& self) { - WorldQueryViewersAction& this_ = static_cast(self); +inline void ActionStatus::SharedDtor(MessageLite& self) { + ActionStatus& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); - delete this_._impl_.world_; - delete this_._impl_.position_; + this_._impl_.error_.Destroy(); this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL WorldQueryViewersAction::PlacementNew_( +inline void* PROTOBUF_NONNULL ActionStatus::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) WorldQueryViewersAction(arena); + return ::new (mem) ActionStatus(arena); } -constexpr auto WorldQueryViewersAction::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(WorldQueryViewersAction), - alignof(WorldQueryViewersAction)); +constexpr auto ActionStatus::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ActionStatus), + alignof(ActionStatus)); } -constexpr auto WorldQueryViewersAction::InternalGenerateClassData_() { +constexpr auto ActionStatus::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_WorldQueryViewersAction_default_instance_._instance, + &_ActionStatus_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &WorldQueryViewersAction::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &ActionStatus::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &WorldQueryViewersAction::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &WorldQueryViewersAction::ByteSizeLong, - &WorldQueryViewersAction::_InternalSerialize, + &ActionStatus::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &ActionStatus::ByteSizeLong, + &ActionStatus::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._cached_size_), false, }, - &WorldQueryViewersAction::kDescriptorMethods, + &ActionStatus::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_ = - WorldQueryViewersAction::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_ = + ActionStatus::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -WorldQueryViewersAction::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&WorldQueryViewersAction_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(WorldQueryViewersAction_class_data_.tc_table); - return WorldQueryViewersAction_class_data_.base(); +ActionStatus::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&ActionStatus_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(ActionStatus_class_data_.tc_table); + return ActionStatus_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 2, 0, 2> -WorldQueryViewersAction::_table_ = { +const ::_pbi::TcParseTable<1, 2, 0, 36, 2> +ActionStatus::_table_ = { { - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_), 0, // no _extensions_ 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), 4294967292, // skipmap offsetof(decltype(_table_), field_entries), 2, // num_field_entries - 2, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - WorldQueryViewersAction_class_data_.base(), + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + ActionStatus_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::WorldQueryViewersAction>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::ActionStatus>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {::_pbi::TcParser::FastMtS1, - {18, 1, 1, - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_)}}, - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {::_pbi::TcParser::FastMtS1, - {10, 0, 0, - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_)}}, + // optional string error = 2 [json_name = "error"]; + {::_pbi::TcParser::FastUS1, + {18, 0, 0, + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_)}}, + // bool ok = 1 [json_name = "ok"]; + {::_pbi::TcParser::SingularVarintNoZag1(), + {8, 1, 0, + PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_)}}, }}, {{ 65535, 65535 }}, {{ - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_), _Internal::kHasBitsOffset + 1, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, - {{ - {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, - {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + // bool ok = 1 [json_name = "ok"]; + {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, + // optional string error = 2 [json_name = "error"]; + {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, }}, + // no aux_entries {{ + "\26\0\5\0\0\0\0\0" + "df.plugin.ActionStatus" + "error" }}, }; -PROTOBUF_NOINLINE void WorldQueryViewersAction::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.WorldQueryViewersAction) +PROTOBUF_NOINLINE void ActionStatus::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.ActionStatus) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - ABSL_DCHECK(_impl_.world_ != nullptr); - _impl_.world_->Clear(); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.position_ != nullptr); - _impl_.position_->Clear(); - } + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + _impl_.error_.ClearNonDefaultToEmpty(); } + _impl_.ok_ = false; _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL WorldQueryViewersAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const WorldQueryViewersAction& this_ = static_cast(base); + const ActionStatus& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL WorldQueryViewersAction::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const WorldQueryViewersAction& this_ = *this; + const ActionStatus& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ActionStatus) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = this_._impl_._has_bits_[0]; - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, - stream); + // bool ok = 1 [json_name = "ok"]; + if (CheckHasBit(cached_has_bits, 0x00000002U)) { + if (this_._internal_ok() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 1, this_._internal_ok(), target); + } } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, - stream); + // optional string error = 2 [json_name = "error"]; + if (CheckHasBit(cached_has_bits, 0x00000001U)) { + const ::std::string& _s = this_._internal_error(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ActionStatus.error"); + target = stream->WriteStringMaybeAliased(2, _s, target); } if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { @@ -13058,18 +12898,18 @@ ::uint8_t* PROTOBUF_NONNULL WorldQueryViewersAction::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ActionStatus) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t WorldQueryViewersAction::ByteSizeLong(const MessageLite& base) { - const WorldQueryViewersAction& this_ = static_cast(base); +::size_t ActionStatus::ByteSizeLong(const MessageLite& base) { + const ActionStatus& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t WorldQueryViewersAction::ByteSizeLong() const { - const WorldQueryViewersAction& this_ = *this; +::size_t ActionStatus::ByteSizeLong() const { + const ActionStatus& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.ActionStatus) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -13079,31 +12919,31 @@ ::size_t WorldQueryViewersAction::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // .df.plugin.WorldRef world = 1 [json_name = "world"]; + // optional string error = 2 [json_name = "error"]; if (CheckHasBit(cached_has_bits, 0x00000001U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_error()); } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; + // bool ok = 1 [json_name = "ok"]; if (CheckHasBit(cached_has_bits, 0x00000002U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); + if (this_._internal_ok() != 0) { + total_size += 2; + } } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void WorldQueryViewersAction::MergeImpl(::google::protobuf::MessageLite& to_msg, +void ActionStatus::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } - ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ActionStatus) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -13111,659 +12951,11 @@ void WorldQueryViewersAction::MergeImpl(::google::protobuf::MessageLite& to_msg, cached_has_bits = from._impl_._has_bits_[0]; if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBit(cached_has_bits, 0x00000001U)) { - ABSL_DCHECK(from._impl_.world_ != nullptr); - if (_this->_impl_.world_ == nullptr) { - _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); - } else { - _this->_impl_.world_->MergeFrom(*from._impl_.world_); - } + _this->_internal_set_error(from._internal_error()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.position_ != nullptr); - if (_this->_impl_.position_ == nullptr) { - _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); - } else { - _this->_impl_.position_->MergeFrom(*from._impl_.position_); - } - } - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( - from._internal_metadata_); -} - -void WorldQueryViewersAction::CopyFrom(const WorldQueryViewersAction& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldQueryViewersAction) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void WorldQueryViewersAction::InternalSwap(WorldQueryViewersAction* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { - using ::std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.position_) - + sizeof(WorldQueryViewersAction::_impl_.position_) - - PROTOBUF_FIELD_OFFSET(WorldQueryViewersAction, _impl_.world_)>( - reinterpret_cast(&_impl_.world_), - reinterpret_cast(&other->_impl_.world_)); -} - -::google::protobuf::Metadata WorldQueryViewersAction::GetMetadata() const { - return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); -} -// =================================================================== - -class ActionStatus::_Internal { - public: - using HasBits = - decltype(::std::declval()._impl_._has_bits_); - static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_); -}; - -ActionStatus::ActionStatus(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.ActionStatus) -} -PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( - [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, - [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::ActionStatus& from_msg) - : _has_bits_{from._has_bits_}, - _cached_size_{0}, - error_(arena, from.error_) {} - -ActionStatus::ActionStatus( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const ActionStatus& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, ActionStatus_class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - ActionStatus* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - _impl_.ok_ = from._impl_.ok_; - - // @@protoc_insertion_point(copy_constructor:df.plugin.ActionStatus) -} -PROTOBUF_NDEBUG_INLINE ActionStatus::Impl_::Impl_( - [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, - [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - error_(arena) {} - -inline void ActionStatus::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.ok_ = {}; -} -ActionStatus::~ActionStatus() { - // @@protoc_insertion_point(destructor:df.plugin.ActionStatus) - SharedDtor(*this); -} -inline void ActionStatus::SharedDtor(MessageLite& self) { - ActionStatus& this_ = static_cast(self); - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.error_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* PROTOBUF_NONNULL ActionStatus::PlacementNew_( - const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) ActionStatus(arena); -} -constexpr auto ActionStatus::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ActionStatus), - alignof(ActionStatus)); -} -constexpr auto ActionStatus::InternalGenerateClassData_() { - return ::google::protobuf::internal::ClassDataFull{ - ::google::protobuf::internal::ClassData{ - &_ActionStatus_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ActionStatus::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ActionStatus::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &ActionStatus::ByteSizeLong, - &ActionStatus::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._cached_size_), - false, - }, - &ActionStatus::kDescriptorMethods, - &descriptor_table_actions_2eproto, - nullptr, // tracker - }; -} - -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_ = - ActionStatus::InternalGenerateClassData_(); - -PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -ActionStatus::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&ActionStatus_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(ActionStatus_class_data_.tc_table); - return ActionStatus_class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 36, 2> -ActionStatus::_table_ = { - { - PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_._has_bits_), - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - ActionStatus_class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallback, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::ActionStatus>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // optional string error = 2 [json_name = "error"]; - {::_pbi::TcParser::FastUS1, - {18, 0, 0, - PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_)}}, - // bool ok = 1 [json_name = "ok"]; - {::_pbi::TcParser::SingularVarintNoZag1(), - {8, 1, 0, - PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // bool ok = 1 [json_name = "ok"]; - {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.ok_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kBool)}, - // optional string error = 2 [json_name = "error"]; - {PROTOBUF_FIELD_OFFSET(ActionStatus, _impl_.error_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcOptional | ::_fl::kUtf8String | ::_fl::kRepAString)}, - }}, - // no aux_entries - {{ - "\26\0\5\0\0\0\0\0" - "df.plugin.ActionStatus" - "error" - }}, -}; -PROTOBUF_NOINLINE void ActionStatus::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.ActionStatus) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _impl_.error_.ClearNonDefaultToEmpty(); - } - _impl_.ok_ = false; - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( - const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const ActionStatus& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL ActionStatus::_InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const ActionStatus& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.ActionStatus) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = this_._impl_._has_bits_[0]; - // bool ok = 1 [json_name = "ok"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_ok() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 1, this_._internal_ok(), target); - } - } - - // optional string error = 2 [json_name = "error"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - const ::std::string& _s = this_._internal_error(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.ActionStatus.error"); - target = stream->WriteStringMaybeAliased(2, _s, target); - } - - if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = - ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.ActionStatus) - return target; -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t ActionStatus::ByteSizeLong(const MessageLite& base) { - const ActionStatus& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE -::size_t ActionStatus::ByteSizeLong() const { - const ActionStatus& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.ActionStatus) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // optional string error = 2 [json_name = "error"]; - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_error()); - } - // bool ok = 1 [json_name = "ok"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (this_._internal_ok() != 0) { - total_size += 2; - } - } - } - return this_.MaybeComputeUnknownFieldsSize(total_size, - &this_._impl_._cached_size_); -} - -void ActionStatus::MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - from.CheckHasBitConsistency(); - } - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.ActionStatus) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBit(cached_has_bits, 0x00000001U)) { - _this->_internal_set_error(from._internal_error()); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - if (from._internal_ok() != 0) { - _this->_impl_.ok_ = from._impl_.ok_; - } - } - } - _this->_impl_._has_bits_[0] |= cached_has_bits; - _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( - from._internal_metadata_); -} - -void ActionStatus::CopyFrom(const ActionStatus& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ActionStatus) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ActionStatus::InternalSwap(ActionStatus* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { - using ::std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); - swap(_impl_.ok_, other->_impl_.ok_); -} - -::google::protobuf::Metadata ActionStatus::GetMetadata() const { - return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); -} -// =================================================================== - -class WorldEntitiesResult::_Internal { - public: - using HasBits = - decltype(::std::declval()._impl_._has_bits_); - static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_); -}; - -void WorldEntitiesResult::clear_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.world_ != nullptr) _impl_.world_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000002U); -} -void WorldEntitiesResult::clear_entities() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.entities_.Clear(); - ClearHasBitForRepeated(_impl_._has_bits_[0], - 0x00000001U); -} -WorldEntitiesResult::WorldEntitiesResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesResult) -} -PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( - [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, - [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::WorldEntitiesResult& from_msg) - : _has_bits_{from._has_bits_}, - _cached_size_{0}, - entities_{visibility, arena, from.entities_} {} - -WorldEntitiesResult::WorldEntitiesResult( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const WorldEntitiesResult& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::Message(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - WorldEntitiesResult* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::uint32_t cached_has_bits = _impl_._has_bits_[0]; - _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) - : nullptr; - - // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesResult) -} -PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( - [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, - [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) - : _cached_size_{0}, - entities_{visibility, arena} {} - -inline void WorldEntitiesResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.world_ = {}; -} -WorldEntitiesResult::~WorldEntitiesResult() { - // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesResult) - SharedDtor(*this); -} -inline void WorldEntitiesResult::SharedDtor(MessageLite& self) { - WorldEntitiesResult& this_ = static_cast(self); - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); - ABSL_DCHECK(this_.GetArena() == nullptr); - delete this_._impl_.world_; - this_._impl_.~Impl_(); -} - -inline void* PROTOBUF_NONNULL WorldEntitiesResult::PlacementNew_( - const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) WorldEntitiesResult(arena); -} -constexpr auto WorldEntitiesResult::InternalNewImpl_() { - constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_) + - decltype(WorldEntitiesResult::_impl_.entities_):: - InternalGetArenaOffset( - ::google::protobuf::Message::internal_visibility()), - }); - if (arena_bits.has_value()) { - return ::google::protobuf::internal::MessageCreator::ZeroInit( - sizeof(WorldEntitiesResult), alignof(WorldEntitiesResult), *arena_bits); - } else { - return ::google::protobuf::internal::MessageCreator(&WorldEntitiesResult::PlacementNew_, - sizeof(WorldEntitiesResult), - alignof(WorldEntitiesResult)); - } -} -constexpr auto WorldEntitiesResult::InternalGenerateClassData_() { - return ::google::protobuf::internal::ClassDataFull{ - ::google::protobuf::internal::ClassData{ - &_WorldEntitiesResult_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &WorldEntitiesResult::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &WorldEntitiesResult::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesResult::ByteSizeLong, - &WorldEntitiesResult::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._cached_size_), - false, - }, - &WorldEntitiesResult::kDescriptorMethods, - &descriptor_table_actions_2eproto, - nullptr, // tracker - }; -} - -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull WorldEntitiesResult_class_data_ = - WorldEntitiesResult::InternalGenerateClassData_(); - -PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -WorldEntitiesResult::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesResult_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesResult_class_data_.tc_table); - return WorldEntitiesResult_class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 2, 0, 2> -WorldEntitiesResult::_table_ = { - { - PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_), - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 2, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - WorldEntitiesResult_class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallback, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesResult>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; - {::_pbi::TcParser::FastMtR1, - {18, 0, 1, - PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_)}}, - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {::_pbi::TcParser::FastMtS1, - {10, 1, 0, - PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; - {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, - {{ - {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, - {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, - }}, - {{ - }}, -}; -PROTOBUF_NOINLINE void WorldEntitiesResult::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesResult) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _impl_.entities_.Clear(); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(_impl_.world_ != nullptr); - _impl_.world_->Clear(); - } - } - _impl_._has_bits_.Clear(); - _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( - const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const WorldEntitiesResult& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const WorldEntitiesResult& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - this_.CheckHasBitConsistency(); - } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesResult) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = this_._impl_._has_bits_[0]; - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 1, *this_._impl_.world_, this_._impl_.world_->GetCachedSize(), target, - stream); - } - - // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; - if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - for (unsigned i = 0, n = static_cast( - this_._internal_entities_size()); - i < n; i++) { - const auto& repfield = this_._internal_entities().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, repfield, repfield.GetCachedSize(), - target, stream); - } - } - - if (ABSL_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = - ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( - this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); - } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesResult) - return target; -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t WorldEntitiesResult::ByteSizeLong(const MessageLite& base) { - const WorldEntitiesResult& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE -::size_t WorldEntitiesResult::ByteSizeLong() const { - const WorldEntitiesResult& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesResult) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; - if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - total_size += 1UL * this_._internal_entities_size(); - for (const auto& msg : this_._internal_entities()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); - } - } - return this_.MaybeComputeUnknownFieldsSize(total_size, - &this_._impl_._cached_size_); -} - -void WorldEntitiesResult::MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); - if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { - from.CheckHasBitConsistency(); - } - ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesResult) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _this->_internal_mutable_entities()->InternalMergeFromWithArena( - ::google::protobuf::MessageLite::internal_visibility(), arena, - from._internal_entities()); - } - if (CheckHasBit(cached_has_bits, 0x00000002U)) { - ABSL_DCHECK(from._impl_.world_ != nullptr); - if (_this->_impl_.world_ == nullptr) { - _this->_impl_.world_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_); - } else { - _this->_impl_.world_->MergeFrom(*from._impl_.world_); + if (from._internal_ok() != 0) { + _this->_impl_.ok_ = from._impl_.ok_; } } } @@ -13772,79 +12964,75 @@ void WorldEntitiesResult::MergeImpl(::google::protobuf::MessageLite& to_msg, from._internal_metadata_); } -void WorldEntitiesResult::CopyFrom(const WorldEntitiesResult& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesResult) +void ActionStatus::CopyFrom(const ActionStatus& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.ActionStatus) if (&from == this) return; Clear(); MergeFrom(from); } -void WorldEntitiesResult::InternalSwap(WorldEntitiesResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void ActionStatus::InternalSwap(ActionStatus* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.entities_.InternalSwap(&other->_impl_.entities_); - swap(_impl_.world_, other->_impl_.world_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.error_, &other->_impl_.error_, arena); + swap(_impl_.ok_, other->_impl_.ok_); } -::google::protobuf::Metadata WorldEntitiesResult::GetMetadata() const { +::google::protobuf::Metadata ActionStatus::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class WorldEntitiesWithinResult::_Internal { +class WorldEntitiesResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_); }; -void WorldEntitiesWithinResult::clear_world() { +void WorldEntitiesResult::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.world_ != nullptr) _impl_.world_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -void WorldEntitiesWithinResult::clear_box() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.box_ != nullptr) _impl_.box_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); -} -void WorldEntitiesWithinResult::clear_entities() { +void WorldEntitiesResult::clear_entities() { ::google::protobuf::internal::TSanWrite(&_impl_); _impl_.entities_.Clear(); ClearHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); } -WorldEntitiesWithinResult::WorldEntitiesWithinResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldEntitiesResult::WorldEntitiesResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesResult) } -PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::WorldEntitiesWithinResult& from_msg) + [[maybe_unused]] const ::df::plugin::WorldEntitiesResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, entities_{visibility, arena, from.entities_} {} -WorldEntitiesWithinResult::WorldEntitiesWithinResult( +WorldEntitiesResult::WorldEntitiesResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const WorldEntitiesWithinResult& from) + const WorldEntitiesResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - WorldEntitiesWithinResult* const _this = this; + WorldEntitiesResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); @@ -13853,157 +13041,140 @@ WorldEntitiesWithinResult::WorldEntitiesWithinResult( _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) : nullptr; - _impl_.box_ = (CheckHasBit(cached_has_bits, 0x00000004U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_) - : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesResult) } -PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, entities_{visibility, arena} {} -inline void WorldEntitiesWithinResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldEntitiesResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, world_), - 0, - offsetof(Impl_, box_) - - offsetof(Impl_, world_) + - sizeof(Impl_::box_)); + _impl_.world_ = {}; } -WorldEntitiesWithinResult::~WorldEntitiesWithinResult() { - // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesWithinResult) +WorldEntitiesResult::~WorldEntitiesResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesResult) SharedDtor(*this); } -inline void WorldEntitiesWithinResult::SharedDtor(MessageLite& self) { - WorldEntitiesWithinResult& this_ = static_cast(self); +inline void WorldEntitiesResult::SharedDtor(MessageLite& self) { + WorldEntitiesResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); delete this_._impl_.world_; - delete this_._impl_.box_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL WorldEntitiesWithinResult::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldEntitiesResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) WorldEntitiesWithinResult(arena); + return ::new (mem) WorldEntitiesResult(arena); } -constexpr auto WorldEntitiesWithinResult::InternalNewImpl_() { +constexpr auto WorldEntitiesResult::InternalNewImpl_() { constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_) + - decltype(WorldEntitiesWithinResult::_impl_.entities_):: + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_) + + decltype(WorldEntitiesResult::_impl_.entities_):: InternalGetArenaOffset( ::google::protobuf::Message::internal_visibility()), }); if (arena_bits.has_value()) { return ::google::protobuf::internal::MessageCreator::ZeroInit( - sizeof(WorldEntitiesWithinResult), alignof(WorldEntitiesWithinResult), *arena_bits); + sizeof(WorldEntitiesResult), alignof(WorldEntitiesResult), *arena_bits); } else { - return ::google::protobuf::internal::MessageCreator(&WorldEntitiesWithinResult::PlacementNew_, - sizeof(WorldEntitiesWithinResult), - alignof(WorldEntitiesWithinResult)); + return ::google::protobuf::internal::MessageCreator(&WorldEntitiesResult::PlacementNew_, + sizeof(WorldEntitiesResult), + alignof(WorldEntitiesResult)); } } -constexpr auto WorldEntitiesWithinResult::InternalGenerateClassData_() { +constexpr auto WorldEntitiesResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_WorldEntitiesWithinResult_default_instance_._instance, + &_WorldEntitiesResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &WorldEntitiesWithinResult::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldEntitiesResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &WorldEntitiesWithinResult::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesWithinResult::ByteSizeLong, - &WorldEntitiesWithinResult::_InternalSerialize, + &WorldEntitiesResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesResult::ByteSizeLong, + &WorldEntitiesResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._cached_size_), false, }, - &WorldEntitiesWithinResult::kDescriptorMethods, + &WorldEntitiesResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull WorldEntitiesWithinResult_class_data_ = - WorldEntitiesWithinResult::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldEntitiesResult_class_data_ = + WorldEntitiesResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -WorldEntitiesWithinResult::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesWithinResult_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesWithinResult_class_data_.tc_table); - return WorldEntitiesWithinResult_class_data_.base(); +WorldEntitiesResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesResult_class_data_.tc_table); + return WorldEntitiesResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 3, 0, 2> -WorldEntitiesWithinResult::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldEntitiesResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_._has_bits_), 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 3, // num_field_entries - 3, // num_aux_entries + 2, // num_field_entries + 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), - WorldEntitiesWithinResult_class_data_.base(), + WorldEntitiesResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesWithinResult>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - {::_pbi::TcParser::MiniParse, {}}, + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + {::_pbi::TcParser::FastMtR1, + {18, 0, 1, + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_)}}, // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, {10, 1, 0, - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)}}, - // .df.plugin.BBox box = 2 [json_name = "box"]; - {::_pbi::TcParser::FastMtS1, - {18, 2, 1, - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_)}}, - // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; - {::_pbi::TcParser::FastMtR1, - {26, 0, 2, - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_)}}, + PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.BBox box = 2 [json_name = "box"]; - {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; - {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, - {::_pbi::TcParser::GetTable<::df::plugin::BBox>()}, {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, {{ }}, }; -PROTOBUF_NOINLINE void WorldEntitiesWithinResult::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesWithinResult) +PROTOBUF_NOINLINE void WorldEntitiesResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { _impl_.entities_.Clear(); } @@ -14011,30 +13182,26 @@ PROTOBUF_NOINLINE void WorldEntitiesWithinResult::Clear() { ABSL_DCHECK(_impl_.world_ != nullptr); _impl_.world_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(_impl_.box_ != nullptr); - _impl_.box_->Clear(); - } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const WorldEntitiesWithinResult& this_ = static_cast(base); + const WorldEntitiesResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const WorldEntitiesWithinResult& this_ = *this; + const WorldEntitiesResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -14046,14 +13213,7 @@ ::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( stream); } - // .df.plugin.BBox box = 2 [json_name = "box"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.box_, this_._impl_.box_->GetCachedSize(), target, - stream); - } - - // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { for (unsigned i = 0, n = static_cast( this_._internal_entities_size()); @@ -14061,7 +13221,7 @@ ::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( const auto& repfield = this_._internal_entities().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, repfield, repfield.GetCachedSize(), + 2, repfield, repfield.GetCachedSize(), target, stream); } } @@ -14071,18 +13231,18 @@ ::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t WorldEntitiesWithinResult::ByteSizeLong(const MessageLite& base) { - const WorldEntitiesWithinResult& this_ = static_cast(base); +::size_t WorldEntitiesResult::ByteSizeLong(const MessageLite& base) { + const WorldEntitiesResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t WorldEntitiesWithinResult::ByteSizeLong() const { - const WorldEntitiesWithinResult& this_ = *this; +::size_t WorldEntitiesResult::ByteSizeLong() const { + const WorldEntitiesResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -14091,8 +13251,8 @@ ::size_t WorldEntitiesWithinResult::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { - // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // repeated .df.plugin.EntityRef entities = 2 [json_name = "entities"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { total_size += 1UL * this_._internal_entities_size(); for (const auto& msg : this_._internal_entities()) { @@ -14104,32 +13264,27 @@ ::size_t WorldEntitiesWithinResult::ByteSizeLong() const { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.BBox box = 2 [json_name = "box"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.box_); - } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void WorldEntitiesWithinResult::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldEntitiesResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesWithinResult) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { _this->_internal_mutable_entities()->InternalMergeFromWithArena( ::google::protobuf::MessageLite::internal_visibility(), arena, @@ -14143,92 +13298,85 @@ void WorldEntitiesWithinResult::MergeImpl(::google::protobuf::MessageLite& to_ms _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(from._impl_.box_ != nullptr); - if (_this->_impl_.box_ == nullptr) { - _this->_impl_.box_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_); - } else { - _this->_impl_.box_->MergeFrom(*from._impl_.box_); - } - } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void WorldEntitiesWithinResult::CopyFrom(const WorldEntitiesWithinResult& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesWithinResult) +void WorldEntitiesResult::CopyFrom(const WorldEntitiesResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesResult) if (&from == this) return; Clear(); MergeFrom(from); } -void WorldEntitiesWithinResult::InternalSwap(WorldEntitiesWithinResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldEntitiesResult::InternalSwap(WorldEntitiesResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); _impl_.entities_.InternalSwap(&other->_impl_.entities_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_) - + sizeof(WorldEntitiesWithinResult::_impl_.box_) - - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)>( - reinterpret_cast(&_impl_.world_), - reinterpret_cast(&other->_impl_.world_)); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata WorldEntitiesWithinResult::GetMetadata() const { +::google::protobuf::Metadata WorldEntitiesResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class WorldPlayersResult::_Internal { +class WorldEntitiesWithinResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_); }; -void WorldPlayersResult::clear_world() { +void WorldEntitiesWithinResult::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.world_ != nullptr) _impl_.world_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -void WorldPlayersResult::clear_players() { +void WorldEntitiesWithinResult::clear_box() { ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.players_.Clear(); + if (_impl_.box_ != nullptr) _impl_.box_->Clear(); + ClearHasBit(_impl_._has_bits_[0], + 0x00000004U); +} +void WorldEntitiesWithinResult::clear_entities() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.entities_.Clear(); ClearHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); } -WorldPlayersResult::WorldPlayersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldEntitiesWithinResult::WorldEntitiesWithinResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldEntitiesWithinResult) } -PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::WorldPlayersResult& from_msg) + [[maybe_unused]] const ::df::plugin::WorldEntitiesWithinResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - players_{visibility, arena, from.players_} {} + entities_{visibility, arena, from.entities_} {} -WorldPlayersResult::WorldPlayersResult( +WorldEntitiesWithinResult::WorldEntitiesWithinResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const WorldPlayersResult& from) + const WorldEntitiesWithinResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldEntitiesWithinResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - WorldPlayersResult* const _this = this; + WorldEntitiesWithinResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); @@ -14237,167 +13385,188 @@ WorldPlayersResult::WorldPlayersResult( _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) : nullptr; + _impl_.box_ = (CheckHasBit(cached_has_bits, 0x00000004U)) + ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_) + : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldEntitiesWithinResult) } -PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldEntitiesWithinResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - players_{visibility, arena} {} + entities_{visibility, arena} {} -inline void WorldPlayersResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldEntitiesWithinResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.world_ = {}; + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, world_), + 0, + offsetof(Impl_, box_) - + offsetof(Impl_, world_) + + sizeof(Impl_::box_)); } -WorldPlayersResult::~WorldPlayersResult() { - // @@protoc_insertion_point(destructor:df.plugin.WorldPlayersResult) +WorldEntitiesWithinResult::~WorldEntitiesWithinResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldEntitiesWithinResult) SharedDtor(*this); } -inline void WorldPlayersResult::SharedDtor(MessageLite& self) { - WorldPlayersResult& this_ = static_cast(self); +inline void WorldEntitiesWithinResult::SharedDtor(MessageLite& self) { + WorldEntitiesWithinResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); delete this_._impl_.world_; + delete this_._impl_.box_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL WorldPlayersResult::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldEntitiesWithinResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) WorldPlayersResult(arena); + return ::new (mem) WorldEntitiesWithinResult(arena); } -constexpr auto WorldPlayersResult::InternalNewImpl_() { +constexpr auto WorldEntitiesWithinResult::InternalNewImpl_() { constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_) + - decltype(WorldPlayersResult::_impl_.players_):: + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_) + + decltype(WorldEntitiesWithinResult::_impl_.entities_):: InternalGetArenaOffset( ::google::protobuf::Message::internal_visibility()), }); if (arena_bits.has_value()) { return ::google::protobuf::internal::MessageCreator::ZeroInit( - sizeof(WorldPlayersResult), alignof(WorldPlayersResult), *arena_bits); + sizeof(WorldEntitiesWithinResult), alignof(WorldEntitiesWithinResult), *arena_bits); } else { - return ::google::protobuf::internal::MessageCreator(&WorldPlayersResult::PlacementNew_, - sizeof(WorldPlayersResult), - alignof(WorldPlayersResult)); + return ::google::protobuf::internal::MessageCreator(&WorldEntitiesWithinResult::PlacementNew_, + sizeof(WorldEntitiesWithinResult), + alignof(WorldEntitiesWithinResult)); } } -constexpr auto WorldPlayersResult::InternalGenerateClassData_() { +constexpr auto WorldEntitiesWithinResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_WorldPlayersResult_default_instance_._instance, + &_WorldEntitiesWithinResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &WorldPlayersResult::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldEntitiesWithinResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &WorldPlayersResult::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &WorldPlayersResult::ByteSizeLong, - &WorldPlayersResult::_InternalSerialize, + &WorldEntitiesWithinResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldEntitiesWithinResult::ByteSizeLong, + &WorldEntitiesWithinResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._cached_size_), false, }, - &WorldPlayersResult::kDescriptorMethods, + &WorldEntitiesWithinResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull WorldPlayersResult_class_data_ = - WorldPlayersResult::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldEntitiesWithinResult_class_data_ = + WorldEntitiesWithinResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -WorldPlayersResult::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&WorldPlayersResult_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(WorldPlayersResult_class_data_.tc_table); - return WorldPlayersResult_class_data_.base(); +WorldEntitiesWithinResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldEntitiesWithinResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldEntitiesWithinResult_class_data_.tc_table); + return WorldEntitiesWithinResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 2, 0, 2> -WorldPlayersResult::_table_ = { +const ::_pbi::TcParseTable<2, 3, 3, 0, 2> +WorldEntitiesWithinResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_._has_bits_), 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask + 3, 24, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap + 4294967288, // skipmap offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 2, // num_aux_entries + 3, // num_field_entries + 3, // num_aux_entries offsetof(decltype(_table_), aux_entries), - WorldPlayersResult_class_data_.base(), + WorldEntitiesWithinResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::WorldPlayersResult>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesWithinResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; - {::_pbi::TcParser::FastMtR1, - {18, 0, 1, - PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_)}}, + {::_pbi::TcParser::MiniParse, {}}, // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, {10, 1, 0, - PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_)}}, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)}}, + // .df.plugin.BBox box = 2 [json_name = "box"]; + {::_pbi::TcParser::FastMtS1, + {18, 2, 1, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_)}}, + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + {::_pbi::TcParser::FastMtR1, + {26, 0, 2, + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_)}}, }}, {{ 65535, 65535 }}, {{ // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; - {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // .df.plugin.BBox box = 2 [json_name = "box"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; + {PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.entities_), _Internal::kHasBitsOffset + 0, 2, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, + {::_pbi::TcParser::GetTable<::df::plugin::BBox>()}, {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, {{ }}, }; -PROTOBUF_NOINLINE void WorldPlayersResult::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.WorldPlayersResult) +PROTOBUF_NOINLINE void WorldEntitiesWithinResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldEntitiesWithinResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _impl_.players_.Clear(); + _impl_.entities_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { ABSL_DCHECK(_impl_.world_ != nullptr); _impl_.world_->Clear(); } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(_impl_.box_ != nullptr); + _impl_.box_->Clear(); + } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const WorldPlayersResult& this_ = static_cast(base); + const WorldEntitiesWithinResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldEntitiesWithinResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const WorldPlayersResult& this_ = *this; + const WorldEntitiesWithinResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldEntitiesWithinResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -14409,15 +13578,22 @@ ::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( stream); } - // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + // .df.plugin.BBox box = 2 [json_name = "box"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.box_, this_._impl_.box_->GetCachedSize(), target, + stream); + } + + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { for (unsigned i = 0, n = static_cast( - this_._internal_players_size()); + this_._internal_entities_size()); i < n; i++) { - const auto& repfield = this_._internal_players().Get(i); + const auto& repfield = this_._internal_entities().Get(i); target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, repfield, repfield.GetCachedSize(), + 3, repfield, repfield.GetCachedSize(), target, stream); } } @@ -14427,18 +13603,18 @@ ::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldEntitiesWithinResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t WorldPlayersResult::ByteSizeLong(const MessageLite& base) { - const WorldPlayersResult& this_ = static_cast(base); +::size_t WorldEntitiesWithinResult::ByteSizeLong(const MessageLite& base) { + const WorldEntitiesWithinResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t WorldPlayersResult::ByteSizeLong() const { - const WorldPlayersResult& this_ = *this; +::size_t WorldEntitiesWithinResult::ByteSizeLong() const { + const WorldEntitiesWithinResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldEntitiesWithinResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -14447,11 +13623,11 @@ ::size_t WorldPlayersResult::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { - // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + // repeated .df.plugin.EntityRef entities = 3 [json_name = "entities"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - total_size += 1UL * this_._internal_players_size(); - for (const auto& msg : this_._internal_players()) { + total_size += 1UL * this_._internal_entities_size(); + for (const auto& msg : this_._internal_entities()) { total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } } @@ -14460,31 +13636,36 @@ ::size_t WorldPlayersResult::ByteSizeLong() const { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } + // .df.plugin.BBox box = 2 [json_name = "box"]; + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.box_); + } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void WorldPlayersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldEntitiesWithinResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldPlayersResult) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldEntitiesWithinResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _this->_internal_mutable_players()->InternalMergeFromWithArena( + _this->_internal_mutable_entities()->InternalMergeFromWithArena( ::google::protobuf::MessageLite::internal_visibility(), arena, - from._internal_players()); + from._internal_entities()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { ABSL_DCHECK(from._impl_.world_ != nullptr); @@ -14494,79 +13675,92 @@ void WorldPlayersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } + if (CheckHasBit(cached_has_bits, 0x00000004U)) { + ABSL_DCHECK(from._impl_.box_ != nullptr); + if (_this->_impl_.box_ == nullptr) { + _this->_impl_.box_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.box_); + } else { + _this->_impl_.box_->MergeFrom(*from._impl_.box_); + } + } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void WorldPlayersResult::CopyFrom(const WorldPlayersResult& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldPlayersResult) +void WorldEntitiesWithinResult::CopyFrom(const WorldEntitiesWithinResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldEntitiesWithinResult) if (&from == this) return; Clear(); MergeFrom(from); } -void WorldPlayersResult::InternalSwap(WorldPlayersResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldEntitiesWithinResult::InternalSwap(WorldEntitiesWithinResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.players_.InternalSwap(&other->_impl_.players_); - swap(_impl_.world_, other->_impl_.world_); + _impl_.entities_.InternalSwap(&other->_impl_.entities_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.box_) + + sizeof(WorldEntitiesWithinResult::_impl_.box_) + - PROTOBUF_FIELD_OFFSET(WorldEntitiesWithinResult, _impl_.world_)>( + reinterpret_cast(&_impl_.world_), + reinterpret_cast(&other->_impl_.world_)); } -::google::protobuf::Metadata WorldPlayersResult::GetMetadata() const { +::google::protobuf::Metadata WorldEntitiesWithinResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== -class WorldViewersResult::_Internal { +class WorldPlayersResult::_Internal { public: using HasBits = - decltype(::std::declval()._impl_._has_bits_); + decltype(::std::declval()._impl_._has_bits_); static constexpr ::int32_t kHasBitsOffset = - 8 * PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._has_bits_); + 8 * PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_); }; -void WorldViewersResult::clear_world() { +void WorldPlayersResult::clear_world() { ::google::protobuf::internal::TSanWrite(&_impl_); if (_impl_.world_ != nullptr) _impl_.world_->Clear(); ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } -void WorldViewersResult::clear_position() { +void WorldPlayersResult::clear_players() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ != nullptr) _impl_.position_->Clear(); - ClearHasBit(_impl_._has_bits_[0], - 0x00000004U); + _impl_.players_.Clear(); + ClearHasBitForRepeated(_impl_._has_bits_[0], + 0x00000001U); } -WorldViewersResult::WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) +WorldPlayersResult::WorldPlayersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldViewersResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(arena_constructor:df.plugin.WorldPlayersResult) } -PROTOBUF_NDEBUG_INLINE WorldViewersResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - [[maybe_unused]] const ::df::plugin::WorldViewersResult& from_msg) + [[maybe_unused]] const ::df::plugin::WorldPlayersResult& from_msg) : _has_bits_{from._has_bits_}, _cached_size_{0}, - viewer_uuids_{visibility, arena, from.viewer_uuids_} {} + players_{visibility, arena, from.players_} {} -WorldViewersResult::WorldViewersResult( +WorldPlayersResult::WorldPlayersResult( ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, - const WorldViewersResult& from) + const WorldPlayersResult& from) #if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::Message(arena, WorldViewersResult_class_data_.base()) { + : ::google::protobuf::Message(arena, WorldPlayersResult_class_data_.base()) { #else // PROTOBUF_CUSTOM_VTABLE : ::google::protobuf::Message(arena) { #endif // PROTOBUF_CUSTOM_VTABLE - WorldViewersResult* const _this = this; + WorldPlayersResult* const _this = this; (void)_this; _internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); @@ -14575,190 +13769,167 @@ WorldViewersResult::WorldViewersResult( _impl_.world_ = (CheckHasBit(cached_has_bits, 0x00000002U)) ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.world_) : nullptr; - _impl_.position_ = (CheckHasBit(cached_has_bits, 0x00000004U)) - ? ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_) - : nullptr; - // @@protoc_insertion_point(copy_constructor:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(copy_constructor:df.plugin.WorldPlayersResult) } -PROTOBUF_NDEBUG_INLINE WorldViewersResult::Impl_::Impl_( +PROTOBUF_NDEBUG_INLINE WorldPlayersResult::Impl_::Impl_( [[maybe_unused]] ::google::protobuf::internal::InternalVisibility visibility, [[maybe_unused]] ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) : _cached_size_{0}, - viewer_uuids_{visibility, arena} {} + players_{visibility, arena} {} -inline void WorldViewersResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { +inline void WorldPlayersResult::SharedCtor(::_pb::Arena* PROTOBUF_NULLABLE arena) { new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, world_), - 0, - offsetof(Impl_, position_) - - offsetof(Impl_, world_) + - sizeof(Impl_::position_)); + _impl_.world_ = {}; } -WorldViewersResult::~WorldViewersResult() { - // @@protoc_insertion_point(destructor:df.plugin.WorldViewersResult) +WorldPlayersResult::~WorldPlayersResult() { + // @@protoc_insertion_point(destructor:df.plugin.WorldPlayersResult) SharedDtor(*this); } -inline void WorldViewersResult::SharedDtor(MessageLite& self) { - WorldViewersResult& this_ = static_cast(self); +inline void WorldPlayersResult::SharedDtor(MessageLite& self) { + WorldPlayersResult& this_ = static_cast(self); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } this_._internal_metadata_.Delete<::google::protobuf::UnknownFieldSet>(); ABSL_DCHECK(this_.GetArena() == nullptr); delete this_._impl_.world_; - delete this_._impl_.position_; this_._impl_.~Impl_(); } -inline void* PROTOBUF_NONNULL WorldViewersResult::PlacementNew_( +inline void* PROTOBUF_NONNULL WorldPlayersResult::PlacementNew_( const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena) { - return ::new (mem) WorldViewersResult(arena); + return ::new (mem) WorldPlayersResult(arena); } -constexpr auto WorldViewersResult::InternalNewImpl_() { +constexpr auto WorldPlayersResult::InternalNewImpl_() { constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_) + - decltype(WorldViewersResult::_impl_.viewer_uuids_):: + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_) + + decltype(WorldPlayersResult::_impl_.players_):: InternalGetArenaOffset( ::google::protobuf::Message::internal_visibility()), }); if (arena_bits.has_value()) { return ::google::protobuf::internal::MessageCreator::ZeroInit( - sizeof(WorldViewersResult), alignof(WorldViewersResult), *arena_bits); + sizeof(WorldPlayersResult), alignof(WorldPlayersResult), *arena_bits); } else { - return ::google::protobuf::internal::MessageCreator(&WorldViewersResult::PlacementNew_, - sizeof(WorldViewersResult), - alignof(WorldViewersResult)); + return ::google::protobuf::internal::MessageCreator(&WorldPlayersResult::PlacementNew_, + sizeof(WorldPlayersResult), + alignof(WorldPlayersResult)); } } -constexpr auto WorldViewersResult::InternalGenerateClassData_() { +constexpr auto WorldPlayersResult::InternalGenerateClassData_() { return ::google::protobuf::internal::ClassDataFull{ ::google::protobuf::internal::ClassData{ - &_WorldViewersResult_default_instance_._instance, + &_WorldPlayersResult_default_instance_._instance, &_table_.header, nullptr, // OnDemandRegisterArenaDtor nullptr, // IsInitialized - &WorldViewersResult::MergeImpl, - ::google::protobuf::Message::GetNewImpl(), + &WorldPlayersResult::MergeImpl, + ::google::protobuf::Message::GetNewImpl(), #if defined(PROTOBUF_CUSTOM_VTABLE) - &WorldViewersResult::SharedDtor, - ::google::protobuf::Message::GetClearImpl(), &WorldViewersResult::ByteSizeLong, - &WorldViewersResult::_InternalSerialize, + &WorldPlayersResult::SharedDtor, + ::google::protobuf::Message::GetClearImpl(), &WorldPlayersResult::ByteSizeLong, + &WorldPlayersResult::_InternalSerialize, #endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._cached_size_), + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._cached_size_), false, }, - &WorldViewersResult::kDescriptorMethods, + &WorldPlayersResult::kDescriptorMethods, &descriptor_table_actions_2eproto, nullptr, // tracker }; } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 const - ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_ = - WorldViewersResult::InternalGenerateClassData_(); + ::google::protobuf::internal::ClassDataFull WorldPlayersResult_class_data_ = + WorldPlayersResult::InternalGenerateClassData_(); PROTOBUF_ATTRIBUTE_WEAK const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL -WorldViewersResult::GetClassData() const { - ::google::protobuf::internal::PrefetchToLocalCache(&WorldViewersResult_class_data_); - ::google::protobuf::internal::PrefetchToLocalCache(WorldViewersResult_class_data_.tc_table); - return WorldViewersResult_class_data_.base(); +WorldPlayersResult::GetClassData() const { + ::google::protobuf::internal::PrefetchToLocalCache(&WorldPlayersResult_class_data_); + ::google::protobuf::internal::PrefetchToLocalCache(WorldPlayersResult_class_data_.tc_table); + return WorldPlayersResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 2, 49, 2> -WorldViewersResult::_table_ = { +const ::_pbi::TcParseTable<1, 2, 2, 0, 2> +WorldPlayersResult::_table_ = { { - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_._has_bits_), + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_._has_bits_), 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask + 2, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap + 4294967292, // skipmap offsetof(decltype(_table_), field_entries), - 3, // num_field_entries + 2, // num_field_entries 2, // num_aux_entries offsetof(decltype(_table_), aux_entries), - WorldViewersResult_class_data_.base(), + WorldPlayersResult_class_data_.base(), nullptr, // post_loop_handler ::_pbi::TcParser::GenericFallback, // fallback #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::df::plugin::WorldViewersResult>(), // to_prefetch + ::_pbi::TcParser::GetTable<::df::plugin::WorldPlayersResult>(), // to_prefetch #endif // PROTOBUF_PREFETCH_PARSE_TABLE }, {{ - {::_pbi::TcParser::MiniParse, {}}, + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + {::_pbi::TcParser::FastMtR1, + {18, 0, 1, + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_)}}, // .df.plugin.WorldRef world = 1 [json_name = "world"]; {::_pbi::TcParser::FastMtS1, {10, 1, 0, - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_)}}, - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {::_pbi::TcParser::FastMtS1, - {18, 2, 1, - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_)}}, - // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; - {::_pbi::TcParser::FastUR1, - {26, 0, 0, - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_)}}, + PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_)}}, }}, {{ 65535, 65535 }}, {{ // .df.plugin.WorldRef world = 1 [json_name = "world"]; - {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_), _Internal::kHasBitsOffset + 2, 1, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; - {PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.viewer_uuids_), _Internal::kHasBitsOffset + 0, 0, (0 | ::_fl::kFcRepeated | ::_fl::kUtf8String | ::_fl::kRepSString)}, + {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.world_), _Internal::kHasBitsOffset + 1, 0, (0 | ::_fl::kFcOptional | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; + {PROTOBUF_FIELD_OFFSET(WorldPlayersResult, _impl_.players_), _Internal::kHasBitsOffset + 0, 1, (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::WorldRef>()}, - {::_pbi::TcParser::GetTable<::df::plugin::Vec3>()}, + {::_pbi::TcParser::GetTable<::df::plugin::EntityRef>()}, }}, {{ - "\34\0\0\14\0\0\0\0" - "df.plugin.WorldViewersResult" - "viewer_uuids" }}, }; -PROTOBUF_NOINLINE void WorldViewersResult::Clear() { -// @@protoc_insertion_point(message_clear_start:df.plugin.WorldViewersResult) +PROTOBUF_NOINLINE void WorldPlayersResult::Clear() { +// @@protoc_insertion_point(message_clear_start:df.plugin.WorldPlayersResult) ::google::protobuf::internal::TSanWrite(&_impl_); ::uint32_t cached_has_bits = 0; // Prevent compiler warnings about cached_has_bits being unused (void) cached_has_bits; cached_has_bits = _impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _impl_.viewer_uuids_.Clear(); + _impl_.players_.Clear(); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { ABSL_DCHECK(_impl_.world_ != nullptr); _impl_.world_->Clear(); } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(_impl_.position_ != nullptr); - _impl_.position_->Clear(); - } } _impl_._has_bits_.Clear(); _internal_metadata_.Clear<::google::protobuf::UnknownFieldSet>(); } #if defined(PROTOBUF_CUSTOM_VTABLE) -::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( const ::google::protobuf::MessageLite& base, ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) { - const WorldViewersResult& this_ = static_cast(base); + const WorldPlayersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( +::uint8_t* PROTOBUF_NONNULL WorldPlayersResult::_InternalSerialize( ::uint8_t* PROTOBUF_NONNULL target, ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - const WorldViewersResult& this_ = *this; + const WorldPlayersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { this_.CheckHasBitConsistency(); } - // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(serialize_to_array_start:df.plugin.WorldPlayersResult) ::uint32_t cached_has_bits = 0; (void)cached_has_bits; @@ -14770,20 +13941,16 @@ ::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( stream); } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.position_, this_._impl_.position_->GetCachedSize(), target, - stream); - } - - // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - for (int i = 0, n = this_._internal_viewer_uuids_size(); i < n; ++i) { - const auto& s = this_._internal_viewer_uuids().Get(i); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - s.data(), static_cast(s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "df.plugin.WorldViewersResult.viewer_uuids"); - target = stream->WriteString(3, s, target); + for (unsigned i = 0, n = static_cast( + this_._internal_players_size()); + i < n; i++) { + const auto& repfield = this_._internal_players().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, repfield, repfield.GetCachedSize(), + target, stream); } } @@ -14792,18 +13959,18 @@ ::uint8_t* PROTOBUF_NONNULL WorldViewersResult::_InternalSerialize( ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( this_._internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance), target, stream); } - // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(serialize_to_array_end:df.plugin.WorldPlayersResult) return target; } #if defined(PROTOBUF_CUSTOM_VTABLE) -::size_t WorldViewersResult::ByteSizeLong(const MessageLite& base) { - const WorldViewersResult& this_ = static_cast(base); +::size_t WorldPlayersResult::ByteSizeLong(const MessageLite& base) { + const WorldPlayersResult& this_ = static_cast(base); #else // PROTOBUF_CUSTOM_VTABLE -::size_t WorldViewersResult::ByteSizeLong() const { - const WorldViewersResult& this_ = *this; +::size_t WorldPlayersResult::ByteSizeLong() const { + const WorldPlayersResult& this_ = *this; #endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(message_byte_size_start:df.plugin.WorldPlayersResult) ::size_t total_size = 0; ::uint32_t cached_has_bits = 0; @@ -14812,14 +13979,12 @@ ::size_t WorldViewersResult::ByteSizeLong() const { ::_pbi::Prefetch5LinesFrom7Lines(&this_); cached_has_bits = this_._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { - // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { + // repeated .df.plugin.EntityRef players = 2 [json_name = "players"]; if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - total_size += - 1 * ::google::protobuf::internal::FromIntSize(this_._internal_viewer_uuids().size()); - for (int i = 0, n = this_._internal_viewer_uuids().size(); i < n; ++i) { - total_size += ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_viewer_uuids().Get(i)); + total_size += 1UL * this_._internal_players_size(); + for (const auto& msg : this_._internal_players()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); } } // .df.plugin.WorldRef world = 1 [json_name = "world"]; @@ -14827,36 +13992,31 @@ ::size_t WorldViewersResult::ByteSizeLong() const { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.world_); } - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.position_); - } } return this_.MaybeComputeUnknownFieldsSize(total_size, &this_._impl_._cached_size_); } -void WorldViewersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, +void WorldPlayersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { auto* const _this = - static_cast(&to_msg); - auto& from = static_cast(from_msg); + static_cast(&to_msg); + auto& from = static_cast(from_msg); if constexpr (::_pbi::DebugHardenCheckHasBitConsistency()) { from.CheckHasBitConsistency(); } ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldViewersResult) + // @@protoc_insertion_point(class_specific_merge_from_start:df.plugin.WorldPlayersResult) ABSL_DCHECK_NE(&from, _this); ::uint32_t cached_has_bits = 0; (void)cached_has_bits; cached_has_bits = from._impl_._has_bits_[0]; - if (BatchCheckHasBit(cached_has_bits, 0x00000007U)) { + if (BatchCheckHasBit(cached_has_bits, 0x00000003U)) { if (CheckHasBitForRepeated(cached_has_bits, 0x00000001U)) { - _this->_internal_mutable_viewer_uuids()->InternalMergeFromWithArena( + _this->_internal_mutable_players()->InternalMergeFromWithArena( ::google::protobuf::MessageLite::internal_visibility(), arena, - from._internal_viewer_uuids()); + from._internal_players()); } if (CheckHasBit(cached_has_bits, 0x00000002U)) { ABSL_DCHECK(from._impl_.world_ != nullptr); @@ -14866,42 +14026,29 @@ void WorldViewersResult::MergeImpl(::google::protobuf::MessageLite& to_msg, _this->_impl_.world_->MergeFrom(*from._impl_.world_); } } - if (CheckHasBit(cached_has_bits, 0x00000004U)) { - ABSL_DCHECK(from._impl_.position_ != nullptr); - if (_this->_impl_.position_ == nullptr) { - _this->_impl_.position_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.position_); - } else { - _this->_impl_.position_->MergeFrom(*from._impl_.position_); - } - } } _this->_impl_._has_bits_[0] |= cached_has_bits; _this->_internal_metadata_.MergeFrom<::google::protobuf::UnknownFieldSet>( from._internal_metadata_); } -void WorldViewersResult::CopyFrom(const WorldViewersResult& from) { - // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldViewersResult) +void WorldPlayersResult::CopyFrom(const WorldPlayersResult& from) { + // @@protoc_insertion_point(class_specific_copy_from_start:df.plugin.WorldPlayersResult) if (&from == this) return; Clear(); MergeFrom(from); } -void WorldViewersResult::InternalSwap(WorldViewersResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { +void WorldPlayersResult::InternalSwap(WorldPlayersResult* PROTOBUF_RESTRICT PROTOBUF_NONNULL other) { using ::std::swap; _internal_metadata_.InternalSwap(&other->_internal_metadata_); swap(_impl_._has_bits_[0], other->_impl_._has_bits_[0]); - _impl_.viewer_uuids_.InternalSwap(&other->_impl_.viewer_uuids_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.position_) - + sizeof(WorldViewersResult::_impl_.position_) - - PROTOBUF_FIELD_OFFSET(WorldViewersResult, _impl_.world_)>( - reinterpret_cast(&_impl_.world_), - reinterpret_cast(&other->_impl_.world_)); + _impl_.players_.InternalSwap(&other->_impl_.players_); + swap(_impl_.world_, other->_impl_.world_); } -::google::protobuf::Metadata WorldViewersResult::GetMetadata() const { +::google::protobuf::Metadata WorldPlayersResult::GetMetadata() const { return ::google::protobuf::Message::GetMetadataImpl(GetClassData()->full()); } // =================================================================== @@ -14955,19 +14102,6 @@ void ActionResult::set_allocated_world_entities_within(::df::plugin::WorldEntiti } // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_entities_within) } -void ActionResult::set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE world_viewers) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_result(); - if (world_viewers) { - ::google::protobuf::Arena* submessage_arena = world_viewers->GetArena(); - if (message_arena != submessage_arena) { - world_viewers = ::google::protobuf::internal::GetOwnedMessage(message_arena, world_viewers, submessage_arena); - } - set_has_world_viewers(); - _impl_.result_.world_viewers_ = world_viewers; - } - // @@protoc_insertion_point(field_set_allocated:df.plugin.ActionResult.world_viewers) -} ActionResult::ActionResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena) #if defined(PROTOBUF_CUSTOM_VTABLE) : ::google::protobuf::Message(arena, ActionResult_class_data_.base()) { @@ -15016,9 +14150,6 @@ ActionResult::ActionResult( case kWorldEntitiesWithin: _impl_.result_.world_entities_within_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_entities_within_); break; - case kWorldViewers: - _impl_.result_.world_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_viewers_); - break; } // @@protoc_insertion_point(copy_constructor:df.plugin.ActionResult) @@ -15082,14 +14213,6 @@ void ActionResult::clear_result() { } break; } - case kWorldViewers: { - if (GetArena() == nullptr) { - delete _impl_.result_.world_viewers_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_viewers_); - } - break; - } case RESULT_NOT_SET: { break; } @@ -15141,17 +14264,17 @@ ActionResult::GetClassData() const { return ActionResult_class_data_.base(); } PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 6, 5, 45, 2> +const ::_pbi::TcParseTable<1, 5, 4, 45, 2> ActionResult::_table_ = { { PROTOBUF_FIELD_OFFSET(ActionResult, _impl_._has_bits_), 0, // no _extensions_ - 13, 8, // max_field_number, fast_idx_mask + 12, 8, // max_field_number, fast_idx_mask offsetof(decltype(_table_), field_lookup_table), - 4294959612, // skipmap + 4294963708, // skipmap offsetof(decltype(_table_), field_entries), - 6, // num_field_entries - 5, // num_aux_entries + 5, // num_field_entries + 4, // num_aux_entries offsetof(decltype(_table_), aux_entries), ActionResult_class_data_.base(), nullptr, // post_loop_handler @@ -15181,15 +14304,12 @@ ActionResult::_table_ = { {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_players_), _Internal::kOneofCaseOffset + 0, 2, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, // .df.plugin.WorldEntitiesWithinResult world_entities_within = 12 [json_name = "worldEntitiesWithin"]; {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_entities_within_), _Internal::kOneofCaseOffset + 0, 3, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; - {PROTOBUF_FIELD_OFFSET(ActionResult, _impl_.result_.world_viewers_), _Internal::kOneofCaseOffset + 0, 4, (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, }}, {{ {::_pbi::TcParser::GetTable<::df::plugin::ActionStatus>()}, {::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesResult>()}, {::_pbi::TcParser::GetTable<::df::plugin::WorldPlayersResult>()}, {::_pbi::TcParser::GetTable<::df::plugin::WorldEntitiesWithinResult>()}, - {::_pbi::TcParser::GetTable<::df::plugin::WorldViewersResult>()}, }}, {{ "\26\16\0\0\0\0\0\0" @@ -15274,12 +14394,6 @@ ::uint8_t* PROTOBUF_NONNULL ActionResult::_InternalSerialize( stream); break; } - case kWorldViewers: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 13, *this_._impl_.result_.world_viewers_, this_._impl_.result_.world_viewers_->GetCachedSize(), target, - stream); - break; - } default: break; } @@ -15341,12 +14455,6 @@ ::size_t ActionResult::ByteSizeLong() const { ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_entities_within_); break; } - // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; - case kWorldViewers: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.result_.world_viewers_); - break; - } case RESULT_NOT_SET: { break; } @@ -15426,14 +14534,6 @@ void ActionResult::MergeImpl(::google::protobuf::MessageLite& to_msg, } break; } - case kWorldViewers: { - if (oneof_needs_init) { - _this->_impl_.result_.world_viewers_ = ::google::protobuf::Message::CopyConstruct(arena, *from._impl_.result_.world_viewers_); - } else { - _this->_impl_.result_.world_viewers_->MergeFrom(*from._impl_.result_.world_viewers_); - } - break; - } case RESULT_NOT_SET: break; } diff --git a/packages/cpp/src/generated/actions.pb.h b/packages/cpp/src/generated/actions.pb.h index 5a581e5..962e7c3 100644 --- a/packages/cpp/src/generated/actions.pb.h +++ b/packages/cpp/src/generated/actions.pb.h @@ -178,10 +178,6 @@ class WorldQueryPlayersAction; struct WorldQueryPlayersActionDefaultTypeInternal; extern WorldQueryPlayersActionDefaultTypeInternal _WorldQueryPlayersAction_default_instance_; extern const ::google::protobuf::internal::ClassDataFull WorldQueryPlayersAction_class_data_; -class WorldQueryViewersAction; -struct WorldQueryViewersActionDefaultTypeInternal; -extern WorldQueryViewersActionDefaultTypeInternal _WorldQueryViewersAction_default_instance_; -extern const ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_; class WorldSetBlockAction; struct WorldSetBlockActionDefaultTypeInternal; extern WorldSetBlockActionDefaultTypeInternal _WorldSetBlockAction_default_instance_; @@ -198,10 +194,6 @@ class WorldSetTickRangeAction; struct WorldSetTickRangeActionDefaultTypeInternal; extern WorldSetTickRangeActionDefaultTypeInternal _WorldSetTickRangeAction_default_instance_; extern const ::google::protobuf::internal::ClassDataFull WorldSetTickRangeAction_class_data_; -class WorldViewersResult; -struct WorldViewersResultDefaultTypeInternal; -extern WorldViewersResultDefaultTypeInternal _WorldViewersResult_default_instance_; -extern const ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_; } // namespace plugin } // namespace df namespace google { @@ -3170,7 +3162,7 @@ class ActionStatus final : public ::google::protobuf::Message return *reinterpret_cast( &_ActionStatus_default_instance_); } - static constexpr int kIndexInFileMessages = 30; + static constexpr int kIndexInFileMessages = 29; friend void swap(ActionStatus& a, ActionStatus& b) { a.Swap(&b); } inline void Swap(ActionStatus* PROTOBUF_NONNULL other) { if (other == this) return; @@ -3323,242 +3315,6 @@ class ActionStatus final : public ::google::protobuf::Message extern const ::google::protobuf::internal::ClassDataFull ActionStatus_class_data_; // ------------------------------------------------------------------- -class WorldViewersResult final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.WorldViewersResult) */ { - public: - inline WorldViewersResult() : WorldViewersResult(nullptr) {} - ~WorldViewersResult() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(WorldViewersResult* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldViewersResult)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR WorldViewersResult(::google::protobuf::internal::ConstantInitialized); - - inline WorldViewersResult(const WorldViewersResult& from) : WorldViewersResult(nullptr, from) {} - inline WorldViewersResult(WorldViewersResult&& from) noexcept - : WorldViewersResult(nullptr, ::std::move(from)) {} - inline WorldViewersResult& operator=(const WorldViewersResult& from) { - CopyFrom(from); - return *this; - } - inline WorldViewersResult& operator=(WorldViewersResult&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); - } - inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); - } - - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { - return GetDescriptor(); - } - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WorldViewersResult& default_instance() { - return *reinterpret_cast( - &_WorldViewersResult_default_instance_); - } - static constexpr int kIndexInFileMessages = 34; - friend void swap(WorldViewersResult& a, WorldViewersResult& b) { a.Swap(&b); } - inline void Swap(WorldViewersResult* PROTOBUF_NONNULL other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WorldViewersResult* PROTOBUF_NONNULL other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WorldViewersResult* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); - } - using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const WorldViewersResult& from); - using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const WorldViewersResult& from) { WorldViewersResult::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(WorldViewersResult* PROTOBUF_NONNULL other); - private: - template - friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.WorldViewersResult"; } - - explicit WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - WorldViewersResult(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldViewersResult& from); - WorldViewersResult( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldViewersResult&& from) noexcept - : WorldViewersResult(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; - static void* PROTOBUF_NONNULL PlacementNew_( - const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static constexpr auto InternalNewImpl_(); - - public: - static constexpr auto InternalGenerateClassData_(); - - ::google::protobuf::Metadata GetMetadata() const; - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kViewerUuidsFieldNumber = 3, - kWorldFieldNumber = 1, - kPositionFieldNumber = 2, - }; - // repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; - int viewer_uuids_size() const; - private: - int _internal_viewer_uuids_size() const; - - public: - void clear_viewer_uuids() ; - const ::std::string& viewer_uuids(int index) const; - ::std::string* PROTOBUF_NONNULL mutable_viewer_uuids(int index); - template - void set_viewer_uuids(int index, Arg_&& value, Args_... args); - ::std::string* PROTOBUF_NONNULL add_viewer_uuids(); - template - void add_viewer_uuids(Arg_&& value, Args_... args); - const ::google::protobuf::RepeatedPtrField<::std::string>& viewer_uuids() const; - ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL mutable_viewer_uuids(); - - private: - const ::google::protobuf::RepeatedPtrField<::std::string>& _internal_viewer_uuids() const; - ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL _internal_mutable_viewer_uuids(); - - public: - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - bool has_world() const; - void clear_world() ; - const ::df::plugin::WorldRef& world() const; - [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); - ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); - void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); - ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); - - private: - const ::df::plugin::WorldRef& _internal_world() const; - ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); - - public: - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - bool has_position() const; - void clear_position() ; - const ::df::plugin::Vec3& position() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); - void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); - - private: - const ::df::plugin::Vec3& _internal_position() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); - - public: - // @@protoc_insertion_point(class_scope:df.plugin.WorldViewersResult) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<2, 3, - 2, 49, - 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const WorldViewersResult& from_msg); - ::google::protobuf::internal::HasBits<1> _has_bits_; - ::google::protobuf::internal::CachedSize _cached_size_; - ::google::protobuf::RepeatedPtrField<::std::string> viewer_uuids_; - ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_actions_2eproto; -}; - -extern const ::google::protobuf::internal::ClassDataFull WorldViewersResult_class_data_; -// ------------------------------------------------------------------- - class WorldSetTickRangeAction final : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:df.plugin.WorldSetTickRangeAction) */ { public: @@ -4097,215 +3853,8 @@ class WorldSetDefaultGameModeAction final : public ::google::protobuf::Message explicit WorldSetDefaultGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); WorldSetDefaultGameModeAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldSetDefaultGameModeAction& from); WorldSetDefaultGameModeAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetDefaultGameModeAction&& from) noexcept - : WorldSetDefaultGameModeAction(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; - static void* PROTOBUF_NONNULL PlacementNew_( - const void* PROTOBUF_NONNULL, void* PROTOBUF_NONNULL mem, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static constexpr auto InternalNewImpl_(); - - public: - static constexpr auto InternalGenerateClassData_(); - - ::google::protobuf::Metadata GetMetadata() const; - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kWorldFieldNumber = 1, - kGameModeFieldNumber = 2, - }; - // .df.plugin.WorldRef world = 1 [json_name = "world"]; - bool has_world() const; - void clear_world() ; - const ::df::plugin::WorldRef& world() const; - [[nodiscard]] ::df::plugin::WorldRef* PROTOBUF_NULLABLE release_world(); - ::df::plugin::WorldRef* PROTOBUF_NONNULL mutable_world(); - void set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value); - ::df::plugin::WorldRef* PROTOBUF_NULLABLE unsafe_arena_release_world(); - - private: - const ::df::plugin::WorldRef& _internal_world() const; - ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); - - public: - // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; - void clear_game_mode() ; - ::df::plugin::GameMode game_mode() const; - void set_game_mode(::df::plugin::GameMode value); - - private: - ::df::plugin::GameMode _internal_game_mode() const; - void _internal_set_game_mode(::df::plugin::GameMode value); - - public: - // @@protoc_insertion_point(class_scope:df.plugin.WorldSetDefaultGameModeAction) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<1, 2, - 1, 0, - 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_(::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - inline explicit Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const WorldSetDefaultGameModeAction& from_msg); - ::google::protobuf::internal::HasBits<1> _has_bits_; - ::google::protobuf::internal::CachedSize _cached_size_; - ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; - int game_mode_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_actions_2eproto; -}; - -extern const ::google::protobuf::internal::ClassDataFull WorldSetDefaultGameModeAction_class_data_; -// ------------------------------------------------------------------- - -class WorldQueryViewersAction final : public ::google::protobuf::Message -/* @@protoc_insertion_point(class_definition:df.plugin.WorldQueryViewersAction) */ { - public: - inline WorldQueryViewersAction() : WorldQueryViewersAction(nullptr) {} - ~WorldQueryViewersAction() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(WorldQueryViewersAction* PROTOBUF_NONNULL msg, ::std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(WorldQueryViewersAction)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR WorldQueryViewersAction(::google::protobuf::internal::ConstantInitialized); - - inline WorldQueryViewersAction(const WorldQueryViewersAction& from) : WorldQueryViewersAction(nullptr, from) {} - inline WorldQueryViewersAction(WorldQueryViewersAction&& from) noexcept - : WorldQueryViewersAction(nullptr, ::std::move(from)) {} - inline WorldQueryViewersAction& operator=(const WorldQueryViewersAction& from) { - CopyFrom(from); - return *this; - } - inline WorldQueryViewersAction& operator=(WorldQueryViewersAction&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields<::google::protobuf::UnknownFieldSet>(::google::protobuf::UnknownFieldSet::default_instance); - } - inline ::google::protobuf::UnknownFieldSet* PROTOBUF_NONNULL mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields<::google::protobuf::UnknownFieldSet>(); - } - - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL descriptor() { - return GetDescriptor(); - } - static const ::google::protobuf::Descriptor* PROTOBUF_NONNULL GetDescriptor() { - return default_instance().GetMetadata().descriptor; - } - static const ::google::protobuf::Reflection* PROTOBUF_NONNULL GetReflection() { - return default_instance().GetMetadata().reflection; - } - static const WorldQueryViewersAction& default_instance() { - return *reinterpret_cast( - &_WorldQueryViewersAction_default_instance_); - } - static constexpr int kIndexInFileMessages = 29; - friend void swap(WorldQueryViewersAction& a, WorldQueryViewersAction& b) { a.Swap(&b); } - inline void Swap(WorldQueryViewersAction* PROTOBUF_NONNULL other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(WorldQueryViewersAction* PROTOBUF_NONNULL other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - WorldQueryViewersAction* PROTOBUF_NONNULL New(::google::protobuf::Arena* PROTOBUF_NULLABLE arena = nullptr) const { - return ::google::protobuf::Message::DefaultConstruct(arena); - } - using ::google::protobuf::Message::CopyFrom; - void CopyFrom(const WorldQueryViewersAction& from); - using ::google::protobuf::Message::MergeFrom; - void MergeFrom(const WorldQueryViewersAction& from) { WorldQueryViewersAction::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - const ::google::protobuf::MessageLite& msg, ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* PROTOBUF_NONNULL _InternalSerialize( - ::uint8_t* PROTOBUF_NONNULL target, - ::google::protobuf::io::EpsCopyOutputStream* PROTOBUF_NONNULL stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(WorldQueryViewersAction* PROTOBUF_NONNULL other); - private: - template - friend ::absl::string_view(::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "df.plugin.WorldQueryViewersAction"; } - - explicit WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena); - WorldQueryViewersAction(::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const WorldQueryViewersAction& from); - WorldQueryViewersAction( - ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldQueryViewersAction&& from) noexcept - : WorldQueryViewersAction(arena) { + ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, WorldSetDefaultGameModeAction&& from) noexcept + : WorldSetDefaultGameModeAction(arena) { *this = ::std::move(from); } const ::google::protobuf::internal::ClassData* PROTOBUF_NONNULL GetClassData() const PROTOBUF_FINAL; @@ -4323,7 +3872,7 @@ class WorldQueryViewersAction final : public ::google::protobuf::Message // accessors ------------------------------------------------------- enum : int { kWorldFieldNumber = 1, - kPositionFieldNumber = 2, + kGameModeFieldNumber = 2, }; // .df.plugin.WorldRef world = 1 [json_name = "world"]; bool has_world() const; @@ -4340,27 +3889,22 @@ class WorldQueryViewersAction final : public ::google::protobuf::Message ::df::plugin::WorldRef* PROTOBUF_NONNULL _internal_mutable_world(); public: - // .df.plugin.Vec3 position = 2 [json_name = "position"]; - bool has_position() const; - void clear_position() ; - const ::df::plugin::Vec3& position() const; - [[nodiscard]] ::df::plugin::Vec3* PROTOBUF_NULLABLE release_position(); - ::df::plugin::Vec3* PROTOBUF_NONNULL mutable_position(); - void set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value); - ::df::plugin::Vec3* PROTOBUF_NULLABLE unsafe_arena_release_position(); + // .df.plugin.GameMode game_mode = 2 [json_name = "gameMode"]; + void clear_game_mode() ; + ::df::plugin::GameMode game_mode() const; + void set_game_mode(::df::plugin::GameMode value); private: - const ::df::plugin::Vec3& _internal_position() const; - ::df::plugin::Vec3* PROTOBUF_NONNULL _internal_mutable_position(); + ::df::plugin::GameMode _internal_game_mode() const; + void _internal_set_game_mode(::df::plugin::GameMode value); public: - // @@protoc_insertion_point(class_scope:df.plugin.WorldQueryViewersAction) + // @@protoc_insertion_point(class_scope:df.plugin.WorldSetDefaultGameModeAction) private: class _Internal; friend class ::google::protobuf::internal::TcParser; static const ::google::protobuf::internal::TcParseTable<1, 2, - 2, 0, + 1, 0, 2> _table_; @@ -4378,18 +3922,18 @@ class WorldQueryViewersAction final : public ::google::protobuf::Message inline explicit Impl_( ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* PROTOBUF_NULLABLE arena, const Impl_& from, - const WorldQueryViewersAction& from_msg); + const WorldSetDefaultGameModeAction& from_msg); ::google::protobuf::internal::HasBits<1> _has_bits_; ::google::protobuf::internal::CachedSize _cached_size_; ::df::plugin::WorldRef* PROTOBUF_NULLABLE world_; - ::df::plugin::Vec3* PROTOBUF_NULLABLE position_; + int game_mode_; PROTOBUF_TSAN_DECLARE_MEMBER }; union { Impl_ _impl_; }; friend struct ::TableStruct_actions_2eproto; }; -extern const ::google::protobuf::internal::ClassDataFull WorldQueryViewersAction_class_data_; +extern const ::google::protobuf::internal::ClassDataFull WorldSetDefaultGameModeAction_class_data_; // ------------------------------------------------------------------- class WorldQueryPlayersAction final : public ::google::protobuf::Message @@ -6634,7 +6178,7 @@ class WorldPlayersResult final : public ::google::protobuf::Message return *reinterpret_cast( &_WorldPlayersResult_default_instance_); } - static constexpr int kIndexInFileMessages = 33; + static constexpr int kIndexInFileMessages = 32; friend void swap(WorldPlayersResult& a, WorldPlayersResult& b) { a.Swap(&b); } inline void Swap(WorldPlayersResult* PROTOBUF_NONNULL other) { if (other == this) return; @@ -6848,7 +6392,7 @@ class WorldEntitiesWithinResult final : public ::google::protobuf::Message return *reinterpret_cast( &_WorldEntitiesWithinResult_default_instance_); } - static constexpr int kIndexInFileMessages = 32; + static constexpr int kIndexInFileMessages = 31; friend void swap(WorldEntitiesWithinResult& a, WorldEntitiesWithinResult& b) { a.Swap(&b); } inline void Swap(WorldEntitiesWithinResult* PROTOBUF_NONNULL other) { if (other == this) return; @@ -7079,7 +6623,7 @@ class WorldEntitiesResult final : public ::google::protobuf::Message return *reinterpret_cast( &_WorldEntitiesResult_default_instance_); } - static constexpr int kIndexInFileMessages = 31; + static constexpr int kIndexInFileMessages = 30; friend void swap(WorldEntitiesResult& a, WorldEntitiesResult& b) { a.Swap(&b); } inline void Swap(WorldEntitiesResult* PROTOBUF_NONNULL other) { if (other == this) return; @@ -7551,10 +7095,9 @@ class ActionResult final : public ::google::protobuf::Message kWorldEntities = 10, kWorldPlayers = 11, kWorldEntitiesWithin = 12, - kWorldViewers = 13, RESULT_NOT_SET = 0, }; - static constexpr int kIndexInFileMessages = 35; + static constexpr int kIndexInFileMessages = 33; friend void swap(ActionResult& a, ActionResult& b) { a.Swap(&b); } inline void Swap(ActionResult* PROTOBUF_NONNULL other) { if (other == this) return; @@ -7646,7 +7189,6 @@ class ActionResult final : public ::google::protobuf::Message kWorldEntitiesFieldNumber = 10, kWorldPlayersFieldNumber = 11, kWorldEntitiesWithinFieldNumber = 12, - kWorldViewersFieldNumber = 13, }; // string correlation_id = 1 [json_name = "correlationId"]; void clear_correlation_id() ; @@ -7734,25 +7276,6 @@ class ActionResult final : public ::google::protobuf::Message const ::df::plugin::WorldEntitiesWithinResult& _internal_world_entities_within() const; ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL _internal_mutable_world_entities_within(); - public: - // .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; - bool has_world_viewers() const; - private: - bool _internal_has_world_viewers() const; - - public: - void clear_world_viewers() ; - const ::df::plugin::WorldViewersResult& world_viewers() const; - [[nodiscard]] ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE release_world_viewers(); - ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL mutable_world_viewers(); - void set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_viewers(::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value); - ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE unsafe_arena_release_world_viewers(); - - private: - const ::df::plugin::WorldViewersResult& _internal_world_viewers() const; - ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL _internal_mutable_world_viewers(); - public: void clear_result(); ResultCase result_case() const; @@ -7762,12 +7285,11 @@ class ActionResult final : public ::google::protobuf::Message void set_has_world_entities(); void set_has_world_players(); void set_has_world_entities_within(); - void set_has_world_viewers(); inline bool has_result() const; inline void clear_has_result(); friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<1, 6, - 5, 45, + static const ::google::protobuf::internal::TcParseTable<1, 5, + 4, 45, 2> _table_; @@ -7796,7 +7318,6 @@ class ActionResult final : public ::google::protobuf::Message ::google::protobuf::Message* PROTOBUF_NULLABLE world_entities_; ::google::protobuf::Message* PROTOBUF_NULLABLE world_players_; ::google::protobuf::Message* PROTOBUF_NULLABLE world_entities_within_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_viewers_; } result_; ::uint32_t _oneof_case_[1]; PROTOBUF_TSAN_DECLARE_MEMBER @@ -7891,7 +7412,6 @@ class Action final : public ::google::protobuf::Message kWorldQueryEntities = 70, kWorldQueryPlayers = 71, kWorldQueryEntitiesWithin = 72, - kWorldQueryViewers = 73, KIND_NOT_SET = 0, }; static constexpr int kIndexInFileMessages = 1; @@ -8009,7 +7529,6 @@ class Action final : public ::google::protobuf::Message kWorldQueryEntitiesFieldNumber = 70, kWorldQueryPlayersFieldNumber = 71, kWorldQueryEntitiesWithinFieldNumber = 72, - kWorldQueryViewersFieldNumber = 73, }; // optional string correlation_id = 1 [json_name = "correlationId"]; bool has_correlation_id() const; @@ -8539,25 +8058,6 @@ class Action final : public ::google::protobuf::Message const ::df::plugin::WorldQueryEntitiesWithinAction& _internal_world_query_entities_within() const; ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL _internal_mutable_world_query_entities_within(); - public: - // .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; - bool has_world_query_viewers() const; - private: - bool _internal_has_world_query_viewers() const; - - public: - void clear_world_query_viewers() ; - const ::df::plugin::WorldQueryViewersAction& world_query_viewers() const; - [[nodiscard]] ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE release_world_query_viewers(); - ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL mutable_world_query_viewers(); - void set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value); - void unsafe_arena_set_allocated_world_query_viewers(::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value); - ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE unsafe_arena_release_world_query_viewers(); - - private: - const ::df::plugin::WorldQueryViewersAction& _internal_world_query_viewers() const; - ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL _internal_mutable_world_query_viewers(); - public: void clear_kind(); KindCase kind_case() const; @@ -8591,12 +8091,11 @@ class Action final : public ::google::protobuf::Message void set_has_world_query_entities(); void set_has_world_query_players(); void set_has_world_query_entities_within(); - void set_has_world_query_viewers(); inline bool has_kind() const; inline void clear_has_kind(); friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable<0, 29, - 28, 63, + static const ::google::protobuf::internal::TcParseTable<0, 28, + 27, 63, 11> _table_; @@ -8648,7 +8147,6 @@ class Action final : public ::google::protobuf::Message ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_entities_; ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_players_; ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_entities_within_; - ::google::protobuf::Message* PROTOBUF_NULLABLE world_query_viewers_; } kind_; ::uint32_t _oneof_case_[1]; PROTOBUF_TSAN_DECLARE_MEMBER @@ -11215,88 +10713,6 @@ inline ::df::plugin::WorldQueryEntitiesWithinAction* PROTOBUF_NONNULL Action::mu return _msg; } -// .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; -inline bool Action::has_world_query_viewers() const { - return kind_case() == kWorldQueryViewers; -} -inline bool Action::_internal_has_world_query_viewers() const { - return kind_case() == kWorldQueryViewers; -} -inline void Action::set_has_world_query_viewers() { - _impl_._oneof_case_[0] = kWorldQueryViewers; -} -inline void Action::clear_world_query_viewers() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (kind_case() == kWorldQueryViewers) { - if (GetArena() == nullptr) { - delete _impl_.kind_.world_query_viewers_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.kind_.world_query_viewers_); - } - clear_has_kind(); - } -} -inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE Action::release_world_query_viewers() { - // @@protoc_insertion_point(field_release:df.plugin.Action.world_query_viewers) - if (kind_case() == kWorldQueryViewers) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.kind_.world_query_viewers_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::df::plugin::WorldQueryViewersAction& Action::_internal_world_query_viewers() const { - return kind_case() == kWorldQueryViewers ? static_cast(*reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_)) - : reinterpret_cast(::df::plugin::_WorldQueryViewersAction_default_instance_); -} -inline const ::df::plugin::WorldQueryViewersAction& Action::world_query_viewers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.Action.world_query_viewers) - return _internal_world_query_viewers(); -} -inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE Action::unsafe_arena_release_world_query_viewers() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.Action.world_query_viewers) - if (kind_case() == kWorldQueryViewers) { - clear_has_kind(); - auto* temp = reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); - _impl_.kind_.world_query_viewers_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Action::unsafe_arena_set_allocated_world_query_viewers( - ::df::plugin::WorldQueryViewersAction* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_kind(); - if (value) { - set_has_world_query_viewers(); - _impl_.kind_.world_query_viewers_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.Action.world_query_viewers) -} -inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL Action::_internal_mutable_world_query_viewers() { - if (kind_case() != kWorldQueryViewers) { - clear_kind(); - set_has_world_query_viewers(); - _impl_.kind_.world_query_viewers_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldQueryViewersAction>(GetArena())); - } - return reinterpret_cast<::df::plugin::WorldQueryViewersAction*>(_impl_.kind_.world_query_viewers_); -} -inline ::df::plugin::WorldQueryViewersAction* PROTOBUF_NONNULL Action::mutable_world_query_viewers() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::WorldQueryViewersAction* _msg = _internal_mutable_world_query_viewers(); - // @@protoc_insertion_point(field_mutable:df.plugin.Action.world_query_viewers) - return _msg; -} - inline bool Action::has_kind() const { return kind_case() != KIND_NOT_SET; } @@ -15689,220 +15105,30 @@ inline ::df::plugin::BBox* PROTOBUF_NULLABLE WorldQueryEntitiesWithinAction::uns // @@protoc_insertion_point(field_release:df.plugin.WorldQueryEntitiesWithinAction.box) ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::BBox* temp = _impl_.box_; - _impl_.box_ = nullptr; - return temp; -} -inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_internal_mutable_box() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.box_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BBox>(GetArena()); - _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(p); - } - return _impl_.box_; -} -inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::mutable_box() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::BBox* _msg = _internal_mutable_box(); - // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryEntitiesWithinAction.box) - return _msg; -} -inline void WorldQueryEntitiesWithinAction::set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); - ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - - _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.box) -} - -// ------------------------------------------------------------------- - -// WorldQueryViewersAction - -// .df.plugin.WorldRef world = 1 [json_name = "world"]; -inline bool WorldQueryViewersAction::has_world() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000001U); - PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); - return value; -} -inline const ::df::plugin::WorldRef& WorldQueryViewersAction::_internal_world() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::WorldRef* p = _impl_.world_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); -} -inline const ::df::plugin::WorldRef& WorldQueryViewersAction::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.WorldQueryViewersAction.world) - return _internal_world(); -} -inline void WorldQueryViewersAction::unsafe_arena_set_allocated_world( - ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); - } - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryViewersAction.world) -} -inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryViewersAction::release_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - ::df::plugin::WorldRef* released = _impl_.world_; - _impl_.world_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; -} -inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldQueryViewersAction::unsafe_arena_release_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.WorldQueryViewersAction.world) - - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - ::df::plugin::WorldRef* temp = _impl_.world_; - _impl_.world_ = nullptr; - return temp; -} -inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryViewersAction::_internal_mutable_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.world_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); - } - return _impl_.world_; -} -inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldQueryViewersAction::mutable_world() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - ::df::plugin::WorldRef* _msg = _internal_mutable_world(); - // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryViewersAction.world) - return _msg; -} -inline void WorldQueryViewersAction::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); - ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000001U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000001U); - } - - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryViewersAction.world) -} - -// .df.plugin.Vec3 position = 2 [json_name = "position"]; -inline bool WorldQueryViewersAction::has_position() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); - return value; -} -inline const ::df::plugin::Vec3& WorldQueryViewersAction::_internal_position() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::Vec3* p = _impl_.position_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); -} -inline const ::df::plugin::Vec3& WorldQueryViewersAction::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.WorldQueryViewersAction.position) - return _internal_position(); -} -inline void WorldQueryViewersAction::unsafe_arena_set_allocated_position( - ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); - } - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldQueryViewersAction.position) -} -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldQueryViewersAction::release_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* released = _impl_.position_; - _impl_.position_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; -} -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldQueryViewersAction::unsafe_arena_release_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.WorldQueryViewersAction.position) - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* temp = _impl_.position_; - _impl_.position_ = nullptr; + ::df::plugin::BBox* temp = _impl_.box_; + _impl_.box_ = nullptr; return temp; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldQueryViewersAction::_internal_mutable_position() { +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::_internal_mutable_box() { ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); + if (_impl_.box_ == nullptr) { + auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::BBox>(GetArena()); + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(p); } - return _impl_.position_; + return _impl_.box_; } -inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldQueryViewersAction::mutable_position() +inline ::df::plugin::BBox* PROTOBUF_NONNULL WorldQueryEntitiesWithinAction::mutable_box() ABSL_ATTRIBUTE_LIFETIME_BOUND { SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::Vec3* _msg = _internal_mutable_position(); - // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryViewersAction.position) + ::df::plugin::BBox* _msg = _internal_mutable_box(); + // @@protoc_insertion_point(field_mutable:df.plugin.WorldQueryEntitiesWithinAction.box) return _msg; } -inline void WorldQueryViewersAction::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { +inline void WorldQueryEntitiesWithinAction::set_allocated_box(::df::plugin::BBox* PROTOBUF_NULLABLE value) { ::google::protobuf::Arena* message_arena = GetArena(); ::google::protobuf::internal::TSanWrite(&_impl_); if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); + delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.box_); } if (value != nullptr) { @@ -15915,8 +15141,8 @@ inline void WorldQueryViewersAction::set_allocated_position(::df::plugin::Vec3* ClearHasBit(_impl_._has_bits_[0], 0x00000002U); } - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryViewersAction.position) + _impl_.box_ = reinterpret_cast<::df::plugin::BBox*>(value); + // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldQueryEntitiesWithinAction.box) } // ------------------------------------------------------------------- @@ -16553,268 +15779,6 @@ WorldPlayersResult::_internal_mutable_players() { // ------------------------------------------------------------------- -// WorldViewersResult - -// .df.plugin.WorldRef world = 1 [json_name = "world"]; -inline bool WorldViewersResult::has_world() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000002U); - PROTOBUF_ASSUME(!value || _impl_.world_ != nullptr); - return value; -} -inline const ::df::plugin::WorldRef& WorldViewersResult::_internal_world() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::WorldRef* p = _impl_.world_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_WorldRef_default_instance_); -} -inline const ::df::plugin::WorldRef& WorldViewersResult::world() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.world) - return _internal_world(); -} -inline void WorldViewersResult::unsafe_arena_set_allocated_world( - ::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); - } - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldViewersResult.world) -} -inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldViewersResult::release_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::WorldRef* released = _impl_.world_; - _impl_.world_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; -} -inline ::df::plugin::WorldRef* PROTOBUF_NULLABLE WorldViewersResult::unsafe_arena_release_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.WorldViewersResult.world) - - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::WorldRef* temp = _impl_.world_; - _impl_.world_ = nullptr; - return temp; -} -inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldViewersResult::_internal_mutable_world() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.world_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldRef>(GetArena()); - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(p); - } - return _impl_.world_; -} -inline ::df::plugin::WorldRef* PROTOBUF_NONNULL WorldViewersResult::mutable_world() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - ::df::plugin::WorldRef* _msg = _internal_mutable_world(); - // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.world) - return _msg; -} -inline void WorldViewersResult::set_allocated_world(::df::plugin::WorldRef* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); - ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.world_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000002U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000002U); - } - - _impl_.world_ = reinterpret_cast<::df::plugin::WorldRef*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldViewersResult.world) -} - -// .df.plugin.Vec3 position = 2 [json_name = "position"]; -inline bool WorldViewersResult::has_position() const { - bool value = CheckHasBit(_impl_._has_bits_[0], 0x00000004U); - PROTOBUF_ASSUME(!value || _impl_.position_ != nullptr); - return value; -} -inline const ::df::plugin::Vec3& WorldViewersResult::_internal_position() const { - ::google::protobuf::internal::TSanRead(&_impl_); - const ::df::plugin::Vec3* p = _impl_.position_; - return p != nullptr ? *p : reinterpret_cast(::df::plugin::_Vec3_default_instance_); -} -inline const ::df::plugin::Vec3& WorldViewersResult::position() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.position) - return _internal_position(); -} -inline void WorldViewersResult::unsafe_arena_set_allocated_position( - ::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (GetArena() == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); - } - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - if (value != nullptr) { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.WorldViewersResult.position) -} -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldViewersResult::release_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* released = _impl_.position_; - _impl_.position_ = nullptr; - if (::google::protobuf::internal::DebugHardenForceCopyInRelease()) { - auto* old = reinterpret_cast<::google::protobuf::MessageLite*>(released); - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - if (GetArena() == nullptr) { - delete old; - } - } else { - if (GetArena() != nullptr) { - released = ::google::protobuf::internal::DuplicateIfNonNull(released); - } - } - return released; -} -inline ::df::plugin::Vec3* PROTOBUF_NULLABLE WorldViewersResult::unsafe_arena_release_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:df.plugin.WorldViewersResult.position) - - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* temp = _impl_.position_; - _impl_.position_ = nullptr; - return temp; -} -inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldViewersResult::_internal_mutable_position() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (_impl_.position_ == nullptr) { - auto* p = ::google::protobuf::Message::DefaultConstruct<::df::plugin::Vec3>(GetArena()); - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(p); - } - return _impl_.position_; -} -inline ::df::plugin::Vec3* PROTOBUF_NONNULL WorldViewersResult::mutable_position() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - ::df::plugin::Vec3* _msg = _internal_mutable_position(); - // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.position) - return _msg; -} -inline void WorldViewersResult::set_allocated_position(::df::plugin::Vec3* PROTOBUF_NULLABLE value) { - ::google::protobuf::Arena* message_arena = GetArena(); - ::google::protobuf::internal::TSanWrite(&_impl_); - if (message_arena == nullptr) { - delete reinterpret_cast<::google::protobuf::MessageLite*>(_impl_.position_); - } - - if (value != nullptr) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::Message*>(value)->GetArena(); - if (message_arena != submessage_arena) { - value = ::google::protobuf::internal::GetOwnedMessage(message_arena, value, submessage_arena); - } - SetHasBit(_impl_._has_bits_[0], 0x00000004U); - } else { - ClearHasBit(_impl_._has_bits_[0], 0x00000004U); - } - - _impl_.position_ = reinterpret_cast<::df::plugin::Vec3*>(value); - // @@protoc_insertion_point(field_set_allocated:df.plugin.WorldViewersResult.position) -} - -// repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; -inline int WorldViewersResult::_internal_viewer_uuids_size() const { - return _internal_viewer_uuids().size(); -} -inline int WorldViewersResult::viewer_uuids_size() const { - return _internal_viewer_uuids_size(); -} -inline void WorldViewersResult::clear_viewer_uuids() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.viewer_uuids_.Clear(); - ClearHasBitForRepeated(_impl_._has_bits_[0], - 0x00000001U); -} -inline ::std::string* PROTOBUF_NONNULL WorldViewersResult::add_viewer_uuids() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::std::string* _s = - _internal_mutable_viewer_uuids()->InternalAddWithArena( - ::google::protobuf::MessageLite::internal_visibility(), GetArena()); - SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); - // @@protoc_insertion_point(field_add_mutable:df.plugin.WorldViewersResult.viewer_uuids) - return _s; -} -inline const ::std::string& WorldViewersResult::viewer_uuids(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.WorldViewersResult.viewer_uuids) - return _internal_viewer_uuids().Get(index); -} -inline ::std::string* PROTOBUF_NONNULL WorldViewersResult::mutable_viewer_uuids(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:df.plugin.WorldViewersResult.viewer_uuids) - return _internal_mutable_viewer_uuids()->Mutable(index); -} -template -inline void WorldViewersResult::set_viewer_uuids(int index, Arg_&& value, Args_... args) { - ::google::protobuf::internal::AssignToString(*_internal_mutable_viewer_uuids()->Mutable(index), ::std::forward(value), - args... ); - // @@protoc_insertion_point(field_set:df.plugin.WorldViewersResult.viewer_uuids) -} -template -inline void WorldViewersResult::add_viewer_uuids(Arg_&& value, Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::google::protobuf::internal::AddToRepeatedPtrField( - ::google::protobuf::MessageLite::internal_visibility(), GetArena(), - *_internal_mutable_viewer_uuids(), ::std::forward(value), - args... ); - SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); - // @@protoc_insertion_point(field_add:df.plugin.WorldViewersResult.viewer_uuids) -} -inline const ::google::protobuf::RepeatedPtrField<::std::string>& WorldViewersResult::viewer_uuids() - const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:df.plugin.WorldViewersResult.viewer_uuids) - return _internal_viewer_uuids(); -} -inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL -WorldViewersResult::mutable_viewer_uuids() ABSL_ATTRIBUTE_LIFETIME_BOUND { - SetHasBitForRepeated(_impl_._has_bits_[0], 0x00000001U); - // @@protoc_insertion_point(field_mutable_list:df.plugin.WorldViewersResult.viewer_uuids) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_viewer_uuids(); -} -inline const ::google::protobuf::RepeatedPtrField<::std::string>& -WorldViewersResult::_internal_viewer_uuids() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.viewer_uuids_; -} -inline ::google::protobuf::RepeatedPtrField<::std::string>* PROTOBUF_NONNULL -WorldViewersResult::_internal_mutable_viewer_uuids() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.viewer_uuids_; -} - -// ------------------------------------------------------------------- - // ActionResult // string correlation_id = 1 [json_name = "correlationId"]; @@ -17227,88 +16191,6 @@ inline ::df::plugin::WorldEntitiesWithinResult* PROTOBUF_NONNULL ActionResult::m return _msg; } -// .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; -inline bool ActionResult::has_world_viewers() const { - return result_case() == kWorldViewers; -} -inline bool ActionResult::_internal_has_world_viewers() const { - return result_case() == kWorldViewers; -} -inline void ActionResult::set_has_world_viewers() { - _impl_._oneof_case_[0] = kWorldViewers; -} -inline void ActionResult::clear_world_viewers() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (result_case() == kWorldViewers) { - if (GetArena() == nullptr) { - delete _impl_.result_.world_viewers_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - ::google::protobuf::internal::MaybePoisonAfterClear(_impl_.result_.world_viewers_); - } - clear_has_result(); - } -} -inline ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE ActionResult::release_world_viewers() { - // @@protoc_insertion_point(field_release:df.plugin.ActionResult.world_viewers) - if (result_case() == kWorldViewers) { - clear_has_result(); - auto* temp = reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.result_.world_viewers_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::df::plugin::WorldViewersResult& ActionResult::_internal_world_viewers() const { - return result_case() == kWorldViewers ? static_cast(*reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_)) - : reinterpret_cast(::df::plugin::_WorldViewersResult_default_instance_); -} -inline const ::df::plugin::WorldViewersResult& ActionResult::world_viewers() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:df.plugin.ActionResult.world_viewers) - return _internal_world_viewers(); -} -inline ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE ActionResult::unsafe_arena_release_world_viewers() { - // @@protoc_insertion_point(field_unsafe_arena_release:df.plugin.ActionResult.world_viewers) - if (result_case() == kWorldViewers) { - clear_has_result(); - auto* temp = reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); - _impl_.result_.world_viewers_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void ActionResult::unsafe_arena_set_allocated_world_viewers( - ::df::plugin::WorldViewersResult* PROTOBUF_NULLABLE value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_result(); - if (value) { - set_has_world_viewers(); - _impl_.result_.world_viewers_ = reinterpret_cast<::google::protobuf::Message*>(value); - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:df.plugin.ActionResult.world_viewers) -} -inline ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL ActionResult::_internal_mutable_world_viewers() { - if (result_case() != kWorldViewers) { - clear_result(); - set_has_world_viewers(); - _impl_.result_.world_viewers_ = reinterpret_cast<::google::protobuf::Message*>( - ::google::protobuf::Message::DefaultConstruct<::df::plugin::WorldViewersResult>(GetArena())); - } - return reinterpret_cast<::df::plugin::WorldViewersResult*>(_impl_.result_.world_viewers_); -} -inline ::df::plugin::WorldViewersResult* PROTOBUF_NONNULL ActionResult::mutable_world_viewers() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::df::plugin::WorldViewersResult* _msg = _internal_mutable_world_viewers(); - // @@protoc_insertion_point(field_mutable:df.plugin.ActionResult.world_viewers) - return _msg; -} - inline bool ActionResult::has_result() const { return result_case() != RESULT_NOT_SET; } diff --git a/packages/node/src/generated/actions.js b/packages/node/src/generated/actions.js index 441771d..41eeb7f 100644 --- a/packages/node/src/generated/actions.js +++ b/packages/node/src/generated/actions.js @@ -223,7 +223,6 @@ function createBaseAction() { worldQueryEntities: undefined, worldQueryPlayers: undefined, worldQueryEntitiesWithin: undefined, - worldQueryViewers: undefined, }; } export const Action = { @@ -312,9 +311,6 @@ export const Action = { if (message.worldQueryEntitiesWithin !== undefined) { WorldQueryEntitiesWithinAction.encode(message.worldQueryEntitiesWithin, writer.uint32(578).fork()).join(); } - if (message.worldQueryViewers !== undefined) { - WorldQueryViewersAction.encode(message.worldQueryViewers, writer.uint32(586).fork()).join(); - } return writer; }, decode(input, length) { @@ -520,13 +516,6 @@ export const Action = { message.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.decode(reader, reader.uint32()); continue; } - case 73: { - if (tag !== 586) { - break; - } - message.worldQueryViewers = WorldQueryViewersAction.decode(reader, reader.uint32()); - continue; - } } if ((tag & 7) === 4 || tag === 0) { break; @@ -579,9 +568,6 @@ export const Action = { worldQueryEntitiesWithin: isSet(object.worldQueryEntitiesWithin) ? WorldQueryEntitiesWithinAction.fromJSON(object.worldQueryEntitiesWithin) : undefined, - worldQueryViewers: isSet(object.worldQueryViewers) - ? WorldQueryViewersAction.fromJSON(object.worldQueryViewers) - : undefined, }; }, toJSON(message) { @@ -670,9 +656,6 @@ export const Action = { if (message.worldQueryEntitiesWithin !== undefined) { obj.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.toJSON(message.worldQueryEntitiesWithin); } - if (message.worldQueryViewers !== undefined) { - obj.worldQueryViewers = WorldQueryViewersAction.toJSON(message.worldQueryViewers); - } return obj; }, create(base) { @@ -764,9 +747,6 @@ export const Action = { (object.worldQueryEntitiesWithin !== undefined && object.worldQueryEntitiesWithin !== null) ? WorldQueryEntitiesWithinAction.fromPartial(object.worldQueryEntitiesWithin) : undefined; - message.worldQueryViewers = (object.worldQueryViewers !== undefined && object.worldQueryViewers !== null) - ? WorldQueryViewersAction.fromPartial(object.worldQueryViewers) - : undefined; return message; }, }; @@ -2900,78 +2880,6 @@ export const WorldQueryEntitiesWithinAction = { return message; }, }; -function createBaseWorldQueryViewersAction() { - return { world: undefined, position: undefined }; -} -export const WorldQueryViewersAction = { - encode(message, writer = new BinaryWriter()) { - if (message.world !== undefined) { - WorldRef.encode(message.world, writer.uint32(10).fork()).join(); - } - if (message.position !== undefined) { - Vec3.encode(message.position, writer.uint32(18).fork()).join(); - } - return writer; - }, - decode(input, length) { - const reader = input instanceof BinaryReader ? input : new BinaryReader(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseWorldQueryViewersAction(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: { - if (tag !== 10) { - break; - } - message.world = WorldRef.decode(reader, reader.uint32()); - continue; - } - case 2: { - if (tag !== 18) { - break; - } - message.position = Vec3.decode(reader, reader.uint32()); - continue; - } - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skip(tag & 7); - } - return message; - }, - fromJSON(object) { - return { - world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, - position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, - }; - }, - toJSON(message) { - const obj = {}; - if (message.world !== undefined) { - obj.world = WorldRef.toJSON(message.world); - } - if (message.position !== undefined) { - obj.position = Vec3.toJSON(message.position); - } - return obj; - }, - create(base) { - return WorldQueryViewersAction.fromPartial(base ?? {}); - }, - fromPartial(object) { - const message = createBaseWorldQueryViewersAction(); - message.world = (object.world !== undefined && object.world !== null) - ? WorldRef.fromPartial(object.world) - : undefined; - message.position = (object.position !== undefined && object.position !== null) - ? Vec3.fromPartial(object.position) - : undefined; - return message; - }, -}; function createBaseActionStatus() { return { ok: false, error: undefined }; } @@ -3269,95 +3177,6 @@ export const WorldPlayersResult = { return message; }, }; -function createBaseWorldViewersResult() { - return { world: undefined, position: undefined, viewerUuids: [] }; -} -export const WorldViewersResult = { - encode(message, writer = new BinaryWriter()) { - if (message.world !== undefined) { - WorldRef.encode(message.world, writer.uint32(10).fork()).join(); - } - if (message.position !== undefined) { - Vec3.encode(message.position, writer.uint32(18).fork()).join(); - } - for (const v of message.viewerUuids) { - writer.uint32(26).string(v); - } - return writer; - }, - decode(input, length) { - const reader = input instanceof BinaryReader ? input : new BinaryReader(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseWorldViewersResult(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: { - if (tag !== 10) { - break; - } - message.world = WorldRef.decode(reader, reader.uint32()); - continue; - } - case 2: { - if (tag !== 18) { - break; - } - message.position = Vec3.decode(reader, reader.uint32()); - continue; - } - case 3: { - if (tag !== 26) { - break; - } - message.viewerUuids.push(reader.string()); - continue; - } - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skip(tag & 7); - } - return message; - }, - fromJSON(object) { - return { - world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, - position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, - viewerUuids: globalThis.Array.isArray(object?.viewerUuids) - ? object.viewerUuids.map((e) => globalThis.String(e)) - : [], - }; - }, - toJSON(message) { - const obj = {}; - if (message.world !== undefined) { - obj.world = WorldRef.toJSON(message.world); - } - if (message.position !== undefined) { - obj.position = Vec3.toJSON(message.position); - } - if (message.viewerUuids?.length) { - obj.viewerUuids = message.viewerUuids; - } - return obj; - }, - create(base) { - return WorldViewersResult.fromPartial(base ?? {}); - }, - fromPartial(object) { - const message = createBaseWorldViewersResult(); - message.world = (object.world !== undefined && object.world !== null) - ? WorldRef.fromPartial(object.world) - : undefined; - message.position = (object.position !== undefined && object.position !== null) - ? Vec3.fromPartial(object.position) - : undefined; - message.viewerUuids = object.viewerUuids?.map((e) => e) || []; - return message; - }, -}; function createBaseActionResult() { return { correlationId: "", @@ -3365,7 +3184,6 @@ function createBaseActionResult() { worldEntities: undefined, worldPlayers: undefined, worldEntitiesWithin: undefined, - worldViewers: undefined, }; } export const ActionResult = { @@ -3385,9 +3203,6 @@ export const ActionResult = { if (message.worldEntitiesWithin !== undefined) { WorldEntitiesWithinResult.encode(message.worldEntitiesWithin, writer.uint32(98).fork()).join(); } - if (message.worldViewers !== undefined) { - WorldViewersResult.encode(message.worldViewers, writer.uint32(106).fork()).join(); - } return writer; }, decode(input, length) { @@ -3432,13 +3247,6 @@ export const ActionResult = { message.worldEntitiesWithin = WorldEntitiesWithinResult.decode(reader, reader.uint32()); continue; } - case 13: { - if (tag !== 106) { - break; - } - message.worldViewers = WorldViewersResult.decode(reader, reader.uint32()); - continue; - } } if ((tag & 7) === 4 || tag === 0) { break; @@ -3456,7 +3264,6 @@ export const ActionResult = { worldEntitiesWithin: isSet(object.worldEntitiesWithin) ? WorldEntitiesWithinResult.fromJSON(object.worldEntitiesWithin) : undefined, - worldViewers: isSet(object.worldViewers) ? WorldViewersResult.fromJSON(object.worldViewers) : undefined, }; }, toJSON(message) { @@ -3476,9 +3283,6 @@ export const ActionResult = { if (message.worldEntitiesWithin !== undefined) { obj.worldEntitiesWithin = WorldEntitiesWithinResult.toJSON(message.worldEntitiesWithin); } - if (message.worldViewers !== undefined) { - obj.worldViewers = WorldViewersResult.toJSON(message.worldViewers); - } return obj; }, create(base) { @@ -3499,9 +3303,6 @@ export const ActionResult = { message.worldEntitiesWithin = (object.worldEntitiesWithin !== undefined && object.worldEntitiesWithin !== null) ? WorldEntitiesWithinResult.fromPartial(object.worldEntitiesWithin) : undefined; - message.worldViewers = (object.worldViewers !== undefined && object.worldViewers !== null) - ? WorldViewersResult.fromPartial(object.worldViewers) - : undefined; return message; }, }; diff --git a/packages/node/src/generated/actions.ts b/packages/node/src/generated/actions.ts index 1bdb4fb..bf06fbb 100644 --- a/packages/node/src/generated/actions.ts +++ b/packages/node/src/generated/actions.ts @@ -219,7 +219,6 @@ export interface Action { worldQueryEntities?: WorldQueryEntitiesAction | undefined; worldQueryPlayers?: WorldQueryPlayersAction | undefined; worldQueryEntitiesWithin?: WorldQueryEntitiesWithinAction | undefined; - worldQueryViewers?: WorldQueryViewersAction | undefined; } export interface SendChatAction { @@ -415,11 +414,6 @@ export interface WorldQueryEntitiesWithinAction { box: BBox | undefined; } -export interface WorldQueryViewersAction { - world: WorldRef | undefined; - position: Vec3 | undefined; -} - export interface ActionStatus { ok: boolean; error?: string | undefined; @@ -441,19 +435,12 @@ export interface WorldPlayersResult { players: EntityRef[]; } -export interface WorldViewersResult { - world: WorldRef | undefined; - position: Vec3 | undefined; - viewerUuids: string[]; -} - export interface ActionResult { correlationId: string; status?: ActionStatus | undefined; worldEntities?: WorldEntitiesResult | undefined; worldPlayers?: WorldPlayersResult | undefined; worldEntitiesWithin?: WorldEntitiesWithinResult | undefined; - worldViewers?: WorldViewersResult | undefined; } function createBaseActionBatch(): ActionBatch { @@ -546,7 +533,6 @@ function createBaseAction(): Action { worldQueryEntities: undefined, worldQueryPlayers: undefined, worldQueryEntitiesWithin: undefined, - worldQueryViewers: undefined, }; } @@ -636,9 +622,6 @@ export const Action: MessageFns = { if (message.worldQueryEntitiesWithin !== undefined) { WorldQueryEntitiesWithinAction.encode(message.worldQueryEntitiesWithin, writer.uint32(578).fork()).join(); } - if (message.worldQueryViewers !== undefined) { - WorldQueryViewersAction.encode(message.worldQueryViewers, writer.uint32(586).fork()).join(); - } return writer; }, @@ -873,14 +856,6 @@ export const Action: MessageFns = { message.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.decode(reader, reader.uint32()); continue; } - case 73: { - if (tag !== 586) { - break; - } - - message.worldQueryViewers = WorldQueryViewersAction.decode(reader, reader.uint32()); - continue; - } } if ((tag & 7) === 4 || tag === 0) { break; @@ -934,9 +909,6 @@ export const Action: MessageFns = { worldQueryEntitiesWithin: isSet(object.worldQueryEntitiesWithin) ? WorldQueryEntitiesWithinAction.fromJSON(object.worldQueryEntitiesWithin) : undefined, - worldQueryViewers: isSet(object.worldQueryViewers) - ? WorldQueryViewersAction.fromJSON(object.worldQueryViewers) - : undefined, }; }, @@ -1026,9 +998,6 @@ export const Action: MessageFns = { if (message.worldQueryEntitiesWithin !== undefined) { obj.worldQueryEntitiesWithin = WorldQueryEntitiesWithinAction.toJSON(message.worldQueryEntitiesWithin); } - if (message.worldQueryViewers !== undefined) { - obj.worldQueryViewers = WorldQueryViewersAction.toJSON(message.worldQueryViewers); - } return obj; }, @@ -1121,9 +1090,6 @@ export const Action: MessageFns = { (object.worldQueryEntitiesWithin !== undefined && object.worldQueryEntitiesWithin !== null) ? WorldQueryEntitiesWithinAction.fromPartial(object.worldQueryEntitiesWithin) : undefined; - message.worldQueryViewers = (object.worldQueryViewers !== undefined && object.worldQueryViewers !== null) - ? WorldQueryViewersAction.fromPartial(object.worldQueryViewers) - : undefined; return message; }, }; @@ -3491,86 +3457,6 @@ export const WorldQueryEntitiesWithinAction: MessageFns = { - encode(message: WorldQueryViewersAction, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { - if (message.world !== undefined) { - WorldRef.encode(message.world, writer.uint32(10).fork()).join(); - } - if (message.position !== undefined) { - Vec3.encode(message.position, writer.uint32(18).fork()).join(); - } - return writer; - }, - - decode(input: BinaryReader | Uint8Array, length?: number): WorldQueryViewersAction { - const reader = input instanceof BinaryReader ? input : new BinaryReader(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseWorldQueryViewersAction(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: { - if (tag !== 10) { - break; - } - - message.world = WorldRef.decode(reader, reader.uint32()); - continue; - } - case 2: { - if (tag !== 18) { - break; - } - - message.position = Vec3.decode(reader, reader.uint32()); - continue; - } - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skip(tag & 7); - } - return message; - }, - - fromJSON(object: any): WorldQueryViewersAction { - return { - world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, - position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, - }; - }, - - toJSON(message: WorldQueryViewersAction): unknown { - const obj: any = {}; - if (message.world !== undefined) { - obj.world = WorldRef.toJSON(message.world); - } - if (message.position !== undefined) { - obj.position = Vec3.toJSON(message.position); - } - return obj; - }, - - create(base?: DeepPartial): WorldQueryViewersAction { - return WorldQueryViewersAction.fromPartial(base ?? {}); - }, - fromPartial(object: DeepPartial): WorldQueryViewersAction { - const message = createBaseWorldQueryViewersAction(); - message.world = (object.world !== undefined && object.world !== null) - ? WorldRef.fromPartial(object.world) - : undefined; - message.position = (object.position !== undefined && object.position !== null) - ? Vec3.fromPartial(object.position) - : undefined; - return message; - }, -}; - function createBaseActionStatus(): ActionStatus { return { ok: false, error: undefined }; } @@ -3901,104 +3787,6 @@ export const WorldPlayersResult: MessageFns = { }, }; -function createBaseWorldViewersResult(): WorldViewersResult { - return { world: undefined, position: undefined, viewerUuids: [] }; -} - -export const WorldViewersResult: MessageFns = { - encode(message: WorldViewersResult, writer: BinaryWriter = new BinaryWriter()): BinaryWriter { - if (message.world !== undefined) { - WorldRef.encode(message.world, writer.uint32(10).fork()).join(); - } - if (message.position !== undefined) { - Vec3.encode(message.position, writer.uint32(18).fork()).join(); - } - for (const v of message.viewerUuids) { - writer.uint32(26).string(v!); - } - return writer; - }, - - decode(input: BinaryReader | Uint8Array, length?: number): WorldViewersResult { - const reader = input instanceof BinaryReader ? input : new BinaryReader(input); - let end = length === undefined ? reader.len : reader.pos + length; - const message = createBaseWorldViewersResult(); - while (reader.pos < end) { - const tag = reader.uint32(); - switch (tag >>> 3) { - case 1: { - if (tag !== 10) { - break; - } - - message.world = WorldRef.decode(reader, reader.uint32()); - continue; - } - case 2: { - if (tag !== 18) { - break; - } - - message.position = Vec3.decode(reader, reader.uint32()); - continue; - } - case 3: { - if (tag !== 26) { - break; - } - - message.viewerUuids.push(reader.string()); - continue; - } - } - if ((tag & 7) === 4 || tag === 0) { - break; - } - reader.skip(tag & 7); - } - return message; - }, - - fromJSON(object: any): WorldViewersResult { - return { - world: isSet(object.world) ? WorldRef.fromJSON(object.world) : undefined, - position: isSet(object.position) ? Vec3.fromJSON(object.position) : undefined, - viewerUuids: globalThis.Array.isArray(object?.viewerUuids) - ? object.viewerUuids.map((e: any) => globalThis.String(e)) - : [], - }; - }, - - toJSON(message: WorldViewersResult): unknown { - const obj: any = {}; - if (message.world !== undefined) { - obj.world = WorldRef.toJSON(message.world); - } - if (message.position !== undefined) { - obj.position = Vec3.toJSON(message.position); - } - if (message.viewerUuids?.length) { - obj.viewerUuids = message.viewerUuids; - } - return obj; - }, - - create(base?: DeepPartial): WorldViewersResult { - return WorldViewersResult.fromPartial(base ?? {}); - }, - fromPartial(object: DeepPartial): WorldViewersResult { - const message = createBaseWorldViewersResult(); - message.world = (object.world !== undefined && object.world !== null) - ? WorldRef.fromPartial(object.world) - : undefined; - message.position = (object.position !== undefined && object.position !== null) - ? Vec3.fromPartial(object.position) - : undefined; - message.viewerUuids = object.viewerUuids?.map((e) => e) || []; - return message; - }, -}; - function createBaseActionResult(): ActionResult { return { correlationId: "", @@ -4006,7 +3794,6 @@ function createBaseActionResult(): ActionResult { worldEntities: undefined, worldPlayers: undefined, worldEntitiesWithin: undefined, - worldViewers: undefined, }; } @@ -4027,9 +3814,6 @@ export const ActionResult: MessageFns = { if (message.worldEntitiesWithin !== undefined) { WorldEntitiesWithinResult.encode(message.worldEntitiesWithin, writer.uint32(98).fork()).join(); } - if (message.worldViewers !== undefined) { - WorldViewersResult.encode(message.worldViewers, writer.uint32(106).fork()).join(); - } return writer; }, @@ -4080,14 +3864,6 @@ export const ActionResult: MessageFns = { message.worldEntitiesWithin = WorldEntitiesWithinResult.decode(reader, reader.uint32()); continue; } - case 13: { - if (tag !== 106) { - break; - } - - message.worldViewers = WorldViewersResult.decode(reader, reader.uint32()); - continue; - } } if ((tag & 7) === 4 || tag === 0) { break; @@ -4106,7 +3882,6 @@ export const ActionResult: MessageFns = { worldEntitiesWithin: isSet(object.worldEntitiesWithin) ? WorldEntitiesWithinResult.fromJSON(object.worldEntitiesWithin) : undefined, - worldViewers: isSet(object.worldViewers) ? WorldViewersResult.fromJSON(object.worldViewers) : undefined, }; }, @@ -4127,9 +3902,6 @@ export const ActionResult: MessageFns = { if (message.worldEntitiesWithin !== undefined) { obj.worldEntitiesWithin = WorldEntitiesWithinResult.toJSON(message.worldEntitiesWithin); } - if (message.worldViewers !== undefined) { - obj.worldViewers = WorldViewersResult.toJSON(message.worldViewers); - } return obj; }, @@ -4151,9 +3923,6 @@ export const ActionResult: MessageFns = { message.worldEntitiesWithin = (object.worldEntitiesWithin !== undefined && object.worldEntitiesWithin !== null) ? WorldEntitiesWithinResult.fromPartial(object.worldEntitiesWithin) : undefined; - message.worldViewers = (object.worldViewers !== undefined && object.worldViewers !== null) - ? WorldViewersResult.fromPartial(object.worldViewers) - : undefined; return message; }, }; diff --git a/packages/php/src/generated/Df/Plugin/Action.php b/packages/php/src/generated/Df/Plugin/Action.php index 2d66a4f..51c087b 100644 --- a/packages/php/src/generated/Df/Plugin/Action.php +++ b/packages/php/src/generated/Df/Plugin/Action.php @@ -61,7 +61,6 @@ class Action extends \Google\Protobuf\Internal\Message * World queries * @type \Df\Plugin\WorldQueryPlayersAction $world_query_players * @type \Df\Plugin\WorldQueryEntitiesWithinAction $world_query_entities_within - * @type \Df\Plugin\WorldQueryViewersAction $world_query_viewers * } */ public function __construct($data = NULL) { @@ -858,33 +857,6 @@ public function setWorldQueryEntitiesWithin($var) return $this; } - /** - * Generated from protobuf field .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; - * @return \Df\Plugin\WorldQueryViewersAction|null - */ - public function getWorldQueryViewers() - { - return $this->readOneof(73); - } - - public function hasWorldQueryViewers() - { - return $this->hasOneof(73); - } - - /** - * Generated from protobuf field .df.plugin.WorldQueryViewersAction world_query_viewers = 73 [json_name = "worldQueryViewers"]; - * @param \Df\Plugin\WorldQueryViewersAction $var - * @return $this - */ - public function setWorldQueryViewers($var) - { - GPBUtil::checkMessage($var, \Df\Plugin\WorldQueryViewersAction::class); - $this->writeOneof(73, $var); - - return $this; - } - /** * @return string */ diff --git a/packages/php/src/generated/Df/Plugin/ActionResult.php b/packages/php/src/generated/Df/Plugin/ActionResult.php index 3cf5678..be4c881 100644 --- a/packages/php/src/generated/Df/Plugin/ActionResult.php +++ b/packages/php/src/generated/Df/Plugin/ActionResult.php @@ -35,7 +35,6 @@ class ActionResult extends \Google\Protobuf\Internal\Message * @type \Df\Plugin\WorldEntitiesResult $world_entities * @type \Df\Plugin\WorldPlayersResult $world_players * @type \Df\Plugin\WorldEntitiesWithinResult $world_entities_within - * @type \Df\Plugin\WorldViewersResult $world_viewers * } */ public function __construct($data = NULL) { @@ -178,33 +177,6 @@ public function setWorldEntitiesWithin($var) return $this; } - /** - * Generated from protobuf field .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; - * @return \Df\Plugin\WorldViewersResult|null - */ - public function getWorldViewers() - { - return $this->readOneof(13); - } - - public function hasWorldViewers() - { - return $this->hasOneof(13); - } - - /** - * Generated from protobuf field .df.plugin.WorldViewersResult world_viewers = 13 [json_name = "worldViewers"]; - * @param \Df\Plugin\WorldViewersResult $var - * @return $this - */ - public function setWorldViewers($var) - { - GPBUtil::checkMessage($var, \Df\Plugin\WorldViewersResult::class); - $this->writeOneof(13, $var); - - return $this; - } - /** * @return string */ diff --git a/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php b/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php index ff285da..c0dedea 100644 --- a/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php +++ b/packages/php/src/generated/Df/Plugin/GPBMetadata/Actions.php @@ -17,7 +17,7 @@ public static function initOnce() { } \Df\Plugin\GPBMetadata\Common::initOnce(); $pool->internalAddGeneratedFile( - "\x0A\x8C:\x0A\x0Dactions.proto\x12\x09df.plugin\":\x0A\x0BActionBatch\x12+\x0A\x07actions\x18\x01 \x03(\x0B2\x11.df.plugin.ActionR\x07actions\"\xAF\x10\x0A\x06Action\x12*\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09H\x01R\x0DcorrelationId\x88\x01\x01\x128\x0A\x09send_chat\x18\x0A \x01(\x0B2\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x127\x0A\x08teleport\x18\x0B \x01(\x0B2\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\x0A\x04kick\x18\x0C \x01(\x0B2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\x0A\x0Dset_game_mode\x18\x0D \x01(\x0B2\x1C.df.plugin.SetGameModeActionH\x00R\x0BsetGameMode\x128\x0A\x09give_item\x18\x0E \x01(\x0B2\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\x0A\x0Fclear_inventory\x18\x0F \x01(\x0B2\x1F.df.plugin.ClearInventoryActionH\x00R\x0EclearInventory\x12B\x0A\x0Dset_held_item\x18\x10 \x01(\x0B2\x1C.df.plugin.SetHeldItemActionH\x00R\x0BsetHeldItem\x12;\x0A\x0Aset_health\x18\x14 \x01(\x0B2\x1A.df.plugin.SetHealthActionH\x00R\x09setHealth\x125\x0A\x08set_food\x18\x15 \x01(\x0B2\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\x0A\x0Eset_experience\x18\x16 \x01(\x0B2\x1E.df.plugin.SetExperienceActionH\x00R\x0DsetExperience\x12A\x0A\x0Cset_velocity\x18\x17 \x01(\x0B2\x1C.df.plugin.SetVelocityActionH\x00R\x0BsetVelocity\x12;\x0A\x0Aadd_effect\x18\x1E \x01(\x0B2\x1A.df.plugin.AddEffectActionH\x00R\x09addEffect\x12D\x0A\x0Dremove_effect\x18\x1F \x01(\x0B2\x1D.df.plugin.RemoveEffectActionH\x00R\x0CremoveEffect\x12;\x0A\x0Asend_title\x18( \x01(\x0B2\x1A.df.plugin.SendTitleActionH\x00R\x09sendTitle\x12;\x0A\x0Asend_popup\x18) \x01(\x0B2\x1A.df.plugin.SendPopupActionH\x00R\x09sendPopup\x125\x0A\x08send_tip\x18* \x01(\x0B2\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\x0A\x0Aplay_sound\x18+ \x01(\x0B2\x1A.df.plugin.PlaySoundActionH\x00R\x09playSound\x12J\x0A\x0Fexecute_command\x182 \x01(\x0B2\x1F.df.plugin.ExecuteCommandActionH\x00R\x0EexecuteCommand\x12h\x0A\x1Bworld_set_default_game_mode\x18< \x01(\x0B2(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\x0A\x14world_set_difficulty\x18= \x01(\x0B2#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\x0A\x14world_set_tick_range\x18> \x01(\x0B2\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\x0A\x0Fworld_set_block\x18? \x01(\x0B2\x1E.df.plugin.WorldSetBlockActionH\x00R\x0DworldSetBlock\x12K\x0A\x10world_play_sound\x18@ \x01(\x0B2\x1F.df.plugin.WorldPlaySoundActionH\x00R\x0EworldPlaySound\x12Q\x0A\x12world_add_particle\x18A \x01(\x0B2!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\x0A\x14world_query_entities\x18F \x01(\x0B2#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\x0A\x13world_query_players\x18G \x01(\x0B2\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\x0A\x1Bworld_query_entities_within\x18H \x01(\x0B2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\x0A\x13world_query_viewers\x18I \x01(\x0B2\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\x0A\x04kindB\x11\x0A\x0F_correlation_id\"K\x0A\x0ESendChatAction\x12\x1F\x0A\x0Btarget_uuid\x18\x01 \x01(\x09R\x0AtargetUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\x8B\x01\x0A\x0ETeleportAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12+\x0A\x08rotation\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08rotation\"E\x0A\x0AKickAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06reason\x18\x02 \x01(\x09R\x06reason\"f\x0A\x11SetGameModeAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"[\x0A\x0EGiveItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12(\x0A\x04item\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackR\x04item\"7\x0A\x14ClearInventoryAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\"\xAD\x01\x0A\x11SetHeldItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12-\x0A\x04main\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\x0A\x07offhand\x18\x03 \x01(\x0B2\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01B\x07\x0A\x05_mainB\x0A\x0A\x08_offhand\"}\x0A\x0FSetHealthAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06health\x18\x02 \x01(\x01R\x06health\x12\"\x0A\x0Amax_health\x18\x03 \x01(\x01H\x00R\x09maxHealth\x88\x01\x01B\x0D\x0A\x0B_max_health\"D\x0A\x0DSetFoodAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x12\x0A\x04food\x18\x02 \x01(\x05R\x04food\"\xB1\x01\x0A\x13SetExperienceAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x19\x0A\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1F\x0A\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1B\x0A\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\x08\x0A\x06_levelB\x0B\x0A\x09_progressB\x09\x0A\x07_amount\"a\x0A\x11SetVelocityAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08velocity\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08velocity\"\xC8\x01\x0A\x0FAddEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\x12\x14\x0A\x05level\x18\x03 \x01(\x05R\x05level\x12\x1F\x0A\x0Bduration_ms\x18\x04 \x01(\x03R\x0AdurationMs\x12%\x0A\x0Eshow_particles\x18\x05 \x01(\x08R\x0DshowParticles\"m\x0A\x12RemoveEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\"\x93\x02\x0A\x0FSendTitleAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x14\x0A\x05title\x18\x02 \x01(\x09R\x05title\x12\x1F\x0A\x08subtitle\x18\x03 \x01(\x09H\x00R\x08subtitle\x88\x01\x01\x12!\x0A\x0Afade_in_ms\x18\x04 \x01(\x03H\x01R\x08fadeInMs\x88\x01\x01\x12\$\x0A\x0Bduration_ms\x18\x05 \x01(\x03H\x02R\x0AdurationMs\x88\x01\x01\x12#\x0A\x0Bfade_out_ms\x18\x06 \x01(\x03H\x03R\x09fadeOutMs\x88\x01\x01B\x0B\x0A\x09_subtitleB\x0D\x0A\x0B_fade_in_msB\x0E\x0A\x0C_duration_msB\x0E\x0A\x0C_fade_out_ms\"L\x0A\x0FSendPopupAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"J\x0A\x0DSendTipAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\xE6\x01\x0A\x0FPlaySoundAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x120\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1B\x0A\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\x0A\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\x0B\x0A\x09_positionB\x09\x0A\x07_volumeB\x08\x0A\x06_pitch\"Q\x0A\x14ExecuteCommandAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07command\x18\x02 \x01(\x09R\x07command\"|\x0A\x1DWorldSetDefaultGameModeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"|\x0A\x18WorldSetDifficultyAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x125\x0A\x0Adifficulty\x18\x02 \x01(\x0E2\x15.df.plugin.DifficultyR\x0Adifficulty\"c\x0A\x17WorldSetTickRangeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12\x1D\x0A\x0Atick_range\x18\x02 \x01(\x05R\x09tickRange\"\xAD\x01\x0A\x13WorldSetBlockAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12/\x0A\x08position\x18\x02 \x01(\x0B2\x13.df.plugin.BlockPosR\x08position\x120\x0A\x05block\x18\x03 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01B\x08\x0A\x06_block\"\x96\x01\x0A\x14WorldPlaySoundAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x12+\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\"\x83\x02\x0A\x16WorldAddParticleAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x123\x0A\x08particle\x18\x03 \x01(\x0E2\x17.df.plugin.ParticleTypeR\x08particle\x120\x0A\x05block\x18\x04 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01\x12\x17\x0A\x04face\x18\x05 \x01(\x05H\x01R\x04face\x88\x01\x01B\x08\x0A\x06_blockB\x07\x0A\x05_face\"E\x0A\x18WorldQueryEntitiesAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"D\x0A\x17WorldQueryPlayersAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"n\x0A\x1EWorldQueryEntitiesWithinAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\"q\x0A\x17WorldQueryViewersAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\"C\x0A\x0CActionStatus\x12\x0E\x0A\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\x0A\x05error\x18\x02 \x01(\x09H\x00R\x05error\x88\x01\x01B\x08\x0A\x06_error\"r\x0A\x13WorldEntitiesResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x08entities\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"\x9B\x01\x0A\x19WorldEntitiesWithinResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\x120\x0A\x08entities\x18\x03 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"o\x0A\x12WorldPlayersResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12.\x0A\x07players\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x07players\"\x8F\x01\x0A\x12WorldViewersResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12!\x0A\x0Cviewer_uuids\x18\x03 \x03(\x09R\x0BviewerUuids\"\xB1\x03\x0A\x0CActionResult\x12%\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09R\x0DcorrelationId\x124\x0A\x06status\x18\x02 \x01(\x0B2\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\x0A\x0Eworld_entities\x18\x0A \x01(\x0B2\x1E.df.plugin.WorldEntitiesResultH\x00R\x0DworldEntities\x12D\x0A\x0Dworld_players\x18\x0B \x01(\x0B2\x1D.df.plugin.WorldPlayersResultH\x00R\x0CworldPlayers\x12Z\x0A\x15world_entities_within\x18\x0C \x01(\x0B2\$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12D\x0A\x0Dworld_viewers\x18\x0D \x01(\x0B2\x1D.df.plugin.WorldViewersResultH\x00R\x0CworldViewersB\x08\x0A\x06resultB\x09\x0A\x07_status*\xEB\x03\x0A\x0CParticleType\x12\x1D\x0A\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1B\x0A\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1E\x0A\x1APARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1A\x0A\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\x0A\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\x0A\x0FPARTICLE_SPLASH\x10\x05\x12\x13\x0A\x0FPARTICLE_EFFECT\x10\x06\x12\x19\x0A\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\x0A\x0EPARTICLE_FLAME\x10\x08\x12\x11\x0A\x0DPARTICLE_DUST\x10\x09\x12\x1E\x0A\x1APARTICLE_BLOCK_FORCE_FIELD\x10\x0A\x12\x16\x0A\x12PARTICLE_BONE_MEAL\x10\x0B\x12\x16\x0A\x12PARTICLE_EVAPORATE\x10\x0C\x12\x17\x0A\x13PARTICLE_WATER_DRIP\x10\x0D\x12\x16\x0A\x12PARTICLE_LAVA_DRIP\x10\x0E\x12\x11\x0A\x0DPARTICLE_LAVA\x10\x0F\x12\x17\x0A\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\x0A\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\x0A\x14PARTICLE_PUNCH_BLOCK\x10\x12B\x8B\x01\x0A\x0Dcom.df.pluginB\x0CActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" + "\x0A\xEB6\x0A\x0Dactions.proto\x12\x09df.plugin\":\x0A\x0BActionBatch\x12+\x0A\x07actions\x18\x01 \x03(\x0B2\x11.df.plugin.ActionR\x07actions\"\xD9\x0F\x0A\x06Action\x12*\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09H\x01R\x0DcorrelationId\x88\x01\x01\x128\x0A\x09send_chat\x18\x0A \x01(\x0B2\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x127\x0A\x08teleport\x18\x0B \x01(\x0B2\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\x0A\x04kick\x18\x0C \x01(\x0B2\x15.df.plugin.KickActionH\x00R\x04kick\x12B\x0A\x0Dset_game_mode\x18\x0D \x01(\x0B2\x1C.df.plugin.SetGameModeActionH\x00R\x0BsetGameMode\x128\x0A\x09give_item\x18\x0E \x01(\x0B2\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\x0A\x0Fclear_inventory\x18\x0F \x01(\x0B2\x1F.df.plugin.ClearInventoryActionH\x00R\x0EclearInventory\x12B\x0A\x0Dset_held_item\x18\x10 \x01(\x0B2\x1C.df.plugin.SetHeldItemActionH\x00R\x0BsetHeldItem\x12;\x0A\x0Aset_health\x18\x14 \x01(\x0B2\x1A.df.plugin.SetHealthActionH\x00R\x09setHealth\x125\x0A\x08set_food\x18\x15 \x01(\x0B2\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\x0A\x0Eset_experience\x18\x16 \x01(\x0B2\x1E.df.plugin.SetExperienceActionH\x00R\x0DsetExperience\x12A\x0A\x0Cset_velocity\x18\x17 \x01(\x0B2\x1C.df.plugin.SetVelocityActionH\x00R\x0BsetVelocity\x12;\x0A\x0Aadd_effect\x18\x1E \x01(\x0B2\x1A.df.plugin.AddEffectActionH\x00R\x09addEffect\x12D\x0A\x0Dremove_effect\x18\x1F \x01(\x0B2\x1D.df.plugin.RemoveEffectActionH\x00R\x0CremoveEffect\x12;\x0A\x0Asend_title\x18( \x01(\x0B2\x1A.df.plugin.SendTitleActionH\x00R\x09sendTitle\x12;\x0A\x0Asend_popup\x18) \x01(\x0B2\x1A.df.plugin.SendPopupActionH\x00R\x09sendPopup\x125\x0A\x08send_tip\x18* \x01(\x0B2\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\x0A\x0Aplay_sound\x18+ \x01(\x0B2\x1A.df.plugin.PlaySoundActionH\x00R\x09playSound\x12J\x0A\x0Fexecute_command\x182 \x01(\x0B2\x1F.df.plugin.ExecuteCommandActionH\x00R\x0EexecuteCommand\x12h\x0A\x1Bworld_set_default_game_mode\x18< \x01(\x0B2(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\x0A\x14world_set_difficulty\x18= \x01(\x0B2#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\x0A\x14world_set_tick_range\x18> \x01(\x0B2\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\x0A\x0Fworld_set_block\x18? \x01(\x0B2\x1E.df.plugin.WorldSetBlockActionH\x00R\x0DworldSetBlock\x12K\x0A\x10world_play_sound\x18@ \x01(\x0B2\x1F.df.plugin.WorldPlaySoundActionH\x00R\x0EworldPlaySound\x12Q\x0A\x12world_add_particle\x18A \x01(\x0B2!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\x0A\x14world_query_entities\x18F \x01(\x0B2#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\x0A\x13world_query_players\x18G \x01(\x0B2\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\x0A\x1Bworld_query_entities_within\x18H \x01(\x0B2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithinB\x06\x0A\x04kindB\x11\x0A\x0F_correlation_id\"K\x0A\x0ESendChatAction\x12\x1F\x0A\x0Btarget_uuid\x18\x01 \x01(\x09R\x0AtargetUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\x8B\x01\x0A\x0ETeleportAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x12+\x0A\x08rotation\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08rotation\"E\x0A\x0AKickAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06reason\x18\x02 \x01(\x09R\x06reason\"f\x0A\x11SetGameModeAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"[\x0A\x0EGiveItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12(\x0A\x04item\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackR\x04item\"7\x0A\x14ClearInventoryAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\"\xAD\x01\x0A\x11SetHeldItemAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12-\x0A\x04main\x18\x02 \x01(\x0B2\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x123\x0A\x07offhand\x18\x03 \x01(\x0B2\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01B\x07\x0A\x05_mainB\x0A\x0A\x08_offhand\"}\x0A\x0FSetHealthAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x16\x0A\x06health\x18\x02 \x01(\x01R\x06health\x12\"\x0A\x0Amax_health\x18\x03 \x01(\x01H\x00R\x09maxHealth\x88\x01\x01B\x0D\x0A\x0B_max_health\"D\x0A\x0DSetFoodAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x12\x0A\x04food\x18\x02 \x01(\x05R\x04food\"\xB1\x01\x0A\x13SetExperienceAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x19\x0A\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1F\x0A\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1B\x0A\x06amount\x18\x04 \x01(\x05H\x02R\x06amount\x88\x01\x01B\x08\x0A\x06_levelB\x0B\x0A\x09_progressB\x09\x0A\x07_amount\"a\x0A\x11SetVelocityAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12+\x0A\x08velocity\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08velocity\"\xC8\x01\x0A\x0FAddEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\x12\x14\x0A\x05level\x18\x03 \x01(\x05R\x05level\x12\x1F\x0A\x0Bduration_ms\x18\x04 \x01(\x03R\x0AdurationMs\x12%\x0A\x0Eshow_particles\x18\x05 \x01(\x08R\x0DshowParticles\"m\x0A\x12RemoveEffectAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x126\x0A\x0Beffect_type\x18\x02 \x01(\x0E2\x15.df.plugin.EffectTypeR\x0AeffectType\"\x93\x02\x0A\x0FSendTitleAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x14\x0A\x05title\x18\x02 \x01(\x09R\x05title\x12\x1F\x0A\x08subtitle\x18\x03 \x01(\x09H\x00R\x08subtitle\x88\x01\x01\x12!\x0A\x0Afade_in_ms\x18\x04 \x01(\x03H\x01R\x08fadeInMs\x88\x01\x01\x12\$\x0A\x0Bduration_ms\x18\x05 \x01(\x03H\x02R\x0AdurationMs\x88\x01\x01\x12#\x0A\x0Bfade_out_ms\x18\x06 \x01(\x03H\x03R\x09fadeOutMs\x88\x01\x01B\x0B\x0A\x09_subtitleB\x0D\x0A\x0B_fade_in_msB\x0E\x0A\x0C_duration_msB\x0E\x0A\x0C_fade_out_ms\"L\x0A\x0FSendPopupAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"J\x0A\x0DSendTipAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07message\x18\x02 \x01(\x09R\x07message\"\xE6\x01\x0A\x0FPlaySoundAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x120\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1B\x0A\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\x0A\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01B\x0B\x0A\x09_positionB\x09\x0A\x07_volumeB\x08\x0A\x06_pitch\"Q\x0A\x14ExecuteCommandAction\x12\x1F\x0A\x0Bplayer_uuid\x18\x01 \x01(\x09R\x0AplayerUuid\x12\x18\x0A\x07command\x18\x02 \x01(\x09R\x07command\"|\x0A\x1DWorldSetDefaultGameModeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x09game_mode\x18\x02 \x01(\x0E2\x13.df.plugin.GameModeR\x08gameMode\"|\x0A\x18WorldSetDifficultyAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x125\x0A\x0Adifficulty\x18\x02 \x01(\x0E2\x15.df.plugin.DifficultyR\x0Adifficulty\"c\x0A\x17WorldSetTickRangeAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12\x1D\x0A\x0Atick_range\x18\x02 \x01(\x05R\x09tickRange\"\xAD\x01\x0A\x13WorldSetBlockAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12/\x0A\x08position\x18\x02 \x01(\x0B2\x13.df.plugin.BlockPosR\x08position\x120\x0A\x05block\x18\x03 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01B\x08\x0A\x06_block\"\x96\x01\x0A\x14WorldPlaySoundAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12&\x0A\x05sound\x18\x02 \x01(\x0E2\x10.df.plugin.SoundR\x05sound\x12+\x0A\x08position\x18\x03 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\"\x83\x02\x0A\x16WorldAddParticleAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12+\x0A\x08position\x18\x02 \x01(\x0B2\x0F.df.plugin.Vec3R\x08position\x123\x0A\x08particle\x18\x03 \x01(\x0E2\x17.df.plugin.ParticleTypeR\x08particle\x120\x0A\x05block\x18\x04 \x01(\x0B2\x15.df.plugin.BlockStateH\x00R\x05block\x88\x01\x01\x12\x17\x0A\x04face\x18\x05 \x01(\x05H\x01R\x04face\x88\x01\x01B\x08\x0A\x06_blockB\x07\x0A\x05_face\"E\x0A\x18WorldQueryEntitiesAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"D\x0A\x17WorldQueryPlayersAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\"n\x0A\x1EWorldQueryEntitiesWithinAction\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\"C\x0A\x0CActionStatus\x12\x0E\x0A\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\x0A\x05error\x18\x02 \x01(\x09H\x00R\x05error\x88\x01\x01B\x08\x0A\x06_error\"r\x0A\x13WorldEntitiesResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x120\x0A\x08entities\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"\x9B\x01\x0A\x19WorldEntitiesWithinResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12!\x0A\x03box\x18\x02 \x01(\x0B2\x0F.df.plugin.BBoxR\x03box\x120\x0A\x08entities\x18\x03 \x03(\x0B2\x14.df.plugin.EntityRefR\x08entities\"o\x0A\x12WorldPlayersResult\x12)\x0A\x05world\x18\x01 \x01(\x0B2\x13.df.plugin.WorldRefR\x05world\x12.\x0A\x07players\x18\x02 \x03(\x0B2\x14.df.plugin.EntityRefR\x07players\"\xEB\x02\x0A\x0CActionResult\x12%\x0A\x0Ecorrelation_id\x18\x01 \x01(\x09R\x0DcorrelationId\x124\x0A\x06status\x18\x02 \x01(\x0B2\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\x0A\x0Eworld_entities\x18\x0A \x01(\x0B2\x1E.df.plugin.WorldEntitiesResultH\x00R\x0DworldEntities\x12D\x0A\x0Dworld_players\x18\x0B \x01(\x0B2\x1D.df.plugin.WorldPlayersResultH\x00R\x0CworldPlayers\x12Z\x0A\x15world_entities_within\x18\x0C \x01(\x0B2\$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithinB\x08\x0A\x06resultB\x09\x0A\x07_status*\xEB\x03\x0A\x0CParticleType\x12\x1D\x0A\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1B\x0A\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1E\x0A\x1APARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1A\x0A\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\x0A\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\x0A\x0FPARTICLE_SPLASH\x10\x05\x12\x13\x0A\x0FPARTICLE_EFFECT\x10\x06\x12\x19\x0A\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\x0A\x0EPARTICLE_FLAME\x10\x08\x12\x11\x0A\x0DPARTICLE_DUST\x10\x09\x12\x1E\x0A\x1APARTICLE_BLOCK_FORCE_FIELD\x10\x0A\x12\x16\x0A\x12PARTICLE_BONE_MEAL\x10\x0B\x12\x16\x0A\x12PARTICLE_EVAPORATE\x10\x0C\x12\x17\x0A\x13PARTICLE_WATER_DRIP\x10\x0D\x12\x16\x0A\x12PARTICLE_LAVA_DRIP\x10\x0E\x12\x11\x0A\x0DPARTICLE_LAVA\x10\x0F\x12\x17\x0A\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\x0A\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\x0A\x14PARTICLE_PUNCH_BLOCK\x10\x12B\x8B\x01\x0A\x0Dcom.df.pluginB\x0CActionsProtoP\x01Z'github.com/secmc/plugin/proto/generated\xA2\x02\x03DPX\xAA\x02\x09Df.Plugin\xCA\x02\x09Df\\Plugin\xE2\x02\x15Df\\Plugin\\GPBMetadata\xEA\x02\x0ADf::Pluginb\x06proto3" , true); static::$is_initialized = true; diff --git a/packages/php/src/generated/Df/Plugin/WorldViewersResult.php b/packages/php/src/generated/Df/Plugin/WorldViewersResult.php index c7cf045..7287ab3 100644 --- a/packages/php/src/generated/Df/Plugin/WorldViewersResult.php +++ b/packages/php/src/generated/Df/Plugin/WorldViewersResult.php @@ -23,9 +23,9 @@ class WorldViewersResult extends \Google\Protobuf\Internal\Message */ protected $position = null; /** - * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; + * Generated from protobuf field repeated .df.plugin.EntityRef viewers = 3 [json_name = "viewers"]; */ - private $viewer_uuids; + private $viewers; /** * Constructor. @@ -35,7 +35,7 @@ class WorldViewersResult extends \Google\Protobuf\Internal\Message * * @type \Df\Plugin\WorldRef $world * @type \Df\Plugin\Vec3 $position - * @type string[] $viewer_uuids + * @type \Df\Plugin\EntityRef[] $viewers * } */ public function __construct($data = NULL) { @@ -108,23 +108,23 @@ public function setPosition($var) } /** - * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; - * @return RepeatedField + * Generated from protobuf field repeated .df.plugin.EntityRef viewers = 3 [json_name = "viewers"]; + * @return RepeatedField<\Df\Plugin\EntityRef> */ - public function getViewerUuids() + public function getViewers() { - return $this->viewer_uuids; + return $this->viewers; } /** - * Generated from protobuf field repeated string viewer_uuids = 3 [json_name = "viewerUuids"]; - * @param string[] $var + * Generated from protobuf field repeated .df.plugin.EntityRef viewers = 3 [json_name = "viewers"]; + * @param \Df\Plugin\EntityRef[] $var * @return $this */ - public function setViewerUuids($var) + public function setViewers($var) { - $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::STRING); - $this->viewer_uuids = $arr; + $arr = GPBUtil::checkRepeatedField($var, \Google\Protobuf\Internal\GPBType::MESSAGE, \Df\Plugin\EntityRef::class); + $this->viewers = $arr; return $this; } diff --git a/packages/python/src/generated/actions_pb2.py b/packages/python/src/generated/actions_pb2.py index e774bc8..99f81e6 100644 --- a/packages/python/src/generated/actions_pb2.py +++ b/packages/python/src/generated/actions_pb2.py @@ -25,7 +25,7 @@ import common_pb2 as common__pb2 -DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ractions.proto\x12\tdf.plugin\x1a\x0c\x63ommon.proto\":\n\x0b\x41\x63tionBatch\x12+\n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x11.df.plugin.ActionR\x07\x61\x63tions\"\xaf\x10\n\x06\x41\x63tion\x12*\n\x0e\x63orrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x12\x38\n\tsend_chat\x18\n \x01(\x0b\x32\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x12\x37\n\x08teleport\x18\x0b \x01(\x0b\x32\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\n\x04kick\x18\x0c \x01(\x0b\x32\x15.df.plugin.KickActionH\x00R\x04kick\x12\x42\n\rset_game_mode\x18\r \x01(\x0b\x32\x1c.df.plugin.SetGameModeActionH\x00R\x0bsetGameMode\x12\x38\n\tgive_item\x18\x0e \x01(\x0b\x32\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\n\x0f\x63lear_inventory\x18\x0f \x01(\x0b\x32\x1f.df.plugin.ClearInventoryActionH\x00R\x0e\x63learInventory\x12\x42\n\rset_held_item\x18\x10 \x01(\x0b\x32\x1c.df.plugin.SetHeldItemActionH\x00R\x0bsetHeldItem\x12;\n\nset_health\x18\x14 \x01(\x0b\x32\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x12\x35\n\x08set_food\x18\x15 \x01(\x0b\x32\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\n\x0eset_experience\x18\x16 \x01(\x0b\x32\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12\x41\n\x0cset_velocity\x18\x17 \x01(\x0b\x32\x1c.df.plugin.SetVelocityActionH\x00R\x0bsetVelocity\x12;\n\nadd_effect\x18\x1e \x01(\x0b\x32\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12\x44\n\rremove_effect\x18\x1f \x01(\x0b\x32\x1d.df.plugin.RemoveEffectActionH\x00R\x0cremoveEffect\x12;\n\nsend_title\x18( \x01(\x0b\x32\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n\nsend_popup\x18) \x01(\x0b\x32\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x12\x35\n\x08send_tip\x18* \x01(\x0b\x32\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\n\nplay_sound\x18+ \x01(\x0b\x32\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n\x0f\x65xecute_command\x18\x32 \x01(\x0b\x32\x1f.df.plugin.ExecuteCommandActionH\x00R\x0e\x65xecuteCommand\x12h\n\x1bworld_set_default_game_mode\x18< \x01(\x0b\x32(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\n\x14world_set_difficulty\x18= \x01(\x0b\x32#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\n\x14world_set_tick_range\x18> \x01(\x0b\x32\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\n\x0fworld_set_block\x18? \x01(\x0b\x32\x1e.df.plugin.WorldSetBlockActionH\x00R\rworldSetBlock\x12K\n\x10world_play_sound\x18@ \x01(\x0b\x32\x1f.df.plugin.WorldPlaySoundActionH\x00R\x0eworldPlaySound\x12Q\n\x12world_add_particle\x18\x41 \x01(\x0b\x32!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\n\x14world_query_entities\x18\x46 \x01(\x0b\x32#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\n\x13world_query_players\x18G \x01(\x0b\x32\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\n\x1bworld_query_entities_within\x18H \x01(\x0b\x32).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\n\x13world_query_viewers\x18I \x01(\x0b\x32\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\n\x04kindB\x11\n\x0f_correlation_id\"K\n\x0eSendChatAction\x12\x1f\n\x0btarget_uuid\x18\x01 \x01(\tR\ntargetUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\x8b\x01\n\x0eTeleportAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12+\n\x08rotation\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08rotation\"E\n\nKickAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reason\"f\n\x11SetGameModeAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"[\n\x0eGiveItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12(\n\x04item\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackR\x04item\"7\n\x14\x43learInventoryAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\"\xad\x01\n\x11SetHeldItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12-\n\x04main\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x12\x33\n\x07offhand\x18\x03 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01\x42\x07\n\x05_mainB\n\n\x08_offhand\"}\n\x0fSetHealthAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n\nmax_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01\x42\r\n\x0b_max_health\"D\n\rSetFoodAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x12\n\x04\x66ood\x18\x02 \x01(\x05R\x04\x66ood\"\xb1\x01\n\x13SetExperienceAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x19\n\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1b\n\x06\x61mount\x18\x04 \x01(\x05H\x02R\x06\x61mount\x88\x01\x01\x42\x08\n\x06_levelB\x0b\n\t_progressB\t\n\x07_amount\"a\n\x11SetVelocityAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08velocity\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08velocity\"\xc8\x01\n\x0f\x41\x64\x64\x45\x66\x66\x65\x63tAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\x12\x14\n\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n\x0b\x64uration_ms\x18\x04 \x01(\x03R\ndurationMs\x12%\n\x0eshow_particles\x18\x05 \x01(\x08R\rshowParticles\"m\n\x12RemoveEffectAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\"\x93\x02\n\x0fSendTitleAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n\x08subtitle\x18\x03 \x01(\tH\x00R\x08subtitle\x88\x01\x01\x12!\n\nfade_in_ms\x18\x04 \x01(\x03H\x01R\x08\x66\x61\x64\x65InMs\x88\x01\x01\x12$\n\x0b\x64uration_ms\x18\x05 \x01(\x03H\x02R\ndurationMs\x88\x01\x01\x12#\n\x0b\x66\x61\x64\x65_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01\x42\x0b\n\t_subtitleB\r\n\x0b_fade_in_msB\x0e\n\x0c_duration_msB\x0e\n\x0c_fade_out_ms\"L\n\x0fSendPopupAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"J\n\rSendTipAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xe6\x01\n\x0fPlaySoundAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12\x30\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1b\n\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01\x42\x0b\n\t_positionB\t\n\x07_volumeB\x08\n\x06_pitch\"Q\n\x14\x45xecuteCommandAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07\x63ommand\x18\x02 \x01(\tR\x07\x63ommand\"|\n\x1dWorldSetDefaultGameModeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"|\n\x18WorldSetDifficultyAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x35\n\ndifficulty\x18\x02 \x01(\x0e\x32\x15.df.plugin.DifficultyR\ndifficulty\"c\n\x17WorldSetTickRangeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x1d\n\ntick_range\x18\x02 \x01(\x05R\ttickRange\"\xad\x01\n\x13WorldSetBlockAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12/\n\x08position\x18\x02 \x01(\x0b\x32\x13.df.plugin.BlockPosR\x08position\x12\x30\n\x05\x62lock\x18\x03 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x42\x08\n\x06_block\"\x96\x01\n\x14WorldPlaySoundAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12+\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\"\x83\x02\n\x16WorldAddParticleAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12\x33\n\x08particle\x18\x03 \x01(\x0e\x32\x17.df.plugin.ParticleTypeR\x08particle\x12\x30\n\x05\x62lock\x18\x04 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x12\x17\n\x04\x66\x61\x63\x65\x18\x05 \x01(\x05H\x01R\x04\x66\x61\x63\x65\x88\x01\x01\x42\x08\n\x06_blockB\x07\n\x05_face\"E\n\x18WorldQueryEntitiesAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"D\n\x17WorldQueryPlayersAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"n\n\x1eWorldQueryEntitiesWithinAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\"q\n\x17WorldQueryViewersAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\"C\n\x0c\x41\x63tionStatus\x12\x0e\n\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\n\x05\x65rror\x18\x02 \x01(\tH\x00R\x05\x65rror\x88\x01\x01\x42\x08\n\x06_error\"r\n\x13WorldEntitiesResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\x08\x65ntities\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"\x9b\x01\n\x19WorldEntitiesWithinResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\x12\x30\n\x08\x65ntities\x18\x03 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"o\n\x12WorldPlayersResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12.\n\x07players\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x07players\"\x8f\x01\n\x12WorldViewersResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12!\n\x0cviewer_uuids\x18\x03 \x03(\tR\x0bviewerUuids\"\xb1\x03\n\x0c\x41\x63tionResult\x12%\n\x0e\x63orrelation_id\x18\x01 \x01(\tR\rcorrelationId\x12\x34\n\x06status\x18\x02 \x01(\x0b\x32\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\n\x0eworld_entities\x18\n \x01(\x0b\x32\x1e.df.plugin.WorldEntitiesResultH\x00R\rworldEntities\x12\x44\n\rworld_players\x18\x0b \x01(\x0b\x32\x1d.df.plugin.WorldPlayersResultH\x00R\x0cworldPlayers\x12Z\n\x15world_entities_within\x18\x0c \x01(\x0b\x32$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12\x44\n\rworld_viewers\x18\r \x01(\x0b\x32\x1d.df.plugin.WorldViewersResultH\x00R\x0cworldViewersB\x08\n\x06resultB\t\n\x07_status*\xeb\x03\n\x0cParticleType\x12\x1d\n\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1e\n\x1aPARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1a\n\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\n\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\n\x0fPARTICLE_SPLASH\x10\x05\x12\x13\n\x0fPARTICLE_EFFECT\x10\x06\x12\x19\n\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\n\x0ePARTICLE_FLAME\x10\x08\x12\x11\n\rPARTICLE_DUST\x10\t\x12\x1e\n\x1aPARTICLE_BLOCK_FORCE_FIELD\x10\n\x12\x16\n\x12PARTICLE_BONE_MEAL\x10\x0b\x12\x16\n\x12PARTICLE_EVAPORATE\x10\x0c\x12\x17\n\x13PARTICLE_WATER_DRIP\x10\r\x12\x16\n\x12PARTICLE_LAVA_DRIP\x10\x0e\x12\x11\n\rPARTICLE_LAVA\x10\x0f\x12\x17\n\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\n\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\n\x14PARTICLE_PUNCH_BLOCK\x10\x12\x42\x8b\x01\n\rcom.df.pluginB\x0c\x41\x63tionsProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') +DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\ractions.proto\x12\tdf.plugin\x1a\x0c\x63ommon.proto\":\n\x0b\x41\x63tionBatch\x12+\n\x07\x61\x63tions\x18\x01 \x03(\x0b\x32\x11.df.plugin.ActionR\x07\x61\x63tions\"\xd9\x0f\n\x06\x41\x63tion\x12*\n\x0e\x63orrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x12\x38\n\tsend_chat\x18\n \x01(\x0b\x32\x19.df.plugin.SendChatActionH\x00R\x08sendChat\x12\x37\n\x08teleport\x18\x0b \x01(\x0b\x32\x19.df.plugin.TeleportActionH\x00R\x08teleport\x12+\n\x04kick\x18\x0c \x01(\x0b\x32\x15.df.plugin.KickActionH\x00R\x04kick\x12\x42\n\rset_game_mode\x18\r \x01(\x0b\x32\x1c.df.plugin.SetGameModeActionH\x00R\x0bsetGameMode\x12\x38\n\tgive_item\x18\x0e \x01(\x0b\x32\x19.df.plugin.GiveItemActionH\x00R\x08giveItem\x12J\n\x0f\x63lear_inventory\x18\x0f \x01(\x0b\x32\x1f.df.plugin.ClearInventoryActionH\x00R\x0e\x63learInventory\x12\x42\n\rset_held_item\x18\x10 \x01(\x0b\x32\x1c.df.plugin.SetHeldItemActionH\x00R\x0bsetHeldItem\x12;\n\nset_health\x18\x14 \x01(\x0b\x32\x1a.df.plugin.SetHealthActionH\x00R\tsetHealth\x12\x35\n\x08set_food\x18\x15 \x01(\x0b\x32\x18.df.plugin.SetFoodActionH\x00R\x07setFood\x12G\n\x0eset_experience\x18\x16 \x01(\x0b\x32\x1e.df.plugin.SetExperienceActionH\x00R\rsetExperience\x12\x41\n\x0cset_velocity\x18\x17 \x01(\x0b\x32\x1c.df.plugin.SetVelocityActionH\x00R\x0bsetVelocity\x12;\n\nadd_effect\x18\x1e \x01(\x0b\x32\x1a.df.plugin.AddEffectActionH\x00R\taddEffect\x12\x44\n\rremove_effect\x18\x1f \x01(\x0b\x32\x1d.df.plugin.RemoveEffectActionH\x00R\x0cremoveEffect\x12;\n\nsend_title\x18( \x01(\x0b\x32\x1a.df.plugin.SendTitleActionH\x00R\tsendTitle\x12;\n\nsend_popup\x18) \x01(\x0b\x32\x1a.df.plugin.SendPopupActionH\x00R\tsendPopup\x12\x35\n\x08send_tip\x18* \x01(\x0b\x32\x18.df.plugin.SendTipActionH\x00R\x07sendTip\x12;\n\nplay_sound\x18+ \x01(\x0b\x32\x1a.df.plugin.PlaySoundActionH\x00R\tplaySound\x12J\n\x0f\x65xecute_command\x18\x32 \x01(\x0b\x32\x1f.df.plugin.ExecuteCommandActionH\x00R\x0e\x65xecuteCommand\x12h\n\x1bworld_set_default_game_mode\x18< \x01(\x0b\x32(.df.plugin.WorldSetDefaultGameModeActionH\x00R\x17worldSetDefaultGameMode\x12W\n\x14world_set_difficulty\x18= \x01(\x0b\x32#.df.plugin.WorldSetDifficultyActionH\x00R\x12worldSetDifficulty\x12U\n\x14world_set_tick_range\x18> \x01(\x0b\x32\".df.plugin.WorldSetTickRangeActionH\x00R\x11worldSetTickRange\x12H\n\x0fworld_set_block\x18? \x01(\x0b\x32\x1e.df.plugin.WorldSetBlockActionH\x00R\rworldSetBlock\x12K\n\x10world_play_sound\x18@ \x01(\x0b\x32\x1f.df.plugin.WorldPlaySoundActionH\x00R\x0eworldPlaySound\x12Q\n\x12world_add_particle\x18\x41 \x01(\x0b\x32!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\n\x14world_query_entities\x18\x46 \x01(\x0b\x32#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\n\x13world_query_players\x18G \x01(\x0b\x32\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\n\x1bworld_query_entities_within\x18H \x01(\x0b\x32).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithinB\x06\n\x04kindB\x11\n\x0f_correlation_id\"K\n\x0eSendChatAction\x12\x1f\n\x0btarget_uuid\x18\x01 \x01(\tR\ntargetUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\x8b\x01\n\x0eTeleportAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12+\n\x08rotation\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08rotation\"E\n\nKickAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06reason\x18\x02 \x01(\tR\x06reason\"f\n\x11SetGameModeAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"[\n\x0eGiveItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12(\n\x04item\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackR\x04item\"7\n\x14\x43learInventoryAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\"\xad\x01\n\x11SetHeldItemAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12-\n\x04main\x18\x02 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x00R\x04main\x88\x01\x01\x12\x33\n\x07offhand\x18\x03 \x01(\x0b\x32\x14.df.plugin.ItemStackH\x01R\x07offhand\x88\x01\x01\x42\x07\n\x05_mainB\n\n\x08_offhand\"}\n\x0fSetHealthAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x16\n\x06health\x18\x02 \x01(\x01R\x06health\x12\"\n\nmax_health\x18\x03 \x01(\x01H\x00R\tmaxHealth\x88\x01\x01\x42\r\n\x0b_max_health\"D\n\rSetFoodAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x12\n\x04\x66ood\x18\x02 \x01(\x05R\x04\x66ood\"\xb1\x01\n\x13SetExperienceAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x19\n\x05level\x18\x02 \x01(\x05H\x00R\x05level\x88\x01\x01\x12\x1f\n\x08progress\x18\x03 \x01(\x02H\x01R\x08progress\x88\x01\x01\x12\x1b\n\x06\x61mount\x18\x04 \x01(\x05H\x02R\x06\x61mount\x88\x01\x01\x42\x08\n\x06_levelB\x0b\n\t_progressB\t\n\x07_amount\"a\n\x11SetVelocityAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12+\n\x08velocity\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08velocity\"\xc8\x01\n\x0f\x41\x64\x64\x45\x66\x66\x65\x63tAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\x12\x14\n\x05level\x18\x03 \x01(\x05R\x05level\x12\x1f\n\x0b\x64uration_ms\x18\x04 \x01(\x03R\ndurationMs\x12%\n\x0eshow_particles\x18\x05 \x01(\x08R\rshowParticles\"m\n\x12RemoveEffectAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x36\n\x0b\x65\x66\x66\x65\x63t_type\x18\x02 \x01(\x0e\x32\x15.df.plugin.EffectTypeR\neffectType\"\x93\x02\n\x0fSendTitleAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x14\n\x05title\x18\x02 \x01(\tR\x05title\x12\x1f\n\x08subtitle\x18\x03 \x01(\tH\x00R\x08subtitle\x88\x01\x01\x12!\n\nfade_in_ms\x18\x04 \x01(\x03H\x01R\x08\x66\x61\x64\x65InMs\x88\x01\x01\x12$\n\x0b\x64uration_ms\x18\x05 \x01(\x03H\x02R\ndurationMs\x88\x01\x01\x12#\n\x0b\x66\x61\x64\x65_out_ms\x18\x06 \x01(\x03H\x03R\tfadeOutMs\x88\x01\x01\x42\x0b\n\t_subtitleB\r\n\x0b_fade_in_msB\x0e\n\x0c_duration_msB\x0e\n\x0c_fade_out_ms\"L\n\x0fSendPopupAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"J\n\rSendTipAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07message\x18\x02 \x01(\tR\x07message\"\xe6\x01\n\x0fPlaySoundAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12\x30\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3H\x00R\x08position\x88\x01\x01\x12\x1b\n\x06volume\x18\x04 \x01(\x02H\x01R\x06volume\x88\x01\x01\x12\x19\n\x05pitch\x18\x05 \x01(\x02H\x02R\x05pitch\x88\x01\x01\x42\x0b\n\t_positionB\t\n\x07_volumeB\x08\n\x06_pitch\"Q\n\x14\x45xecuteCommandAction\x12\x1f\n\x0bplayer_uuid\x18\x01 \x01(\tR\nplayerUuid\x12\x18\n\x07\x63ommand\x18\x02 \x01(\tR\x07\x63ommand\"|\n\x1dWorldSetDefaultGameModeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\tgame_mode\x18\x02 \x01(\x0e\x32\x13.df.plugin.GameModeR\x08gameMode\"|\n\x18WorldSetDifficultyAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x35\n\ndifficulty\x18\x02 \x01(\x0e\x32\x15.df.plugin.DifficultyR\ndifficulty\"c\n\x17WorldSetTickRangeAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x1d\n\ntick_range\x18\x02 \x01(\x05R\ttickRange\"\xad\x01\n\x13WorldSetBlockAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12/\n\x08position\x18\x02 \x01(\x0b\x32\x13.df.plugin.BlockPosR\x08position\x12\x30\n\x05\x62lock\x18\x03 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x42\x08\n\x06_block\"\x96\x01\n\x14WorldPlaySoundAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12&\n\x05sound\x18\x02 \x01(\x0e\x32\x10.df.plugin.SoundR\x05sound\x12+\n\x08position\x18\x03 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\"\x83\x02\n\x16WorldAddParticleAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12+\n\x08position\x18\x02 \x01(\x0b\x32\x0f.df.plugin.Vec3R\x08position\x12\x33\n\x08particle\x18\x03 \x01(\x0e\x32\x17.df.plugin.ParticleTypeR\x08particle\x12\x30\n\x05\x62lock\x18\x04 \x01(\x0b\x32\x15.df.plugin.BlockStateH\x00R\x05\x62lock\x88\x01\x01\x12\x17\n\x04\x66\x61\x63\x65\x18\x05 \x01(\x05H\x01R\x04\x66\x61\x63\x65\x88\x01\x01\x42\x08\n\x06_blockB\x07\n\x05_face\"E\n\x18WorldQueryEntitiesAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"D\n\x17WorldQueryPlayersAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\"n\n\x1eWorldQueryEntitiesWithinAction\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\"C\n\x0c\x41\x63tionStatus\x12\x0e\n\x02ok\x18\x01 \x01(\x08R\x02ok\x12\x19\n\x05\x65rror\x18\x02 \x01(\tH\x00R\x05\x65rror\x88\x01\x01\x42\x08\n\x06_error\"r\n\x13WorldEntitiesResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12\x30\n\x08\x65ntities\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"\x9b\x01\n\x19WorldEntitiesWithinResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12!\n\x03\x62ox\x18\x02 \x01(\x0b\x32\x0f.df.plugin.BBoxR\x03\x62ox\x12\x30\n\x08\x65ntities\x18\x03 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x08\x65ntities\"o\n\x12WorldPlayersResult\x12)\n\x05world\x18\x01 \x01(\x0b\x32\x13.df.plugin.WorldRefR\x05world\x12.\n\x07players\x18\x02 \x03(\x0b\x32\x14.df.plugin.EntityRefR\x07players\"\xeb\x02\n\x0c\x41\x63tionResult\x12%\n\x0e\x63orrelation_id\x18\x01 \x01(\tR\rcorrelationId\x12\x34\n\x06status\x18\x02 \x01(\x0b\x32\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\n\x0eworld_entities\x18\n \x01(\x0b\x32\x1e.df.plugin.WorldEntitiesResultH\x00R\rworldEntities\x12\x44\n\rworld_players\x18\x0b \x01(\x0b\x32\x1d.df.plugin.WorldPlayersResultH\x00R\x0cworldPlayers\x12Z\n\x15world_entities_within\x18\x0c \x01(\x0b\x32$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithinB\x08\n\x06resultB\t\n\x07_status*\xeb\x03\n\x0cParticleType\x12\x1d\n\x19PARTICLE_TYPE_UNSPECIFIED\x10\x00\x12\x1b\n\x17PARTICLE_HUGE_EXPLOSION\x10\x01\x12\x1e\n\x1aPARTICLE_ENDERMAN_TELEPORT\x10\x02\x12\x1a\n\x16PARTICLE_SNOWBALL_POOF\x10\x03\x12\x16\n\x12PARTICLE_EGG_SMASH\x10\x04\x12\x13\n\x0fPARTICLE_SPLASH\x10\x05\x12\x13\n\x0fPARTICLE_EFFECT\x10\x06\x12\x19\n\x15PARTICLE_ENTITY_FLAME\x10\x07\x12\x12\n\x0ePARTICLE_FLAME\x10\x08\x12\x11\n\rPARTICLE_DUST\x10\t\x12\x1e\n\x1aPARTICLE_BLOCK_FORCE_FIELD\x10\n\x12\x16\n\x12PARTICLE_BONE_MEAL\x10\x0b\x12\x16\n\x12PARTICLE_EVAPORATE\x10\x0c\x12\x17\n\x13PARTICLE_WATER_DRIP\x10\r\x12\x16\n\x12PARTICLE_LAVA_DRIP\x10\x0e\x12\x11\n\rPARTICLE_LAVA\x10\x0f\x12\x17\n\x13PARTICLE_DUST_PLUME\x10\x10\x12\x18\n\x14PARTICLE_BLOCK_BREAK\x10\x11\x12\x18\n\x14PARTICLE_PUNCH_BLOCK\x10\x12\x42\x8b\x01\n\rcom.df.pluginB\x0c\x41\x63tionsProtoP\x01Z\'github.com/secmc/plugin/proto/generated\xa2\x02\x03\x44PX\xaa\x02\tDf.Plugin\xca\x02\tDf\\Plugin\xe2\x02\x15\x44\x66\\Plugin\\GPBMetadata\xea\x02\nDf::Pluginb\x06proto3') _globals = globals() _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals) @@ -33,78 +33,74 @@ if not _descriptor._USE_C_DESCRIPTORS: _globals['DESCRIPTOR']._loaded_options = None _globals['DESCRIPTOR']._serialized_options = b'\n\rcom.df.pluginB\014ActionsProtoP\001Z\'github.com/secmc/plugin/proto/generated\242\002\003DPX\252\002\tDf.Plugin\312\002\tDf\\Plugin\342\002\025Df\\Plugin\\GPBMetadata\352\002\nDf::Plugin' - _globals['_PARTICLETYPE']._serialized_start=6809 - _globals['_PARTICLETYPE']._serialized_end=7300 + _globals['_PARTICLETYPE']._serialized_start=6392 + _globals['_PARTICLETYPE']._serialized_end=6883 _globals['_ACTIONBATCH']._serialized_start=42 _globals['_ACTIONBATCH']._serialized_end=100 _globals['_ACTION']._serialized_start=103 - _globals['_ACTION']._serialized_end=2198 - _globals['_SENDCHATACTION']._serialized_start=2200 - _globals['_SENDCHATACTION']._serialized_end=2275 - _globals['_TELEPORTACTION']._serialized_start=2278 - _globals['_TELEPORTACTION']._serialized_end=2417 - _globals['_KICKACTION']._serialized_start=2419 - _globals['_KICKACTION']._serialized_end=2488 - _globals['_SETGAMEMODEACTION']._serialized_start=2490 - _globals['_SETGAMEMODEACTION']._serialized_end=2592 - _globals['_GIVEITEMACTION']._serialized_start=2594 - _globals['_GIVEITEMACTION']._serialized_end=2685 - _globals['_CLEARINVENTORYACTION']._serialized_start=2687 - _globals['_CLEARINVENTORYACTION']._serialized_end=2742 - _globals['_SETHELDITEMACTION']._serialized_start=2745 - _globals['_SETHELDITEMACTION']._serialized_end=2918 - _globals['_SETHEALTHACTION']._serialized_start=2920 - _globals['_SETHEALTHACTION']._serialized_end=3045 - _globals['_SETFOODACTION']._serialized_start=3047 - _globals['_SETFOODACTION']._serialized_end=3115 - _globals['_SETEXPERIENCEACTION']._serialized_start=3118 - _globals['_SETEXPERIENCEACTION']._serialized_end=3295 - _globals['_SETVELOCITYACTION']._serialized_start=3297 - _globals['_SETVELOCITYACTION']._serialized_end=3394 - _globals['_ADDEFFECTACTION']._serialized_start=3397 - _globals['_ADDEFFECTACTION']._serialized_end=3597 - _globals['_REMOVEEFFECTACTION']._serialized_start=3599 - _globals['_REMOVEEFFECTACTION']._serialized_end=3708 - _globals['_SENDTITLEACTION']._serialized_start=3711 - _globals['_SENDTITLEACTION']._serialized_end=3986 - _globals['_SENDPOPUPACTION']._serialized_start=3988 - _globals['_SENDPOPUPACTION']._serialized_end=4064 - _globals['_SENDTIPACTION']._serialized_start=4066 - _globals['_SENDTIPACTION']._serialized_end=4140 - _globals['_PLAYSOUNDACTION']._serialized_start=4143 - _globals['_PLAYSOUNDACTION']._serialized_end=4373 - _globals['_EXECUTECOMMANDACTION']._serialized_start=4375 - _globals['_EXECUTECOMMANDACTION']._serialized_end=4456 - _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_start=4458 - _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_end=4582 - _globals['_WORLDSETDIFFICULTYACTION']._serialized_start=4584 - _globals['_WORLDSETDIFFICULTYACTION']._serialized_end=4708 - _globals['_WORLDSETTICKRANGEACTION']._serialized_start=4710 - _globals['_WORLDSETTICKRANGEACTION']._serialized_end=4809 - _globals['_WORLDSETBLOCKACTION']._serialized_start=4812 - _globals['_WORLDSETBLOCKACTION']._serialized_end=4985 - _globals['_WORLDPLAYSOUNDACTION']._serialized_start=4988 - _globals['_WORLDPLAYSOUNDACTION']._serialized_end=5138 - _globals['_WORLDADDPARTICLEACTION']._serialized_start=5141 - _globals['_WORLDADDPARTICLEACTION']._serialized_end=5400 - _globals['_WORLDQUERYENTITIESACTION']._serialized_start=5402 - _globals['_WORLDQUERYENTITIESACTION']._serialized_end=5471 - _globals['_WORLDQUERYPLAYERSACTION']._serialized_start=5473 - _globals['_WORLDQUERYPLAYERSACTION']._serialized_end=5541 - _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_start=5543 - _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_end=5653 - _globals['_WORLDQUERYVIEWERSACTION']._serialized_start=5655 - _globals['_WORLDQUERYVIEWERSACTION']._serialized_end=5768 - _globals['_ACTIONSTATUS']._serialized_start=5770 - _globals['_ACTIONSTATUS']._serialized_end=5837 - _globals['_WORLDENTITIESRESULT']._serialized_start=5839 - _globals['_WORLDENTITIESRESULT']._serialized_end=5953 - _globals['_WORLDENTITIESWITHINRESULT']._serialized_start=5956 - _globals['_WORLDENTITIESWITHINRESULT']._serialized_end=6111 - _globals['_WORLDPLAYERSRESULT']._serialized_start=6113 - _globals['_WORLDPLAYERSRESULT']._serialized_end=6224 - _globals['_WORLDVIEWERSRESULT']._serialized_start=6227 - _globals['_WORLDVIEWERSRESULT']._serialized_end=6370 - _globals['_ACTIONRESULT']._serialized_start=6373 - _globals['_ACTIONRESULT']._serialized_end=6806 + _globals['_ACTION']._serialized_end=2112 + _globals['_SENDCHATACTION']._serialized_start=2114 + _globals['_SENDCHATACTION']._serialized_end=2189 + _globals['_TELEPORTACTION']._serialized_start=2192 + _globals['_TELEPORTACTION']._serialized_end=2331 + _globals['_KICKACTION']._serialized_start=2333 + _globals['_KICKACTION']._serialized_end=2402 + _globals['_SETGAMEMODEACTION']._serialized_start=2404 + _globals['_SETGAMEMODEACTION']._serialized_end=2506 + _globals['_GIVEITEMACTION']._serialized_start=2508 + _globals['_GIVEITEMACTION']._serialized_end=2599 + _globals['_CLEARINVENTORYACTION']._serialized_start=2601 + _globals['_CLEARINVENTORYACTION']._serialized_end=2656 + _globals['_SETHELDITEMACTION']._serialized_start=2659 + _globals['_SETHELDITEMACTION']._serialized_end=2832 + _globals['_SETHEALTHACTION']._serialized_start=2834 + _globals['_SETHEALTHACTION']._serialized_end=2959 + _globals['_SETFOODACTION']._serialized_start=2961 + _globals['_SETFOODACTION']._serialized_end=3029 + _globals['_SETEXPERIENCEACTION']._serialized_start=3032 + _globals['_SETEXPERIENCEACTION']._serialized_end=3209 + _globals['_SETVELOCITYACTION']._serialized_start=3211 + _globals['_SETVELOCITYACTION']._serialized_end=3308 + _globals['_ADDEFFECTACTION']._serialized_start=3311 + _globals['_ADDEFFECTACTION']._serialized_end=3511 + _globals['_REMOVEEFFECTACTION']._serialized_start=3513 + _globals['_REMOVEEFFECTACTION']._serialized_end=3622 + _globals['_SENDTITLEACTION']._serialized_start=3625 + _globals['_SENDTITLEACTION']._serialized_end=3900 + _globals['_SENDPOPUPACTION']._serialized_start=3902 + _globals['_SENDPOPUPACTION']._serialized_end=3978 + _globals['_SENDTIPACTION']._serialized_start=3980 + _globals['_SENDTIPACTION']._serialized_end=4054 + _globals['_PLAYSOUNDACTION']._serialized_start=4057 + _globals['_PLAYSOUNDACTION']._serialized_end=4287 + _globals['_EXECUTECOMMANDACTION']._serialized_start=4289 + _globals['_EXECUTECOMMANDACTION']._serialized_end=4370 + _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_start=4372 + _globals['_WORLDSETDEFAULTGAMEMODEACTION']._serialized_end=4496 + _globals['_WORLDSETDIFFICULTYACTION']._serialized_start=4498 + _globals['_WORLDSETDIFFICULTYACTION']._serialized_end=4622 + _globals['_WORLDSETTICKRANGEACTION']._serialized_start=4624 + _globals['_WORLDSETTICKRANGEACTION']._serialized_end=4723 + _globals['_WORLDSETBLOCKACTION']._serialized_start=4726 + _globals['_WORLDSETBLOCKACTION']._serialized_end=4899 + _globals['_WORLDPLAYSOUNDACTION']._serialized_start=4902 + _globals['_WORLDPLAYSOUNDACTION']._serialized_end=5052 + _globals['_WORLDADDPARTICLEACTION']._serialized_start=5055 + _globals['_WORLDADDPARTICLEACTION']._serialized_end=5314 + _globals['_WORLDQUERYENTITIESACTION']._serialized_start=5316 + _globals['_WORLDQUERYENTITIESACTION']._serialized_end=5385 + _globals['_WORLDQUERYPLAYERSACTION']._serialized_start=5387 + _globals['_WORLDQUERYPLAYERSACTION']._serialized_end=5455 + _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_start=5457 + _globals['_WORLDQUERYENTITIESWITHINACTION']._serialized_end=5567 + _globals['_ACTIONSTATUS']._serialized_start=5569 + _globals['_ACTIONSTATUS']._serialized_end=5636 + _globals['_WORLDENTITIESRESULT']._serialized_start=5638 + _globals['_WORLDENTITIESRESULT']._serialized_end=5752 + _globals['_WORLDENTITIESWITHINRESULT']._serialized_start=5755 + _globals['_WORLDENTITIESWITHINRESULT']._serialized_end=5910 + _globals['_WORLDPLAYERSRESULT']._serialized_start=5912 + _globals['_WORLDPLAYERSRESULT']._serialized_end=6023 + _globals['_ACTIONRESULT']._serialized_start=6026 + _globals['_ACTIONRESULT']._serialized_end=6389 # @@protoc_insertion_point(module_scope) diff --git a/packages/rust/src/generated/df.plugin.rs b/packages/rust/src/generated/df.plugin.rs index 469dbfd..deca148 100644 --- a/packages/rust/src/generated/df.plugin.rs +++ b/packages/rust/src/generated/df.plugin.rs @@ -440,7 +440,7 @@ pub struct ActionBatch { pub struct Action { #[prost(string, optional, tag="1")] pub correlation_id: ::core::option::Option<::prost::alloc::string::String>, - #[prost(oneof="action::Kind", tags="10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 30, 31, 40, 41, 42, 43, 50, 60, 61, 62, 63, 64, 65, 70, 71, 72, 73")] + #[prost(oneof="action::Kind", tags="10, 11, 12, 13, 14, 15, 16, 20, 21, 22, 23, 30, 31, 40, 41, 42, 43, 50, 60, 61, 62, 63, 64, 65, 70, 71, 72")] pub kind: ::core::option::Option, } /// Nested message and enum types in `Action`. @@ -509,8 +509,6 @@ pub mod action { WorldQueryPlayers(super::WorldQueryPlayersAction), #[prost(message, tag="72")] WorldQueryEntitiesWithin(super::WorldQueryEntitiesWithinAction), - #[prost(message, tag="73")] - WorldQueryViewers(super::WorldQueryViewersAction), } } #[allow(clippy::derive_partial_eq_without_eq)] @@ -788,14 +786,6 @@ pub struct WorldQueryEntitiesWithinAction { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct WorldQueryViewersAction { - #[prost(message, optional, tag="1")] - pub world: ::core::option::Option, - #[prost(message, optional, tag="2")] - pub position: ::core::option::Option, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionStatus { #[prost(bool, tag="1")] pub ok: bool, @@ -830,22 +820,12 @@ pub struct WorldPlayersResult { } #[allow(clippy::derive_partial_eq_without_eq)] #[derive(Clone, PartialEq, ::prost::Message)] -pub struct WorldViewersResult { - #[prost(message, optional, tag="1")] - pub world: ::core::option::Option, - #[prost(message, optional, tag="2")] - pub position: ::core::option::Option, - #[prost(string, repeated, tag="3")] - pub viewer_uuids: ::prost::alloc::vec::Vec<::prost::alloc::string::String>, -} -#[allow(clippy::derive_partial_eq_without_eq)] -#[derive(Clone, PartialEq, ::prost::Message)] pub struct ActionResult { #[prost(string, tag="1")] pub correlation_id: ::prost::alloc::string::String, #[prost(message, optional, tag="2")] pub status: ::core::option::Option, - #[prost(oneof="action_result::Result", tags="10, 11, 12, 13")] + #[prost(oneof="action_result::Result", tags="10, 11, 12")] pub result: ::core::option::Option, } /// Nested message and enum types in `ActionResult`. @@ -859,8 +839,6 @@ pub mod action_result { WorldPlayers(super::WorldPlayersResult), #[prost(message, tag="12")] WorldEntitiesWithin(super::WorldEntitiesWithinResult), - #[prost(message, tag="13")] - WorldViewers(super::WorldViewersResult), } } #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)] diff --git a/plugin/adapters/plugin/actions.go b/plugin/adapters/plugin/actions.go index 17bcbf6..dfded0b 100644 --- a/plugin/adapters/plugin/actions.go +++ b/plugin/adapters/plugin/actions.go @@ -1,6 +1,7 @@ package plugin import ( + "strings" "time" "github.com/df-mc/dragonfly/server/block/cube" @@ -82,8 +83,6 @@ func (m *Manager) applyActions(p *pluginProcess, batch *pb.ActionBatch) { m.handleWorldQueryPlayers(p, correlationID, kind.WorldQueryPlayers) case *pb.Action_WorldQueryEntitiesWithin: m.handleWorldQueryEntitiesWithin(p, correlationID, kind.WorldQueryEntitiesWithin) - case *pb.Action_WorldQueryViewers: - m.handleWorldQueryViewers(p, correlationID, kind.WorldQueryViewers) } } } @@ -542,36 +541,6 @@ func (m *Manager) handleWorldQueryEntitiesWithin(p *pluginProcess, correlationID }) } -func (m *Manager) handleWorldQueryViewers(p *pluginProcess, correlationID string, act *pb.WorldQueryViewersAction) { - w := m.worldFromRef(act.GetWorld()) - if w == nil { - m.sendActionError(p, correlationID, "world not found") - return - } - pos, ok := vec3FromProto(act.Position) - if !ok { - m.sendActionError(p, correlationID, "invalid position") - return - } - viewers := make([]string, 0) - <-w.Exec(func(tx *world.Tx) { - for _, v := range tx.Viewers(pos) { - if pl, ok := v.(*player.Player); ok { - viewers = append(viewers, pl.UUID().String()) - } - } - }) - m.sendActionResult(p, &pb.ActionResult{ - CorrelationId: correlationID, - Status: &pb.ActionStatus{Ok: true}, - Result: &pb.ActionResult_WorldViewers{WorldViewers: &pb.WorldViewersResult{ - World: protoWorldRef(w), - Position: protoVec3(pos), - ViewerUuids: viewers, - }}, - }) -} - func (m *Manager) execMethod(id uuid.UUID, method func(pl *player.Player)) { if m.srv == nil { return diff --git a/proto/generated/go/actions.pb.go b/proto/generated/go/actions.pb.go index f9c48be..f2aa3af 100644 --- a/proto/generated/go/actions.pb.go +++ b/proto/generated/go/actions.pb.go @@ -194,7 +194,6 @@ type Action struct { // *Action_WorldQueryEntities // *Action_WorldQueryPlayers // *Action_WorldQueryEntitiesWithin - // *Action_WorldQueryViewers Kind isAction_Kind `protobuf_oneof:"kind"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -487,15 +486,6 @@ func (x *Action) GetWorldQueryEntitiesWithin() *WorldQueryEntitiesWithinAction { return nil } -func (x *Action) GetWorldQueryViewers() *WorldQueryViewersAction { - if x != nil { - if x, ok := x.Kind.(*Action_WorldQueryViewers); ok { - return x.WorldQueryViewers - } - } - return nil -} - type isAction_Kind interface { isAction_Kind() } @@ -615,10 +605,6 @@ type Action_WorldQueryEntitiesWithin struct { WorldQueryEntitiesWithin *WorldQueryEntitiesWithinAction `protobuf:"bytes,72,opt,name=world_query_entities_within,json=worldQueryEntitiesWithin,proto3,oneof"` } -type Action_WorldQueryViewers struct { - WorldQueryViewers *WorldQueryViewersAction `protobuf:"bytes,73,opt,name=world_query_viewers,json=worldQueryViewers,proto3,oneof"` -} - func (*Action_SendChat) isAction_Kind() {} func (*Action_Teleport) isAction_Kind() {} @@ -673,8 +659,6 @@ func (*Action_WorldQueryPlayers) isAction_Kind() {} func (*Action_WorldQueryEntitiesWithin) isAction_Kind() {} -func (*Action_WorldQueryViewers) isAction_Kind() {} - type SendChatAction struct { state protoimpl.MessageState `protogen:"open.v1"` TargetUuid string `protobuf:"bytes,1,opt,name=target_uuid,json=targetUuid,proto3" json:"target_uuid,omitempty"` @@ -2226,58 +2210,6 @@ func (x *WorldQueryEntitiesWithinAction) GetBox() *BBox { return nil } -type WorldQueryViewersAction struct { - state protoimpl.MessageState `protogen:"open.v1"` - World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` - Position *Vec3 `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *WorldQueryViewersAction) Reset() { - *x = WorldQueryViewersAction{} - mi := &file_actions_proto_msgTypes[29] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *WorldQueryViewersAction) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*WorldQueryViewersAction) ProtoMessage() {} - -func (x *WorldQueryViewersAction) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[29] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use WorldQueryViewersAction.ProtoReflect.Descriptor instead. -func (*WorldQueryViewersAction) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{29} -} - -func (x *WorldQueryViewersAction) GetWorld() *WorldRef { - if x != nil { - return x.World - } - return nil -} - -func (x *WorldQueryViewersAction) GetPosition() *Vec3 { - if x != nil { - return x.Position - } - return nil -} - type ActionStatus struct { state protoimpl.MessageState `protogen:"open.v1"` Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` @@ -2288,7 +2220,7 @@ type ActionStatus struct { func (x *ActionStatus) Reset() { *x = ActionStatus{} - mi := &file_actions_proto_msgTypes[30] + mi := &file_actions_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2300,7 +2232,7 @@ func (x *ActionStatus) String() string { func (*ActionStatus) ProtoMessage() {} func (x *ActionStatus) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[30] + mi := &file_actions_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2313,7 +2245,7 @@ func (x *ActionStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionStatus.ProtoReflect.Descriptor instead. func (*ActionStatus) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{30} + return file_actions_proto_rawDescGZIP(), []int{29} } func (x *ActionStatus) GetOk() bool { @@ -2340,7 +2272,7 @@ type WorldEntitiesResult struct { func (x *WorldEntitiesResult) Reset() { *x = WorldEntitiesResult{} - mi := &file_actions_proto_msgTypes[31] + mi := &file_actions_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2352,7 +2284,7 @@ func (x *WorldEntitiesResult) String() string { func (*WorldEntitiesResult) ProtoMessage() {} func (x *WorldEntitiesResult) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[31] + mi := &file_actions_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2365,7 +2297,7 @@ func (x *WorldEntitiesResult) ProtoReflect() protoreflect.Message { // Deprecated: Use WorldEntitiesResult.ProtoReflect.Descriptor instead. func (*WorldEntitiesResult) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{31} + return file_actions_proto_rawDescGZIP(), []int{30} } func (x *WorldEntitiesResult) GetWorld() *WorldRef { @@ -2393,7 +2325,7 @@ type WorldEntitiesWithinResult struct { func (x *WorldEntitiesWithinResult) Reset() { *x = WorldEntitiesWithinResult{} - mi := &file_actions_proto_msgTypes[32] + mi := &file_actions_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2405,7 +2337,7 @@ func (x *WorldEntitiesWithinResult) String() string { func (*WorldEntitiesWithinResult) ProtoMessage() {} func (x *WorldEntitiesWithinResult) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[32] + mi := &file_actions_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2418,7 +2350,7 @@ func (x *WorldEntitiesWithinResult) ProtoReflect() protoreflect.Message { // Deprecated: Use WorldEntitiesWithinResult.ProtoReflect.Descriptor instead. func (*WorldEntitiesWithinResult) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{32} + return file_actions_proto_rawDescGZIP(), []int{31} } func (x *WorldEntitiesWithinResult) GetWorld() *WorldRef { @@ -2452,7 +2384,7 @@ type WorldPlayersResult struct { func (x *WorldPlayersResult) Reset() { *x = WorldPlayersResult{} - mi := &file_actions_proto_msgTypes[33] + mi := &file_actions_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2464,7 +2396,7 @@ func (x *WorldPlayersResult) String() string { func (*WorldPlayersResult) ProtoMessage() {} func (x *WorldPlayersResult) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[33] + mi := &file_actions_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2477,7 +2409,7 @@ func (x *WorldPlayersResult) ProtoReflect() protoreflect.Message { // Deprecated: Use WorldPlayersResult.ProtoReflect.Descriptor instead. func (*WorldPlayersResult) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{33} + return file_actions_proto_rawDescGZIP(), []int{32} } func (x *WorldPlayersResult) GetWorld() *WorldRef { @@ -2494,66 +2426,6 @@ func (x *WorldPlayersResult) GetPlayers() []*EntityRef { return nil } -type WorldViewersResult struct { - state protoimpl.MessageState `protogen:"open.v1"` - World *WorldRef `protobuf:"bytes,1,opt,name=world,proto3" json:"world,omitempty"` - Position *Vec3 `protobuf:"bytes,2,opt,name=position,proto3" json:"position,omitempty"` - ViewerUuids []string `protobuf:"bytes,3,rep,name=viewer_uuids,json=viewerUuids,proto3" json:"viewer_uuids,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *WorldViewersResult) Reset() { - *x = WorldViewersResult{} - mi := &file_actions_proto_msgTypes[34] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *WorldViewersResult) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*WorldViewersResult) ProtoMessage() {} - -func (x *WorldViewersResult) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[34] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use WorldViewersResult.ProtoReflect.Descriptor instead. -func (*WorldViewersResult) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{34} -} - -func (x *WorldViewersResult) GetWorld() *WorldRef { - if x != nil { - return x.World - } - return nil -} - -func (x *WorldViewersResult) GetPosition() *Vec3 { - if x != nil { - return x.Position - } - return nil -} - -func (x *WorldViewersResult) GetViewerUuids() []string { - if x != nil { - return x.ViewerUuids - } - return nil -} - type ActionResult struct { state protoimpl.MessageState `protogen:"open.v1"` CorrelationId string `protobuf:"bytes,1,opt,name=correlation_id,json=correlationId,proto3" json:"correlation_id,omitempty"` @@ -2563,7 +2435,6 @@ type ActionResult struct { // *ActionResult_WorldEntities // *ActionResult_WorldPlayers // *ActionResult_WorldEntitiesWithin - // *ActionResult_WorldViewers Result isActionResult_Result `protobuf_oneof:"result"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache @@ -2571,7 +2442,7 @@ type ActionResult struct { func (x *ActionResult) Reset() { *x = ActionResult{} - mi := &file_actions_proto_msgTypes[35] + mi := &file_actions_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2583,7 +2454,7 @@ func (x *ActionResult) String() string { func (*ActionResult) ProtoMessage() {} func (x *ActionResult) ProtoReflect() protoreflect.Message { - mi := &file_actions_proto_msgTypes[35] + mi := &file_actions_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2596,7 +2467,7 @@ func (x *ActionResult) ProtoReflect() protoreflect.Message { // Deprecated: Use ActionResult.ProtoReflect.Descriptor instead. func (*ActionResult) Descriptor() ([]byte, []int) { - return file_actions_proto_rawDescGZIP(), []int{35} + return file_actions_proto_rawDescGZIP(), []int{33} } func (x *ActionResult) GetCorrelationId() string { @@ -2647,15 +2518,6 @@ func (x *ActionResult) GetWorldEntitiesWithin() *WorldEntitiesWithinResult { return nil } -func (x *ActionResult) GetWorldViewers() *WorldViewersResult { - if x != nil { - if x, ok := x.Result.(*ActionResult_WorldViewers); ok { - return x.WorldViewers - } - } - return nil -} - type isActionResult_Result interface { isActionResult_Result() } @@ -2672,25 +2534,19 @@ type ActionResult_WorldEntitiesWithin struct { WorldEntitiesWithin *WorldEntitiesWithinResult `protobuf:"bytes,12,opt,name=world_entities_within,json=worldEntitiesWithin,proto3,oneof"` } -type ActionResult_WorldViewers struct { - WorldViewers *WorldViewersResult `protobuf:"bytes,13,opt,name=world_viewers,json=worldViewers,proto3,oneof"` -} - func (*ActionResult_WorldEntities) isActionResult_Result() {} func (*ActionResult_WorldPlayers) isActionResult_Result() {} func (*ActionResult_WorldEntitiesWithin) isActionResult_Result() {} -func (*ActionResult_WorldViewers) isActionResult_Result() {} - var File_actions_proto protoreflect.FileDescriptor const file_actions_proto_rawDesc = "" + "\n" + "\ractions.proto\x12\tdf.plugin\x1a\fcommon.proto\":\n" + "\vActionBatch\x12+\n" + - "\aactions\x18\x01 \x03(\v2\x11.df.plugin.ActionR\aactions\"\xaf\x10\n" + + "\aactions\x18\x01 \x03(\v2\x11.df.plugin.ActionR\aactions\"\xd9\x0f\n" + "\x06Action\x12*\n" + "\x0ecorrelation_id\x18\x01 \x01(\tH\x01R\rcorrelationId\x88\x01\x01\x128\n" + "\tsend_chat\x18\n" + @@ -2725,8 +2581,7 @@ const file_actions_proto_rawDesc = "" + "\x12world_add_particle\x18A \x01(\v2!.df.plugin.WorldAddParticleActionH\x00R\x10worldAddParticle\x12W\n" + "\x14world_query_entities\x18F \x01(\v2#.df.plugin.WorldQueryEntitiesActionH\x00R\x12worldQueryEntities\x12T\n" + "\x13world_query_players\x18G \x01(\v2\".df.plugin.WorldQueryPlayersActionH\x00R\x11worldQueryPlayers\x12j\n" + - "\x1bworld_query_entities_within\x18H \x01(\v2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithin\x12T\n" + - "\x13world_query_viewers\x18I \x01(\v2\".df.plugin.WorldQueryViewersActionH\x00R\x11worldQueryViewersB\x06\n" + + "\x1bworld_query_entities_within\x18H \x01(\v2).df.plugin.WorldQueryEntitiesWithinActionH\x00R\x18worldQueryEntitiesWithinB\x06\n" + "\x04kindB\x11\n" + "\x0f_correlation_id\"K\n" + "\x0eSendChatAction\x12\x1f\n" + @@ -2871,10 +2726,7 @@ const file_actions_proto_rawDesc = "" + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\"n\n" + "\x1eWorldQueryEntitiesWithinAction\x12)\n" + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12!\n" + - "\x03box\x18\x02 \x01(\v2\x0f.df.plugin.BBoxR\x03box\"q\n" + - "\x17WorldQueryViewersAction\x12)\n" + - "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12+\n" + - "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\"C\n" + + "\x03box\x18\x02 \x01(\v2\x0f.df.plugin.BBoxR\x03box\"C\n" + "\fActionStatus\x12\x0e\n" + "\x02ok\x18\x01 \x01(\bR\x02ok\x12\x19\n" + "\x05error\x18\x02 \x01(\tH\x00R\x05error\x88\x01\x01B\b\n" + @@ -2888,19 +2740,14 @@ const file_actions_proto_rawDesc = "" + "\bentities\x18\x03 \x03(\v2\x14.df.plugin.EntityRefR\bentities\"o\n" + "\x12WorldPlayersResult\x12)\n" + "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12.\n" + - "\aplayers\x18\x02 \x03(\v2\x14.df.plugin.EntityRefR\aplayers\"\x8f\x01\n" + - "\x12WorldViewersResult\x12)\n" + - "\x05world\x18\x01 \x01(\v2\x13.df.plugin.WorldRefR\x05world\x12+\n" + - "\bposition\x18\x02 \x01(\v2\x0f.df.plugin.Vec3R\bposition\x12!\n" + - "\fviewer_uuids\x18\x03 \x03(\tR\vviewerUuids\"\xb1\x03\n" + + "\aplayers\x18\x02 \x03(\v2\x14.df.plugin.EntityRefR\aplayers\"\xeb\x02\n" + "\fActionResult\x12%\n" + "\x0ecorrelation_id\x18\x01 \x01(\tR\rcorrelationId\x124\n" + "\x06status\x18\x02 \x01(\v2\x17.df.plugin.ActionStatusH\x01R\x06status\x88\x01\x01\x12G\n" + "\x0eworld_entities\x18\n" + " \x01(\v2\x1e.df.plugin.WorldEntitiesResultH\x00R\rworldEntities\x12D\n" + "\rworld_players\x18\v \x01(\v2\x1d.df.plugin.WorldPlayersResultH\x00R\fworldPlayers\x12Z\n" + - "\x15world_entities_within\x18\f \x01(\v2$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithin\x12D\n" + - "\rworld_viewers\x18\r \x01(\v2\x1d.df.plugin.WorldViewersResultH\x00R\fworldViewersB\b\n" + + "\x15world_entities_within\x18\f \x01(\v2$.df.plugin.WorldEntitiesWithinResultH\x00R\x13worldEntitiesWithinB\b\n" + "\x06resultB\t\n" + "\a_status*\xeb\x03\n" + "\fParticleType\x12\x1d\n" + @@ -2940,7 +2787,7 @@ func file_actions_proto_rawDescGZIP() []byte { } var file_actions_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_actions_proto_msgTypes = make([]protoimpl.MessageInfo, 36) +var file_actions_proto_msgTypes = make([]protoimpl.MessageInfo, 34) var file_actions_proto_goTypes = []any{ (ParticleType)(0), // 0: df.plugin.ParticleType (*ActionBatch)(nil), // 1: df.plugin.ActionBatch @@ -2972,24 +2819,22 @@ var file_actions_proto_goTypes = []any{ (*WorldQueryEntitiesAction)(nil), // 27: df.plugin.WorldQueryEntitiesAction (*WorldQueryPlayersAction)(nil), // 28: df.plugin.WorldQueryPlayersAction (*WorldQueryEntitiesWithinAction)(nil), // 29: df.plugin.WorldQueryEntitiesWithinAction - (*WorldQueryViewersAction)(nil), // 30: df.plugin.WorldQueryViewersAction - (*ActionStatus)(nil), // 31: df.plugin.ActionStatus - (*WorldEntitiesResult)(nil), // 32: df.plugin.WorldEntitiesResult - (*WorldEntitiesWithinResult)(nil), // 33: df.plugin.WorldEntitiesWithinResult - (*WorldPlayersResult)(nil), // 34: df.plugin.WorldPlayersResult - (*WorldViewersResult)(nil), // 35: df.plugin.WorldViewersResult - (*ActionResult)(nil), // 36: df.plugin.ActionResult - (*Vec3)(nil), // 37: df.plugin.Vec3 - (GameMode)(0), // 38: df.plugin.GameMode - (*ItemStack)(nil), // 39: df.plugin.ItemStack - (EffectType)(0), // 40: df.plugin.EffectType - (Sound)(0), // 41: df.plugin.Sound - (*WorldRef)(nil), // 42: df.plugin.WorldRef - (Difficulty)(0), // 43: df.plugin.Difficulty - (*BlockPos)(nil), // 44: df.plugin.BlockPos - (*BlockState)(nil), // 45: df.plugin.BlockState - (*BBox)(nil), // 46: df.plugin.BBox - (*EntityRef)(nil), // 47: df.plugin.EntityRef + (*ActionStatus)(nil), // 30: df.plugin.ActionStatus + (*WorldEntitiesResult)(nil), // 31: df.plugin.WorldEntitiesResult + (*WorldEntitiesWithinResult)(nil), // 32: df.plugin.WorldEntitiesWithinResult + (*WorldPlayersResult)(nil), // 33: df.plugin.WorldPlayersResult + (*ActionResult)(nil), // 34: df.plugin.ActionResult + (*Vec3)(nil), // 35: df.plugin.Vec3 + (GameMode)(0), // 36: df.plugin.GameMode + (*ItemStack)(nil), // 37: df.plugin.ItemStack + (EffectType)(0), // 38: df.plugin.EffectType + (Sound)(0), // 39: df.plugin.Sound + (*WorldRef)(nil), // 40: df.plugin.WorldRef + (Difficulty)(0), // 41: df.plugin.Difficulty + (*BlockPos)(nil), // 42: df.plugin.BlockPos + (*BlockState)(nil), // 43: df.plugin.BlockState + (*BBox)(nil), // 44: df.plugin.BBox + (*EntityRef)(nil), // 45: df.plugin.EntityRef } var file_actions_proto_depIdxs = []int32{ 2, // 0: df.plugin.ActionBatch.actions:type_name -> df.plugin.Action @@ -3020,58 +2865,52 @@ var file_actions_proto_depIdxs = []int32{ 27, // 25: df.plugin.Action.world_query_entities:type_name -> df.plugin.WorldQueryEntitiesAction 28, // 26: df.plugin.Action.world_query_players:type_name -> df.plugin.WorldQueryPlayersAction 29, // 27: df.plugin.Action.world_query_entities_within:type_name -> df.plugin.WorldQueryEntitiesWithinAction - 30, // 28: df.plugin.Action.world_query_viewers:type_name -> df.plugin.WorldQueryViewersAction - 37, // 29: df.plugin.TeleportAction.position:type_name -> df.plugin.Vec3 - 37, // 30: df.plugin.TeleportAction.rotation:type_name -> df.plugin.Vec3 - 38, // 31: df.plugin.SetGameModeAction.game_mode:type_name -> df.plugin.GameMode - 39, // 32: df.plugin.GiveItemAction.item:type_name -> df.plugin.ItemStack - 39, // 33: df.plugin.SetHeldItemAction.main:type_name -> df.plugin.ItemStack - 39, // 34: df.plugin.SetHeldItemAction.offhand:type_name -> df.plugin.ItemStack - 37, // 35: df.plugin.SetVelocityAction.velocity:type_name -> df.plugin.Vec3 - 40, // 36: df.plugin.AddEffectAction.effect_type:type_name -> df.plugin.EffectType - 40, // 37: df.plugin.RemoveEffectAction.effect_type:type_name -> df.plugin.EffectType - 41, // 38: df.plugin.PlaySoundAction.sound:type_name -> df.plugin.Sound - 37, // 39: df.plugin.PlaySoundAction.position:type_name -> df.plugin.Vec3 - 42, // 40: df.plugin.WorldSetDefaultGameModeAction.world:type_name -> df.plugin.WorldRef - 38, // 41: df.plugin.WorldSetDefaultGameModeAction.game_mode:type_name -> df.plugin.GameMode - 42, // 42: df.plugin.WorldSetDifficultyAction.world:type_name -> df.plugin.WorldRef - 43, // 43: df.plugin.WorldSetDifficultyAction.difficulty:type_name -> df.plugin.Difficulty - 42, // 44: df.plugin.WorldSetTickRangeAction.world:type_name -> df.plugin.WorldRef - 42, // 45: df.plugin.WorldSetBlockAction.world:type_name -> df.plugin.WorldRef - 44, // 46: df.plugin.WorldSetBlockAction.position:type_name -> df.plugin.BlockPos - 45, // 47: df.plugin.WorldSetBlockAction.block:type_name -> df.plugin.BlockState - 42, // 48: df.plugin.WorldPlaySoundAction.world:type_name -> df.plugin.WorldRef - 41, // 49: df.plugin.WorldPlaySoundAction.sound:type_name -> df.plugin.Sound - 37, // 50: df.plugin.WorldPlaySoundAction.position:type_name -> df.plugin.Vec3 - 42, // 51: df.plugin.WorldAddParticleAction.world:type_name -> df.plugin.WorldRef - 37, // 52: df.plugin.WorldAddParticleAction.position:type_name -> df.plugin.Vec3 - 0, // 53: df.plugin.WorldAddParticleAction.particle:type_name -> df.plugin.ParticleType - 45, // 54: df.plugin.WorldAddParticleAction.block:type_name -> df.plugin.BlockState - 42, // 55: df.plugin.WorldQueryEntitiesAction.world:type_name -> df.plugin.WorldRef - 42, // 56: df.plugin.WorldQueryPlayersAction.world:type_name -> df.plugin.WorldRef - 42, // 57: df.plugin.WorldQueryEntitiesWithinAction.world:type_name -> df.plugin.WorldRef - 46, // 58: df.plugin.WorldQueryEntitiesWithinAction.box:type_name -> df.plugin.BBox - 42, // 59: df.plugin.WorldQueryViewersAction.world:type_name -> df.plugin.WorldRef - 37, // 60: df.plugin.WorldQueryViewersAction.position:type_name -> df.plugin.Vec3 - 42, // 61: df.plugin.WorldEntitiesResult.world:type_name -> df.plugin.WorldRef - 47, // 62: df.plugin.WorldEntitiesResult.entities:type_name -> df.plugin.EntityRef - 42, // 63: df.plugin.WorldEntitiesWithinResult.world:type_name -> df.plugin.WorldRef - 46, // 64: df.plugin.WorldEntitiesWithinResult.box:type_name -> df.plugin.BBox - 47, // 65: df.plugin.WorldEntitiesWithinResult.entities:type_name -> df.plugin.EntityRef - 42, // 66: df.plugin.WorldPlayersResult.world:type_name -> df.plugin.WorldRef - 47, // 67: df.plugin.WorldPlayersResult.players:type_name -> df.plugin.EntityRef - 42, // 68: df.plugin.WorldViewersResult.world:type_name -> df.plugin.WorldRef - 37, // 69: df.plugin.WorldViewersResult.position:type_name -> df.plugin.Vec3 - 31, // 70: df.plugin.ActionResult.status:type_name -> df.plugin.ActionStatus - 32, // 71: df.plugin.ActionResult.world_entities:type_name -> df.plugin.WorldEntitiesResult - 34, // 72: df.plugin.ActionResult.world_players:type_name -> df.plugin.WorldPlayersResult - 33, // 73: df.plugin.ActionResult.world_entities_within:type_name -> df.plugin.WorldEntitiesWithinResult - 35, // 74: df.plugin.ActionResult.world_viewers:type_name -> df.plugin.WorldViewersResult - 75, // [75:75] is the sub-list for method output_type - 75, // [75:75] is the sub-list for method input_type - 75, // [75:75] is the sub-list for extension type_name - 75, // [75:75] is the sub-list for extension extendee - 0, // [0:75] is the sub-list for field type_name + 35, // 28: df.plugin.TeleportAction.position:type_name -> df.plugin.Vec3 + 35, // 29: df.plugin.TeleportAction.rotation:type_name -> df.plugin.Vec3 + 36, // 30: df.plugin.SetGameModeAction.game_mode:type_name -> df.plugin.GameMode + 37, // 31: df.plugin.GiveItemAction.item:type_name -> df.plugin.ItemStack + 37, // 32: df.plugin.SetHeldItemAction.main:type_name -> df.plugin.ItemStack + 37, // 33: df.plugin.SetHeldItemAction.offhand:type_name -> df.plugin.ItemStack + 35, // 34: df.plugin.SetVelocityAction.velocity:type_name -> df.plugin.Vec3 + 38, // 35: df.plugin.AddEffectAction.effect_type:type_name -> df.plugin.EffectType + 38, // 36: df.plugin.RemoveEffectAction.effect_type:type_name -> df.plugin.EffectType + 39, // 37: df.plugin.PlaySoundAction.sound:type_name -> df.plugin.Sound + 35, // 38: df.plugin.PlaySoundAction.position:type_name -> df.plugin.Vec3 + 40, // 39: df.plugin.WorldSetDefaultGameModeAction.world:type_name -> df.plugin.WorldRef + 36, // 40: df.plugin.WorldSetDefaultGameModeAction.game_mode:type_name -> df.plugin.GameMode + 40, // 41: df.plugin.WorldSetDifficultyAction.world:type_name -> df.plugin.WorldRef + 41, // 42: df.plugin.WorldSetDifficultyAction.difficulty:type_name -> df.plugin.Difficulty + 40, // 43: df.plugin.WorldSetTickRangeAction.world:type_name -> df.plugin.WorldRef + 40, // 44: df.plugin.WorldSetBlockAction.world:type_name -> df.plugin.WorldRef + 42, // 45: df.plugin.WorldSetBlockAction.position:type_name -> df.plugin.BlockPos + 43, // 46: df.plugin.WorldSetBlockAction.block:type_name -> df.plugin.BlockState + 40, // 47: df.plugin.WorldPlaySoundAction.world:type_name -> df.plugin.WorldRef + 39, // 48: df.plugin.WorldPlaySoundAction.sound:type_name -> df.plugin.Sound + 35, // 49: df.plugin.WorldPlaySoundAction.position:type_name -> df.plugin.Vec3 + 40, // 50: df.plugin.WorldAddParticleAction.world:type_name -> df.plugin.WorldRef + 35, // 51: df.plugin.WorldAddParticleAction.position:type_name -> df.plugin.Vec3 + 0, // 52: df.plugin.WorldAddParticleAction.particle:type_name -> df.plugin.ParticleType + 43, // 53: df.plugin.WorldAddParticleAction.block:type_name -> df.plugin.BlockState + 40, // 54: df.plugin.WorldQueryEntitiesAction.world:type_name -> df.plugin.WorldRef + 40, // 55: df.plugin.WorldQueryPlayersAction.world:type_name -> df.plugin.WorldRef + 40, // 56: df.plugin.WorldQueryEntitiesWithinAction.world:type_name -> df.plugin.WorldRef + 44, // 57: df.plugin.WorldQueryEntitiesWithinAction.box:type_name -> df.plugin.BBox + 40, // 58: df.plugin.WorldEntitiesResult.world:type_name -> df.plugin.WorldRef + 45, // 59: df.plugin.WorldEntitiesResult.entities:type_name -> df.plugin.EntityRef + 40, // 60: df.plugin.WorldEntitiesWithinResult.world:type_name -> df.plugin.WorldRef + 44, // 61: df.plugin.WorldEntitiesWithinResult.box:type_name -> df.plugin.BBox + 45, // 62: df.plugin.WorldEntitiesWithinResult.entities:type_name -> df.plugin.EntityRef + 40, // 63: df.plugin.WorldPlayersResult.world:type_name -> df.plugin.WorldRef + 45, // 64: df.plugin.WorldPlayersResult.players:type_name -> df.plugin.EntityRef + 30, // 65: df.plugin.ActionResult.status:type_name -> df.plugin.ActionStatus + 31, // 66: df.plugin.ActionResult.world_entities:type_name -> df.plugin.WorldEntitiesResult + 33, // 67: df.plugin.ActionResult.world_players:type_name -> df.plugin.WorldPlayersResult + 32, // 68: df.plugin.ActionResult.world_entities_within:type_name -> df.plugin.WorldEntitiesWithinResult + 69, // [69:69] is the sub-list for method output_type + 69, // [69:69] is the sub-list for method input_type + 69, // [69:69] is the sub-list for extension type_name + 69, // [69:69] is the sub-list for extension extendee + 0, // [0:69] is the sub-list for field type_name } func init() { file_actions_proto_init() } @@ -3108,7 +2947,6 @@ func file_actions_proto_init() { (*Action_WorldQueryEntities)(nil), (*Action_WorldQueryPlayers)(nil), (*Action_WorldQueryEntitiesWithin)(nil), - (*Action_WorldQueryViewers)(nil), } file_actions_proto_msgTypes[8].OneofWrappers = []any{} file_actions_proto_msgTypes[9].OneofWrappers = []any{} @@ -3117,12 +2955,11 @@ func file_actions_proto_init() { file_actions_proto_msgTypes[18].OneofWrappers = []any{} file_actions_proto_msgTypes[23].OneofWrappers = []any{} file_actions_proto_msgTypes[25].OneofWrappers = []any{} - file_actions_proto_msgTypes[30].OneofWrappers = []any{} - file_actions_proto_msgTypes[35].OneofWrappers = []any{ + file_actions_proto_msgTypes[29].OneofWrappers = []any{} + file_actions_proto_msgTypes[33].OneofWrappers = []any{ (*ActionResult_WorldEntities)(nil), (*ActionResult_WorldPlayers)(nil), (*ActionResult_WorldEntitiesWithin)(nil), - (*ActionResult_WorldViewers)(nil), } type x struct{} out := protoimpl.TypeBuilder{ @@ -3130,7 +2967,7 @@ func file_actions_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_actions_proto_rawDesc), len(file_actions_proto_rawDesc)), NumEnums: 1, - NumMessages: 36, + NumMessages: 34, NumExtensions: 0, NumServices: 0, }, diff --git a/proto/types/actions.proto b/proto/types/actions.proto index 087fde2..dbcfea0 100644 --- a/proto/types/actions.proto +++ b/proto/types/actions.proto @@ -46,7 +46,6 @@ message Action { WorldQueryEntitiesAction world_query_entities = 70; WorldQueryPlayersAction world_query_players = 71; WorldQueryEntitiesWithinAction world_query_entities_within = 72; - WorldQueryViewersAction world_query_viewers = 73; } } @@ -234,11 +233,6 @@ message WorldQueryEntitiesWithinAction { BBox box = 2; } -message WorldQueryViewersAction { - WorldRef world = 1; - Vec3 position = 2; -} - message ActionStatus { bool ok = 1; optional string error = 2; @@ -260,12 +254,6 @@ message WorldPlayersResult { repeated EntityRef players = 2; } -message WorldViewersResult { - WorldRef world = 1; - Vec3 position = 2; - repeated string viewer_uuids = 3; -} - message ActionResult { string correlation_id = 1; optional ActionStatus status = 2; @@ -273,6 +261,5 @@ message ActionResult { WorldEntitiesResult world_entities = 10; WorldPlayersResult world_players = 11; WorldEntitiesWithinResult world_entities_within = 12; - WorldViewersResult world_viewers = 13; } }