Stadium Block Rotation and Center defenitions

common/src/main/java/com/cobblemon/mod/common/mixin/client/GameRendererMixin.java

@@ -9,10 +9,20 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
+import com.cobblemon.mod.common.stadium.BattleCameraManagerClient;
+import com.cobblemon.mod.common.util.CameraExtensionsKt;
+import net.minecraft.client.Camera;
 import net.minecraft.client.DeltaTracker;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
+import net.minecraft.client.renderer.LightTexture;
+import net.minecraft.world.entity.Entity;
+import org.joml.Matrix4f;
+import org.joml.Quaternionf;
+import org.joml.Vector3f;
+import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
@@ -20,6 +30,17 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(GameRenderer.class)
 public class GameRendererMixin {
+    @Shadow @Final Minecraft minecraft;
+    @Shadow float renderDistance;
+    @Shadow @Final private LightTexture lightTexture;
+    @Shadow private boolean renderHand;
+
+    @Shadow private double getFov(Camera activeRenderInfo, float partialTicks, boolean useFOVSetting) { return 0.0; }
+    @Shadow public void resetProjectionMatrix(Matrix4f matrix) {}
+    @Shadow public Matrix4f getProjectionMatrix(double fov) { return new Matrix4f(); }
+    @Shadow private void renderItemInHand(Camera camera, float partialTick, Matrix4f projectionMatrix) {}
+    @Shadow public void pick(float partialTicks) {}
+
     @Unique
     long lastTime = -1;
 
@@ -42,4 +63,44 @@ public class GameRendererMixin {
         lastTime = newTime;
     }
 
+    @Inject(method = "renderLevel", at = @At(value = "HEAD"), cancellable = true)
+    public void renderLevel(DeltaTracker deltaTracker, CallbackInfo ci) {
+        if (BattleCameraManagerClient.INSTANCE.shouldUseStadiumCamera()) {
+            float f = deltaTracker.getGameTimeDeltaPartialTick(true);
+            this.lightTexture.updateLightTexture(f);
+            if (this.minecraft.getCameraEntity() == null) {
+                this.minecraft.setCameraEntity(this.minecraft.player);
+            }
+
+            this.minecraft.getProfiler().push("camera");
+            Camera stadiumCamera = new Camera();
+            Entity entity = (Entity) this.minecraft.player;
+            stadiumCamera.setup(this.minecraft.level, entity, true, false, 1.0F);
+
+            //adjust camera
+            BattleCameraManagerClient.INSTANCE.updateCameraData(f);
+            stadiumCamera.setPosition(BattleCameraManagerClient.INSTANCE.getCameraPosition());
+            Vector3f rotations = BattleCameraManagerClient.INSTANCE.getCameraRotation();
+            CameraExtensionsKt.setRotation(stadiumCamera, rotations.x, rotations.y, rotations.z);
+
+            this.renderDistance = (float)(this.minecraft.options.getEffectiveRenderDistance() * 16);
+            double d = this.getFov(stadiumCamera, f, true);
+            Matrix4f matrix4f = this.getProjectionMatrix(d);
+
+            this.resetProjectionMatrix(matrix4f);
+            Quaternionf quaternionf = stadiumCamera.rotation().conjugate(new Quaternionf());
+            Matrix4f matrix4f2 = (new Matrix4f()).rotation(quaternionf);
+            this.minecraft.levelRenderer.prepareCullFrustum(stadiumCamera.getPosition(), matrix4f2, this.getProjectionMatrix(Math.max(d, (double)(Integer)this.minecraft.options.fov().get())));
+            this.minecraft.levelRenderer.renderLevel(deltaTracker, false, stadiumCamera, (GameRenderer) (Object) this, this.lightTexture, matrix4f2, matrix4f);
+
+            this.minecraft.getProfiler().pop();
+
+            ci.cancel();
+        }
+    }
+
+    @Inject(method = "tick", at = @At(value = "TAIL"))
+    public void tick(CallbackInfo ci) {
+        BattleCameraManagerClient.INSTANCE.tickCameraManager();
+    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlockEntities.kt

@@ -37,6 +37,9 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
     @JvmField
     val PC: BlockEntityType<PCBlockEntity> = this.create("pc", BlockEntityType.Builder.of(::PCBlockEntity, CobblemonBlocks.PC).build(null))
 
+    @JvmField
+    val STADIUM: BlockEntityType<StadiumBlockEntity> = this.create("stadium_block", BlockEntityType.Builder.of(::StadiumBlockEntity, CobblemonBlocks.STADIUM_BLOCK).build(null))
+
     @JvmField
     val LECTERN: BlockEntityType<LecternBlockEntity> = this.create("lectern", BlockEntityType.Builder.of(::LecternBlockEntity, CobblemonBlocks.LECTERN).build(null))
 

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlocks.kt

@@ -482,6 +482,9 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val PC = create("pc", PCBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if ((it.getValue(PCBlock.ON) as Boolean) && (it.getValue(PCBlock.PART) == PCBlock.PCPart.TOP)) 10 else 0 }))
 
+    @JvmField
+    val STADIUM_BLOCK = create("stadium_block", StadiumBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F)))
+
     @JvmField
     val LECTERN = create("lectern", LecternBlock(BlockBehaviour.Properties.of().mapColor(MapColor.WOOD).instrument(NoteBlockInstrument.BASS).sound(SoundType.WOOD).strength(2.5F).ignitedByLava()))
 

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonItems.kt

@@ -619,6 +619,8 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val PC = blockItem("pc", CobblemonBlocks.PC)
     @JvmField
+    val STADIUM_BLOCK = blockItem("stadium_block", CobblemonBlocks.STADIUM_BLOCK)
+    @JvmField
     val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
     @JvmField
     val DISPLAY_CASE = blockItem("display_case", CobblemonBlocks.DISPLAY_CASE)

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonNetwork.kt

@@ -225,6 +225,10 @@ import com.cobblemon.mod.common.net.serverhandling.trade.ChangeTradeAcceptanceHa
 import com.cobblemon.mod.common.net.serverhandling.trade.OfferTradeHandler
 import com.cobblemon.mod.common.net.serverhandling.trade.PerformTradeHandler
 import com.cobblemon.mod.common.net.serverhandling.trade.UpdateTradeOfferHandler
+import com.cobblemon.mod.common.stadium.BattleCamerasSyncPacket
+import com.cobblemon.mod.common.stadium.BattleCameraSetupHandler
+import com.cobblemon.mod.common.stadium.BattleCameraPacket
+import com.cobblemon.mod.common.stadium.BattleCameraManagersSyncPacket
 import com.cobblemon.mod.common.util.server
 import net.minecraft.server.level.ServerPlayer
 
@@ -382,6 +386,8 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(SeasoningRegistrySyncPacket.ID, SeasoningRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(FlowRegistrySyncPacket.ID, FlowRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(CosmeticItemAssignmentSyncPacket.ID, CosmeticItemAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(BattleCamerasSyncPacket.ID, BattleCamerasSyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(BattleCameraManagersSyncPacket.ID, BattleCameraManagersSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(MarkRegistrySyncPacket.ID, MarkRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
 
         // Effects
@@ -442,6 +448,9 @@ object CobblemonNetwork {
         // Debug / cheats
         list.add(PacketRegisterInfo(CalculateSeatPositionsPacket.ID, CalculateSeatPositionsPacket::decode, CalculateSeatPositionsHandler))
 
+        // Stadium packets
+        list.add(PacketRegisterInfo(BattleCameraPacket.ID, BattleCameraPacket::decode, BattleCameraSetupHandler))
+
         // Riding
         list.add(PacketRegisterInfo(ClientboundUpdateRidingStatePacket.ID, ClientboundUpdateRidingStatePacket::decode, ClientboundUpdateRidingStateHandler))
 

common/src/main/kotlin/com/cobblemon/mod/common/CobblemonPoiTypes.kt

@@ -39,6 +39,10 @@ object CobblemonPoiTypes: PlatformRegistry<Registry<PoiType>, ResourceKey<Regist
     val INCENSE_SWEET_KEY: ResourceKey<PoiType> = createKey("saccharine_honey_log")
     @JvmField
     val INCENSE_SWEET = create(INCENSE_SWEET_KEY.location().path, PoiType(getBlockStates(CobblemonBlocks.INCENSE_SWEET), 0, 1))
+    @JvmField
+    val STADIUM_BLOCK_KEY: ResourceKey<PoiType> = createKey("stadium_block")
+    @JvmField
+    val STADIUM_BLOCK = create(STADIUM_BLOCK_KEY.location().path, PoiType(getBlockStates(CobblemonBlocks.STADIUM_BLOCK), 0, 1))
 
     private fun createKey(string: String): ResourceKey<PoiType> = ResourceKey.create(Registries.POINT_OF_INTEREST_TYPE, cobblemonResource(string))
 

common/src/main/kotlin/com/cobblemon/mod/common/block/StadiumBlock.kt

@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.api.text.red
+import com.cobblemon.mod.common.api.text.text
+import com.cobblemon.mod.common.block.entity.StadiumBlockEntity
+import net.minecraft.core.BlockPos
+import net.minecraft.core.Direction
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.InteractionResult
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.context.BlockPlaceContext
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.BaseEntityBlock
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.HorizontalDirectionalBlock
+import net.minecraft.world.level.block.Mirror
+import net.minecraft.world.level.block.RenderShape
+import net.minecraft.world.level.block.Rotation
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.phys.BlockHitResult
+
+class StadiumBlock(properties: Properties): BaseEntityBlock(properties) {
+    companion object {
+        val CODEC = simpleCodec(::StadiumBlock)
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any().setValue(HorizontalDirectionalBlock.FACING, Direction.NORTH))
+    }
+
+    override fun codec() = CODEC
+
+    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity {
+        return StadiumBlockEntity(pos, state)
+    }
+
+    override fun getStateForPlacement(blockPlaceContext: BlockPlaceContext): BlockState {
+        return this.defaultBlockState().setValue(HorizontalDirectionalBlock.FACING, blockPlaceContext.horizontalDirection)
+    }
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HorizontalDirectionalBlock.FACING)
+    }
+
+    override fun rotate(blockState: BlockState, rotation: Rotation): BlockState {
+        return blockState.setValue(
+            HorizontalDirectionalBlock.FACING, rotation.rotate(blockState.getValue(
+                HorizontalDirectionalBlock.FACING)))
+    }
+
+    override fun mirror(blockState: BlockState, mirror: Mirror): BlockState {
+        return blockState.rotate(mirror.getRotation(blockState.getValue(HorizontalDirectionalBlock.FACING)))
+    }
+
+    override fun onRemove(state: BlockState, world: Level, pos: BlockPos, newState: BlockState, moved: Boolean) {
+        if (!state.`is`(newState.block)) super.onRemove(state, world, pos, newState, moved)
+    }
+
+    //TODO: override getTicker
+
+    override fun getRenderShape(state: BlockState) = RenderShape.MODEL
+
+    override fun useWithoutItem(
+        state: BlockState,
+        world: Level,
+        pos: BlockPos,
+        player: Player,
+        hitResult: BlockHitResult
+    ): InteractionResult {
+        if (player !is ServerPlayer) return InteractionResult.SUCCESS
+
+        val blockEntity = world.getBlockEntity(pos)
+        if (blockEntity !is StadiumBlockEntity) return InteractionResult.SUCCESS
+
+        player.sendSystemMessage(text("Adding you to Battle").red())
+        return InteractionResult.SUCCESS
+    }
+
+    /*
+    override fun useWithoutItem(
+        blockState: BlockState,
+        world: Level,
+        blockPos: BlockPos,
+        player: Player,
+        blockHitResult: BlockHitResult
+    ): InteractionResult {
+        if (player !is ServerPlayer) return InteractionResult.SUCCESS
+
+        val blockEntity = world.getBlockEntity(blockPos)
+        if (blockEntity !is StadiumBlockEntity) return InteractionResult.SUCCESS
+
+        // Toggle isInUse state
+        blockEntity.isInUse = !blockEntity.isInUse
+
+        // debug
+        val activateMessage = if (blockEntity.isInUse) "Stadium Activated!" else "Stadium Deactivated!"
+        player.sendSystemMessage(text(activateMessage).red())
+
+        if (blockEntity.isInUse) {
+            // Generate flight path when activated
+            blockEntity.generateFlightPath(world, radiusX = 5.0, radiusZ = 3.0, height = 10.0, steps = 20)
+
+        } else {
+            // Clear path when deactivated
+            blockEntity.pathPoints.clear()
+        }
+
+        val message = "Stadium Pos: " + blockEntity.blockPos +
+                "\nPlayer 1 Pos: " + blockEntity.getPlayer1Pos() +
+                "\nPoke 1 Pos: " + blockEntity.getPoke1Pos() +
+                "\nPlayer 2 Pos: " + blockEntity.getPlayer2Pos() +
+                "\nPoke 2 Pos: " + blockEntity.getPoke2Pos()
+        player.sendSystemMessage(text(message).red())
+
+        blockEntity.setChanged()
+        world.sendBlockUpdated(blockPos, blockState, blockState, Block.UPDATE_CLIENTS)
+
+        return InteractionResult.SUCCESS
+    }
+    */
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/entity/StadiumBlockEntity.kt

@@ -0,0 +1,149 @@
+package com.cobblemon.mod.common.block.entity
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.client.render.models.blockbench.drone.DroneState
+import com.cobblemon.mod.common.stadium.StadiumSingleBattle
+import net.minecraft.core.BlockPos
+import net.minecraft.core.HolderLookup
+import net.minecraft.nbt.CompoundTag
+import net.minecraft.nbt.ListTag
+import net.minecraft.network.protocol.Packet
+import net.minecraft.network.protocol.game.ClientGamePacketListener
+import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket
+import net.minecraft.network.protocol.game.ClientboundPlayerLookAtPacket
+import net.minecraft.network.protocol.game.ClientboundSetCarriedItemPacket
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.level.Level
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.phys.Vec3
+import org.joml.Vector3f
+
+class StadiumBlockEntity(
+    pos: BlockPos,
+    blockState: BlockState
+): BlockEntity(
+    CobblemonBlockEntities.STADIUM,
+    pos,
+    blockState
+) {
+    /** Battle area center is bottom center */
+    var battleArea = Vector3f(10f,10f,10f) // Width, Height, Length
+    var battleCenter = Vec3.ZERO // Local
+    var battleRot = 70F
+
+    fun positionInBattleArea(targetPos: Vector3f) : Boolean {
+        val adjustedPos = targetPos.sub(blockPos.bottomCenter.toVector3f()).sub(battleCenter.toVector3f())
+        if (targetPos.y < 0f || targetPos.y >= battleArea.y) return false
+        adjustedPos.rotateY(-battleRot)
+        if (targetPos.x < -battleArea.x || targetPos.x > battleArea.x) return false
+        if (targetPos.z < -battleArea.z || targetPos.z > battleArea.z) return false
+        return true
+    }
+
+    /*
+    var isInUse = false
+
+    val droneState = DroneState()
+
+    val pathPoints: MutableList<Vec3> = mutableListOf()
+
+    fun generateFlightPath(world: Level, radiusX: Double, radiusZ: Double, height: Double, steps: Int) {
+        pathPoints.clear()
+
+        for (i in 0 until steps) {
+            val angle = (i.toDouble() / steps) * Math.PI * 2
+            val xOffset = radiusX * Math.cos(angle)
+            val zOffset = radiusZ * Math.sin(angle)
+
+            val basePos = Vec3(blockPos.x + xOffset, blockPos.y + height, blockPos.z + zOffset)
+            val adjustedPos = getValidPoint(world, basePos)
+
+            pathPoints.add(adjustedPos)
+        }
+    }
+
+    private fun getValidPoint(world: Level, start: Vec3): Vec3 {
+        val maxHeight = 40 // Max height for drone path
+        val stepHeight = 1.0 // Step size for raycast
+
+        var adjustedHeight = start.y
+        for (h in 0..maxHeight step stepHeight.toInt()) {
+            val checkPos = BlockPos(start.x.toInt(), start.y.toInt() - h, start.z.toInt()) // Convert to BlockPos
+            if (!world.getBlockState(checkPos).isAir) { // Check if block is solid
+                return Vec3(start.x, start.y - h - 1, start.z) // Adjust position
+            }
+        }
+        return start // No obstruction found
+    }
+
+
+    fun getPlayer1Pos(): BlockPos {
+        return blockPos.north(10)
+    }
+    fun getPlayer2Pos(): BlockPos {
+        return blockPos.south(10)
+    }
+    fun getPoke1Pos(): BlockPos {
+        return blockPos.north(5)
+    }
+    fun getPoke2Pos(): BlockPos {
+        return blockPos.south(5)
+    }
+
+
+
+
+    /**
+     * Saves data to NBT.
+     */
+    override fun saveAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
+        super.saveAdditional(tag, registries)
+
+        // Save the isInUse state
+        tag.putBoolean("IsInUse", isInUse)
+
+        // Save path points
+        val pathTag = ListTag()
+        for (point in pathPoints) {
+            val pointTag = CompoundTag()
+            pointTag.putDouble("x", point.x)
+            pointTag.putDouble("y", point.y)
+            pointTag.putDouble("z", point.z)
+            pathTag.add(pointTag)
+        }
+        tag.put("PathPoints", pathTag)
+    }
+
+    /**
+     * Loads data from NBT.
+     */
+    override fun loadAdditional(tag: CompoundTag, registries: HolderLookup.Provider) {
+        super.loadAdditional(tag, registries)
+
+        // Load the isInUse state
+        isInUse = tag.getBoolean("IsInUse")
+
+        // Load path points
+        pathPoints.clear()
+        val pathTag = tag.getList("PathPoints", 10) // 10 is the ID for CompoundTag
+        for (i in 0 until pathTag.size) {
+            val pointTag = pathTag.getCompound(i)
+            val point = Vec3(pointTag.getDouble("x"), pointTag.getDouble("y"), pointTag.getDouble("z"))
+            pathPoints.add(point)
+        }
+    }
+
+    override fun getUpdatePacket(): Packet<ClientGamePacketListener>? {
+        //println("getUpdatePacket called for NestBlockEntity at $blockPos with egg: $eggComponent")
+        return ClientboundBlockEntityDataPacket.create(this)
+    }
+
+    override fun getUpdateTag(registryLookup: HolderLookup.Provider): CompoundTag {
+        val tag = saveWithoutMetadata(registryLookup)
+        //println("getUpdateTag called for NestBlockEntity at $blockPos with tag: $tag")
+        return tag
+    }
+
+    */
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/CobblemonClient.kt

@@ -53,6 +53,7 @@ import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext
+import com.cobblemon.mod.common.stadium.BattleCameraManagerClient
 import com.cobblemon.mod.common.util.isLookingAt
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
@@ -106,6 +107,7 @@ object CobblemonClient {
         CobblemonDataProvider.canReload = true
         DeferredRenderer.clearAll()
         ClientPlayerIcon.clear()
+        BattleCameraManagerClient.onLogout()
     }
 
     fun initialize(implementation: CobblemonClientImplementation) {
@@ -255,6 +257,8 @@ object CobblemonClient {
             CobblemonBlocks.SKY_TUMBLESTONE_CLUSTER,
             CobblemonBlocks.GIMMIGHOUL_CHEST,
             CobblemonBlocks.DISPLAY_CASE,
+            CobblemonBlocks.LECTERN,
+            CobblemonBlocks.STADIUM_BLOCK,
             CobblemonBlocks.SACCHARINE_DOOR,
             CobblemonBlocks.SACCHARINE_TRAPDOOR,
             CobblemonBlocks.SACCHARINE_SIGN,
@@ -273,7 +277,6 @@ object CobblemonClient {
             CobblemonBlocks.RED_CAMPFIRE_POT,
             CobblemonBlocks.WHITE_CAMPFIRE_POT,
             CobblemonBlocks.YELLOW_CAMPFIRE_POT
-
         )
 
         this.createBoatModelLayers()
@@ -311,6 +314,7 @@ object CobblemonClient {
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.GILDED_CHEST, ::GildedChestBlockRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.DISPLAY_CASE, ::DisplayCaseRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.LECTERN, ::LecternBlockEntityRenderer)
+        this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.STADIUM, ::StadiumBlockRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.CAMPFIRE, ::CampfireBlockEntityRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.LURE_CAKE, ::CakeBlockEntityRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.POKE_CAKE, ::CakeBlockEntityRenderer)

common/src/main/kotlin/com/cobblemon/mod/common/client/render/block/StadiumBlockRenderer.kt

@@ -0,0 +1,238 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.render.block
+
+import com.cobblemon.mod.common.block.entity.StadiumBlockEntity
+import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
+import com.mojang.blaze3d.vertex.PoseStack
+import net.minecraft.client.renderer.MultiBufferSource
+import net.minecraft.client.renderer.RenderType
+import net.minecraft.client.renderer.blockentity.BlockEntityRenderer
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider
+import net.minecraft.util.Mth
+import org.joml.Vector3f
+import org.joml.Vector3i
+
+class StadiumBlockRenderer(ctx: BlockEntityRendererProvider.Context) : BlockEntityRenderer<StadiumBlockEntity> {
+    val context = RenderContext().also {
+        it.put(RenderContext.DO_QUIRKS, false)
+        it.put(RenderContext.RENDER_STATE, RenderContext.RenderState.BLOCK)
+    }
+
+    private var pathIndex = 0
+    private var animationTime = 0.0
+    private val droneSpeed = 0.10
+
+    override fun render(
+        blockEntity: StadiumBlockEntity,
+        partialTick: Float,
+        poseStack: PoseStack,
+        bufferSource: MultiBufferSource,
+        packedLight: Int,
+        packedOverlay: Int
+    ) {
+        val vertexConsumer = bufferSource.getBuffer(RenderType.LINES)
+        val pose = poseStack.last()
+
+        val center = Vector3f(0.5f,0f,0.5f).add(blockEntity.battleCenter.toVector3f()) // 0,0,0 is corner of block, we make center be bottom center
+        val rotation = blockEntity.battleRot / (180f * Mth.PI)
+        val widthOffset = blockEntity.battleArea.x / 2f
+        val lengthOffset = blockEntity.battleArea.z / 2f
+        val height = blockEntity.battleArea.y
+
+        fun drawLine(point1: Vector3i, point2: Vector3i) {
+            val f = if (point1.x == 0) -widthOffset else widthOffset
+            val g = if (point1.y == 0) 0f else height
+            val h = if (point1.z == 0) -lengthOffset else lengthOffset
+            val i = if (point2.x == 0) -widthOffset else widthOffset
+            val j = if (point2.y == 0) 0f else height
+            val k = if (point2.z == 0) -lengthOffset else lengthOffset
+
+            val position1 = Vector3f(f, g, h).rotateY(rotation).add(center)
+            val position2 = Vector3f(i, j, k).rotateY(rotation).add(center)
+            val normal = Vector3f(position2).sub(position1).normalize()
+
+            vertexConsumer.addVertex(pose, position1).setColor(0.9f, 0.9f, 0.9f, 1f).setNormal(normal.x, normal.y, normal.z)
+            vertexConsumer.addVertex(pose, position2).setColor(0.9f, 0.9f, 0.9f, 1f).setNormal(normal.x, normal.y, normal.z)
+        }
+
+        drawLine(Vector3i(0,0,0), Vector3i(1,0,0))
+        drawLine(Vector3i(0,0,0), Vector3i(0,1,0))
+        drawLine(Vector3i(0,0,0), Vector3i(0,0,1))
+        drawLine(Vector3i(1,0,0), Vector3i(1,1,0))
+        drawLine(Vector3i(1,0,0), Vector3i(1,0,1))
+        drawLine(Vector3i(0,0,1), Vector3i(1,0,1))
+        drawLine(Vector3i(0,0,1), Vector3i(0,1,1))
+        drawLine(Vector3i(0,0,0), Vector3i(0,0,0))
+        drawLine(Vector3i(0,1,0), Vector3i(1,1,0))
+        drawLine(Vector3i(0,1,0), Vector3i(0,1,1))
+        drawLine(Vector3i(1,1,0), Vector3i(1,1,1))
+        drawLine(Vector3i(0,1,1), Vector3i(1,1,1))
+        drawLine(Vector3i(1,0,1), Vector3i(1,1,1))
+    }
+
+    /*
+    override fun render(
+            blockEntity: StadiumBlockEntity,
+            tickDelta: Float,
+            poseStack: PoseStack,
+            multiBufferSource: MultiBufferSource,
+            light: Int,
+            overlay: Int
+    ) {
+        val blockState = blockEntity.blockState
+        val yRot = blockState.getValue(HorizontalDirectionalBlock.FACING).toYRot()
+
+        val isClientSide = blockEntity.level?.isClientSide == true
+        if (!isClientSide) return
+
+        val stadiumBlockState = blockEntity.level?.getBlockState(blockEntity.blockPos) ?: return
+        if (stadiumBlockState.block != CobblemonBlocks.STADIUM) {
+            return
+        }
+
+        val droneState = blockEntity.droneState
+
+
+        poseStack.pushPose()
+        if (blockEntity.isInUse) {
+            if (blockEntity.pathPoints.isEmpty()) {
+
+                poseStack.popPose()
+                return
+            }
+
+            spawnDebugParticles(blockEntity) // debug particles
+
+            // Center the drone at the block's center
+            poseStack.translate(0.5, -3.0, 0.5)
+            //poseStack.mulPose(Axis.XP.rotationDegrees(180F))
+            //poseStack.mulPose(Axis.YP.rotationDegrees(180F))
+
+            val points = blockEntity.pathPoints
+            val nextIndex = (pathIndex + 1) % points.size
+
+            val currentPoint = points[pathIndex]
+            val nextPoint = points[nextIndex]
+
+            animationTime += tickDelta * droneSpeed
+            if (animationTime >= 1.0) {
+                animationTime = 0.0
+                pathIndex = nextIndex
+            }
+
+            val interpolatedPos = currentPoint.lerp(nextPoint, animationTime.toDouble())
+
+            println("DEBUG: Drone moving between points:")
+            println("  - Current Point: ${currentPoint}")
+            println("  - Next Point: ${nextPoint}")
+            println("  - Interpolated Position: $interpolatedPos")
+
+            poseStack.translate(interpolatedPos.x - blockEntity.blockPos.x,
+                    interpolatedPos.y - blockEntity.blockPos.y,
+                    interpolatedPos.z - blockEntity.blockPos.z)
+
+            println("DEBUG: Drone position interpolated to: $interpolatedPos")
+
+            poseStack.mulPose(Axis.YP.rotationDegrees(-yRot))
+            poseStack.mulPose(Axis.ZP.rotationDegrees(180F)) // flip the drone right side up
+
+            renderDrone(droneState, "sleep", tickDelta, poseStack, 1.0F, multiBufferSource, light)
+        } else {
+            val yRot = blockState.getValue(HorizontalDirectionalBlock.FACING).toYRot()
+
+            val poseEntry = poseStack.last()
+            val matrix = poseEntry.pose()
+
+            poseStack.translate(0.5, 0.0, 0.5)
+            poseStack.mulPose(Axis.YP.rotationDegrees(yRot))
+
+            val posX = matrix.m03()
+            val posY = matrix.m13()
+            val posZ = matrix.m23()
+
+            println("DEBUG: Drone is NOT in use. Rendering default position at: x=$posX, y=$posY, z=$posZ")
+
+            poseStack.mulPose(Axis.ZP.rotationDegrees(180F))
+            renderDrone(droneState, "sleep", tickDelta, poseStack, 1.0F, multiBufferSource, light)
+        }
+
+        poseStack.popPose()
+    }
+
+    fun renderDrone(
+        state: DroneState,
+        pose: String,
+        tickDelta: Float,
+        poseStack: PoseStack,
+        scale: Float = 1F,
+        multiBufferSource: MultiBufferSource,
+        light: Int,
+    ) {
+        state.updatePartialTicks(tickDelta)
+
+        val droneResource: ResourceLocation = cobblemonResource("rotom_drone")
+
+        val model = VaryingModelRepository.getPoser(droneResource, state) as DroneModel
+        val texture = VaryingModelRepository.getTexture(droneResource, state)
+
+        val buffer = multiBufferSource.getBuffer(RenderType.entityCutout(texture))
+        model.bufferProvider = multiBufferSource
+
+        state.currentModel = model
+        state.setPose(pose)
+
+        model.context = context
+        context.put(RenderContext.TEXTURE, texture)
+        context.put(RenderContext.RENDER_STATE, RenderContext.RenderState.BLOCK)
+        context.put(RenderContext.POSABLE_STATE, state)
+
+        model.applyAnimations(
+            entity = null,
+            state = state,
+            headYaw = 0F,
+            headPitch = 0F,
+            limbSwing = 0F,
+            limbSwingAmount = 0F,
+            ageInTicks = state.animationSeconds * 20
+        )
+
+        poseStack.scale(scale, scale, scale)
+
+        // TODO: Make drone lighting dynamic (simply using the light arg makes the drone always appear dark)
+        model.withLayerContext(multiBufferSource, state, VaryingModelRepository.getLayers(droneResource, state)) {
+            model.render(context, poseStack, buffer, 200, OverlayTexture.NO_OVERLAY, -0x1)
+        }
+        model.setDefault()
+    }
+
+    private fun spawnDebugParticles(blockEntity: StadiumBlockEntity) {
+        val world = blockEntity.level ?: return
+        if (!world.isClientSide) return // Only run on the client-side
+
+        for (point in blockEntity.pathPoints) {
+            world.addParticle(
+                    net.minecraft.core.particles.ParticleTypes.FLAME, // Test particle (changeable)
+                    point.x, point.y, point.z, // Position of the particle
+                    0.0, 0.02, 0.0 // Slight upward motion
+            )
+        }
+
+        // Spawn a special particle at the next interpolation point
+        if (blockEntity.pathPoints.isNotEmpty()) {
+            val nextPoint = blockEntity.pathPoints[(pathIndex + 1) % blockEntity.pathPoints.size]
+            world.addParticle(
+                    net.minecraft.core.particles.ParticleTypes.END_ROD, // Different effect for next point
+                    nextPoint.x, nextPoint.y, nextPoint.z,
+                    0.0, 0.05, 0.0
+            )
+        }
+    }
+    */
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/drone/DroneModel.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2025 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.render.models.blockbench.drone
+
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableModel
+import com.cobblemon.mod.common.client.render.models.blockbench.animation.PoseAnimation
+import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
+import com.cobblemon.mod.common.client.render.models.blockbench.quirk.ModelQuirk
+import com.cobblemon.mod.common.entity.PoseType
+import com.google.gson.annotations.SerializedName
+import net.minecraft.client.model.geom.ModelPart
+
+/**
+ * A model for rendering the Rotom drone used by the stadium block.
+ *
+ * @author Flarkinater
+ * @since February 14th, 2025
+ */
+class DroneModel(root: Bone) : PosableModel(root) {
+    @Transient
+    @SerializedName("So this name can be literally anything, huh?")
+    override val rootPart = (root as ModelPart).registerChildWithAllChildren(root.children.entries.first().key)
+    var droneAnimations: Array<PoseAnimation> = emptyArray()
+    var droneQuirks: Array<ModelQuirk<*>> = emptyArray()
+
+    override fun registerPoses() {
+        registerPose(
+            poseType = PoseType.SLEEP,
+            animations = droneAnimations,
+            quirks = droneQuirks
+        )
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/drone/DroneState.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright (C) 2025 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.client.render.models.blockbench.drone
+
+import com.cobblemon.mod.common.api.scheduling.SchedulingTracker
+import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
+
+/**
+ * State for a drone Rotom attached to a stadium block.
+ *
+ * @author Flarkinater
+ * @since February 12th, 2025
+ */
+class DroneState() : PosableState() {
+    init {
+        setPose("sleep")
+        age = 0
+        currentPartialTicks = 0F
+    }
+
+    override fun getEntity() = null
+
+    override fun updatePartialTicks(partialTicks: Float) {
+        currentPartialTicks += partialTicks / 2
+    }
+
+    override val schedulingTracker = SchedulingTracker()
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/repository/VaryingModelRepository.kt

@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.*
 import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animation.BedrockAnimationRepository
 import com.cobblemon.mod.common.client.render.models.blockbench.blockentity.BlockEntityModel
 import com.cobblemon.mod.common.client.render.models.blockbench.fossil.FossilModel
+import com.cobblemon.mod.common.client.render.models.blockbench.drone.DroneModel
 import com.cobblemon.mod.common.client.render.models.blockbench.pokeball.AncientPokeBallModel
 import com.cobblemon.mod.common.client.render.models.blockbench.pokeball.BeastBallModel
 import com.cobblemon.mod.common.client.render.models.blockbench.pokeball.PokeBallModel
@@ -79,12 +80,14 @@ object VaryingModelRepository {
         "poke_balls",
         "generic",
         "block_entities",
+        "drone"
     )
 
     val poserDirectories: List<Pair<String, Class<out PosableModel>>> = listOf(
         "bedrock/posers" to PosableModel::class.java,
         "bedrock/pokemon/posers" to PokemonPosableModel::class.java,
         "bedrock/fossils/posers" to FossilModel::class.java,
+        "bedrock/drone/posers" to DroneModel::class.java,
         "bedrock/block_entities/posers" to BlockEntityModel::class.java,
         "bedrock/npcs/posers" to PosableModel::class.java,
         "bedrock/poke_balls/posers" to PosableModel::class.java,
@@ -116,6 +119,7 @@ object VaryingModelRepository {
             .registerTypeAdapter(PosableModel::class.java, JsonModelAdapter(::PosableModel))
             .registerTypeAdapter(PokemonPosableModel::class.java, JsonModelAdapter(::PokemonPosableModel))
             .registerTypeAdapter(FossilModel::class.java, JsonModelAdapter(::FossilModel))
+            .registerTypeAdapter(DroneModel::class.java, JsonModelAdapter(::DroneModel))
             .registerTypeAdapter(BlockEntityModel::class.java, JsonModelAdapter(::BlockEntityModel))
             .registerTypeAdapter(Pose::class.java, PoseAdapter { JsonModelAdapter.model!! })
             .registerTypeAdapter(ModelPartTransformation::class.java, ModelPartTransformationAdapter)

common/src/main/kotlin/com/cobblemon/mod/common/data/CobblemonDataProvider.kt

@@ -50,6 +50,8 @@ import com.cobblemon.mod.common.net.messages.client.data.UnlockReloadPacket
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokemon.SpeciesAdditions
 import com.cobblemon.mod.common.pokemon.properties.PropertiesCompletionProvider
+import com.cobblemon.mod.common.stadium.BattleCameraManagers
+import com.cobblemon.mod.common.stadium.BattleCameras
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.ifClient
 import com.cobblemon.mod.common.util.server
@@ -98,6 +100,8 @@ object CobblemonDataProvider : DataProvider {
         this.register(CobblemonCosmeticItems)
         this.register(CobblemonFlows)
         this.register(CobblemonUnlockableWallpapers)
+        this.register(BattleCameras)
+        this.register(BattleCameraManagers)
         this.register(Marks)
 
         CobblemonSpawnPools.load()

common/src/main/kotlin/com/cobblemon/mod/common/item/group/CobblemonItemGroups.kt

@@ -242,6 +242,7 @@ object CobblemonItemGroups {
         entries.accept(CobblemonItems.PC)
         entries.accept(CobblemonItems.HEALING_MACHINE)
         entries.accept(CobblemonItems.PASTURE)
+        entries.accept(CobblemonItems.STADIUM_BLOCK)
 
         entries.accept(CobblemonItems.GILDED_CHEST)
         entries.accept(CobblemonItems.YELLOW_GILDED_CHEST)

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraEntry.kt

@@ -0,0 +1,192 @@
+package com.cobblemon.mod.common.stadium
+
+import com.bedrockk.molang.Expression
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.cobblemon.mod.common.util.*
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.util.Mth
+import net.minecraft.world.phys.Vec3
+import org.joml.Vector3f
+import java.lang.reflect.Type
+import kotlin.math.abs
+import kotlin.math.atan
+import kotlin.math.atan2
+
+class BattleCameraEntry(
+    var id: ResourceLocation,
+    val length: Double = 0.0,
+    val positionTimeline: MutableMap<String, CameraKeyFrame> = mutableMapOf(),
+    val targetPositionTimeline: MutableMap<String, CameraKeyFrame> = mutableMapOf(),
+    val move: String = ""
+) {
+    fun resolvePosition(time: Double, yRot: Float): Vec3 {
+        return resolvePosition(time, positionTimeline).yRot(yRot * (Mth.PI/180))
+    }
+
+    private fun resolvePosition(time: Double, map: MutableMap<String, CameraKeyFrame>): Vec3 {
+        val runtime = BattleCameraManagerClient.runtime
+        runtime.environment.setSimpleVariable("anim_time", DoubleValue(time))
+        var frame1: CameraKeyFrame? = null
+        var frame2: CameraKeyFrame? = null
+        var time1 = -1.0
+        var time2 = -1.0
+        for (keyframe in map) {
+            if (time >= keyframe.key.toDouble()) {
+                if (time1 == -1.0 || abs(time - keyframe.key.toDouble()) < abs(time - time1)) {
+                    frame1 = keyframe.value
+                    time1 = keyframe.key.toDouble()
+                }
+            }
+            if (time < keyframe.key.toDouble()) {
+                if (time2 == -1.0 || abs(time - keyframe.key.toDouble()) < abs(time - time2)) {
+                    frame2 = keyframe.value
+                    time2 = keyframe.key.toDouble()
+                }
+            }
+        }
+        val difference = (time - time1) / (time2 - time1)
+
+        if (frame1 != null && frame1.interpolation == CameraInterpolation.STEP) {
+            frame2 = null
+        }
+
+        if (frame1 == null && frame2 == null) {
+            return Vec3.ZERO
+        }
+        else if (frame1 == null) {
+            frame2!!
+            val x = runtime.resolveDouble(frame2.x)
+            val y = runtime.resolveDouble(frame2.y)
+            val z = runtime.resolveDouble(frame2.z)
+            return Vec3(x,y,z)
+        }
+        else if (frame2 == null) {
+            val x = runtime.resolveDouble(frame1.x)
+            val y = runtime.resolveDouble(frame1.y)
+            val z = runtime.resolveDouble(frame1.z)
+            return Vec3(x,y,z)
+        }
+        else {
+            val x1 = runtime.resolveDouble(frame1.x)
+            val y1 = runtime.resolveDouble(frame1.y)
+            val z1 = runtime.resolveDouble(frame1.z)
+            val vec1 = Vec3(x1,y1,z1)
+            val x2 = runtime.resolveDouble(frame2.x)
+            val y2 = runtime.resolveDouble(frame2.y)
+            val z2 = runtime.resolveDouble(frame2.z)
+            val vec2 = Vec3(x2,y2,z2)
+            return vec1.lerp(vec2, difference)
+        }
+    }
+
+    fun resolveRotation(time: Double, yRot: Float): Vector3f {
+        val position = resolvePosition(time, positionTimeline).yRot(yRot * (Mth.PI/180))
+        val target = resolvePosition(time, targetPositionTimeline).yRot(yRot * (Mth.PI/180))
+        val offset = target.subtract(position)
+        val xRot = -atan(offset.y.toFloat()/offset.horizontalDistance().toFloat()) * (180F / Math.PI.toFloat())
+        val yRot = -atan2(offset.x.toFloat(),offset.z.toFloat()) * (180F / Math.PI.toFloat())
+        return Vector3f(xRot, yRot, 0.0F)
+    }
+
+    fun encode(buf: RegistryFriendlyByteBuf) {
+        buf.writeIdentifier(id)
+        buf.writeDouble(length)
+        buf.writeMap(positionTimeline, {_, key -> buf.writeString(key)}, {_, value ->
+            buf.writeString(value.x.getString())
+            buf.writeString(value.y.getString())
+            buf.writeString(value.z.getString())
+            buf.writeEnum(value.interpolation)
+        })
+        buf.writeMap(targetPositionTimeline, {_, key -> buf.writeString(key)}, {_, value ->
+            buf.writeString(value.x.getString())
+            buf.writeString(value.y.getString())
+            buf.writeString(value.z.getString())
+            buf.writeEnum(value.interpolation)
+        })
+        buf.writeString(move)
+    }
+
+    companion object {
+        fun decode(buf: RegistryFriendlyByteBuf) : BattleCameraEntry {
+            val id = buf.readIdentifier()
+            val length = buf.readDouble()
+            val positionTimeline = buf.readMap({_ -> buf.readString()}, {_ ->
+                CameraKeyFrame(buf.readString().asExpression(), buf.readString().asExpression(), buf.readString().asExpression(), buf.readEnum(CameraInterpolation::class.java))
+            }).toMutableMap()
+            val targetPositionTimeline = buf.readMap({_ -> buf.readString()}, {_ ->
+                CameraKeyFrame(buf.readString().asExpression(), buf.readString().asExpression(), buf.readString().asExpression(), buf.readEnum(CameraInterpolation::class.java))
+            }).toMutableMap()
+            val move = buf.readString()
+
+            return BattleCameraEntry(id, length, positionTimeline, targetPositionTimeline, move)
+        }
+    }
+
+    data class CameraKeyFrame (
+        val x: Expression,
+        val y: Expression,
+        val z: Expression,
+        val interpolation: CameraInterpolation
+    )
+
+    enum class CameraInterpolation {
+        LINEAR,
+        STEP
+    }
+
+    object CameraEntryAdapter: JsonDeserializer<BattleCameraEntry> {
+        override fun deserialize(
+            json: JsonElement?,
+            typeOfT: Type?,
+            context: JsonDeserializationContext?
+        ): BattleCameraEntry {
+            if (json is JsonObject) {
+                val length = json["length"]?.asDouble ?: 0.0
+                val positionTimeline = mutableMapOf<String, CameraKeyFrame>()
+                json["positions"]?.asJsonObject?.entrySet()?.forEach { (name, position) ->
+                    val xyz = position.asJsonObject["xyz"]
+                    var x = "0.0".asExpression()
+                    var y = "0.0".asExpression()
+                    var z = "0.0".asExpression()
+                    if (xyz != null && xyz.isJsonArray && xyz.asJsonArray.size() == 3) {
+                        x = xyz.asJsonArray[0].asString.asExpression()
+                        y = xyz.asJsonArray[1].asString.asExpression()
+                        z = xyz.asJsonArray[2].asString.asExpression()
+                    }
+                    val interpolation = when (position.asJsonObject["interpolation"]?.asString) {
+                        "linear" -> CameraInterpolation.LINEAR
+                        "step" -> CameraInterpolation.STEP
+                        else -> CameraInterpolation.LINEAR
+                    }
+                    positionTimeline[name] = CameraKeyFrame(x, y, z, interpolation)
+                }
+                val targetPositionTimeline = mutableMapOf<String, CameraKeyFrame>()
+                json["targetPositions"]?.asJsonObject?.entrySet()?.forEach { (name, position) ->
+                    val xyz = position.asJsonObject["xyz"]
+                    var x = "0.0".asExpression()
+                    var y = "0.0".asExpression()
+                    var z = "0.0".asExpression()
+                    if (xyz != null && xyz.isJsonArray && xyz.asJsonArray.size() == 3) {
+                        x = xyz.asJsonArray[0].asString.asExpression()
+                        y = xyz.asJsonArray[1].asString.asExpression()
+                        z = xyz.asJsonArray[2].asString.asExpression()
+                    }
+                    val interpolation = when (position.asJsonObject["interpolation"]?.asString) {
+                        "linear" -> CameraInterpolation.LINEAR
+                        "step" -> CameraInterpolation.STEP
+                        else -> CameraInterpolation.LINEAR
+                    }
+                    targetPositionTimeline[name] = CameraKeyFrame(x, y, z, interpolation)
+                }
+                val move = json["move"]?.asString ?: ""
+                return BattleCameraEntry(cobblemonResource(""), length, positionTimeline, targetPositionTimeline, move)
+            }
+            throw IllegalStateException("Stadium Camera could not be parsed")
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraManagerClient.kt

@@ -0,0 +1,215 @@
+package com.cobblemon.mod.common.stadium
+
+import com.bedrockk.molang.runtime.MoLangRuntime
+import com.bedrockk.molang.runtime.value.DoubleValue
+import com.bedrockk.molang.runtime.value.MoValue
+import com.bedrockk.molang.runtime.value.StringValue
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.addFunctions
+import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
+import com.cobblemon.mod.common.client.ClientMoLangFunctions.setupClient
+import com.cobblemon.mod.common.client.CobblemonClient
+import com.cobblemon.mod.common.util.resolveBoolean
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.phys.Vec3
+import org.joml.Vector3f
+import java.util.UUID
+import java.util.function.Function
+
+object BattleCameraManagerClient {
+    //Molang
+    fun MoLangRuntime.setupCameraFunctions(): MoLangRuntime {
+        environment.query.addFunctions(
+            hashMapOf(
+                "moveCamera" to Function { params ->
+                    if (params.get<MoValue>(0) !is StringValue) {
+                        return@Function Unit
+                    }
+                    val camera = BattleCameras.getMoveCamera(params.get<MoValue>(0).asString())
+                    return@Function camera?.id?.toString() ?: ""
+                }
+            )
+        )
+        return this
+    }
+
+    val runtime = MoLangRuntime().setup().setupClient().setupCameraFunctions()
+
+    var currentStadiumBattleUUID: UUID? = null
+
+    var Instruction = "DEFAULT"
+    var InstructionChangeTime = 0.0
+    var InstructionJustChanged = false
+
+    fun updateState(newState: String) {
+        Instruction = newState
+        InstructionChangeTime = 0.0
+        InstructionJustChanged = true
+    }
+
+    fun onLogout() {
+        currentStadiumBattleUUID = null
+    }
+
+    fun handleJoin(battleUUID: UUID, cameraManager: ResourceLocation, center: Vec3, yRot: Float) {
+        currentStadiumBattleUUID = battleUUID
+        activeCameraManager = cameraManager
+
+        battleCenter = center
+        battleYRot = yRot
+
+        cameraTimer = 0.0
+        currentCameraState = BattleCameraManagers.managers[cameraManager]!!.startingState
+        cameraPosition = Vec3.ZERO
+        cameraRotation = Vector3f()
+        updateCameraData(0.0)
+    }
+
+    fun inStadiumBattle(): Boolean {
+        return currentStadiumBattleUUID != null
+    }
+
+    fun shouldUseStadiumCamera(): Boolean {
+        return inStadiumBattle()
+    }
+
+    //Molang Data
+    fun updateMolangVar() {
+        val environment = runtime.environment
+        environment.setSimpleVariable("instruction", StringValue(Instruction))
+        //environment.setSimpleVariable("instructionChangeTime", DoubleValue(InstructionChangeTime))
+        environment.setSimpleVariable("instructionJustChanged", DoubleValue(InstructionJustChanged))
+        val isSpectating = CobblemonClient.battle?.spectating ?: false
+        environment.setSimpleVariable("isBattling", DoubleValue(!isSpectating))
+        environment.setSimpleVariable("isSpectating", DoubleValue(isSpectating))
+    }
+
+    fun instructionUpdate(newState: String, additionalValues: MutableMap<String, MoValue>) {
+        val environment = runtime.environment
+        Instruction = newState
+        InstructionChangeTime = 0.0
+        InstructionJustChanged = true
+        for (value in additionalValues) {
+            environment.setSimpleVariable(value.key, value.value)
+        }
+    }
+
+    //Camera Manager
+    var battleYRot = 0.0F
+    var battleCenter = Vec3.ZERO
+
+    var activeCameraManager: ResourceLocation? = null
+    var cameraTimer: Double = 0.0
+    var currentCameraState: String = ""
+    var nextCameraState: String = ""
+    var calculateNextState: Boolean = true
+
+    fun tickCameraManager() {
+        if (!shouldUseStadiumCamera()) return
+
+        //Molang Variables
+        val environment = runtime.environment
+        if (CobblemonClient.battle != null) {
+            environment.setSimpleVariable("selectingMove", DoubleValue(CobblemonClient.battle!!.mustChoose))
+        }
+        else {
+            environment.setSimpleVariable("selectingMove", DoubleValue(0.0))
+        }
+
+        val currentManager = BattleCameraManagers.managers[activeCameraManager]!!
+        val currentState = currentManager.states[currentCameraState]!!
+        val currentCamera = BattleCameras.cameras[currentState.camera]
+
+        InstructionChangeTime += 0.05
+        if (currentCamera != null) {
+            cameraTimer += 0.05
+            if (cameraTimer > currentCamera.length && currentCamera.length != 0.0) {
+                if (currentState.loop) {
+                    cameraTimer -= currentCamera.length
+                }
+                else {
+                    cameraTimer = currentCamera.length
+                }
+            }
+        }
+
+        if (!calculateNextState) {
+            currentCameraState = nextCameraState
+            calculateNextState = true
+
+            cameraTimer = if (currentCamera != null && currentCamera.length != 0.0) cameraTimer - currentCamera.length else 0.0
+        }
+        else {
+            updateMolangVar()
+            environment.setSimpleVariable("instructionChangeTime", DoubleValue(InstructionChangeTime))
+
+            val endOfAnim = if (currentCamera != null) cameraTimer + 1/20 >= currentCamera.length else true
+
+            val nextState = evaluateTransitions(currentState, endOfAnim)
+            if (nextState != null) {
+                nextCameraState = nextState.targetState
+                while (true) {
+                    val newState = currentManager.states[nextCameraState]!!
+                    val newCamera = BattleCameras.cameras[newState.camera]
+                    val newEndOfAnim = if (newCamera != null) newCamera.length == 0.0 else true
+
+                    val newNextState = evaluateTransitions(newState, newEndOfAnim)
+                    if (newNextState == null) {
+                        break
+                    }
+                    else {
+                        nextCameraState = newNextState.targetState
+                    }
+                }
+                calculateNextState = false
+            }
+        }
+        if (InstructionJustChanged) {
+            InstructionJustChanged = false
+            Instruction = "NONE"
+        }
+    }
+
+    private fun evaluateTransitions(state: BattleCameraState, checkEnd: Boolean) : BattleCameraTransition? {
+        var nextState = state.listOfTransitions.firstOrNull { !it.checkOnEnd && runtime.resolveBoolean(it.condition) }
+        if (nextState == null && checkEnd) {
+            nextState = state.listOfTransitions.firstOrNull { it.checkOnEnd && runtime.resolveBoolean(it.condition) }
+        }
+        return nextState
+    }
+
+    var cameraPosition: Vec3 = Vec3.ZERO
+    var cameraRotation: Vector3f = Vector3f()
+
+    fun updateCameraData(delta: Double) {
+        if (!shouldUseStadiumCamera()) return
+
+        val environment = runtime.environment
+        updateMolangVar()
+        environment.setSimpleVariable("instructionChangeTime", DoubleValue(InstructionChangeTime + delta/20))
+
+        val currentManager = BattleCameraManagers.managers[activeCameraManager]!!
+        val currentState = currentManager.states[currentCameraState]!!
+        val currentCamera = BattleCameras.cameras[currentState.camera]
+
+        if (currentCamera != null) {
+            var renderTime = cameraTimer + delta/20
+            if (renderTime > currentCamera.length && currentCamera.length != 0.0 && !calculateNextState) {
+                val newState = currentManager.states[nextCameraState]!!
+                val newCamera = BattleCameras.cameras[newState.camera] ?: return
+
+                environment.setSimpleVariable("anim_time", DoubleValue(renderTime - currentCamera.length))
+                cameraPosition = newCamera.resolvePosition(renderTime - currentCamera.length, battleYRot)
+                cameraRotation = newCamera.resolveRotation(renderTime - currentCamera.length, battleYRot)
+            }
+            else {
+                if (renderTime > currentCamera.length && currentCamera.length != 0.0) renderTime = currentCamera.length
+
+                environment.setSimpleVariable("anim_time", DoubleValue(renderTime))
+                cameraPosition = currentCamera.resolvePosition(renderTime, battleYRot)
+                cameraRotation = currentCamera.resolveRotation(renderTime, battleYRot)
+            }
+
+            cameraPosition = cameraPosition.add(battleCenter)
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraManagerData.kt

@@ -0,0 +1,119 @@
+package com.cobblemon.mod.common.stadium
+
+import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.util.*
+import com.google.gson.JsonDeserializationContext
+import com.google.gson.JsonDeserializer
+import com.google.gson.JsonElement
+import com.google.gson.JsonObject
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+import java.lang.reflect.Type
+
+class BattleCameraManagerEntry(
+    var id: ResourceLocation,
+    val states: MutableMap<String, BattleCameraState>,
+    val startingState: String
+) {
+    fun encode(buf: RegistryFriendlyByteBuf) {
+        buf.writeIdentifier(id)
+        buf.writeMap(states, {_, key -> buf.writeString(key)}, {_, value -> value.encode(buf)})
+        buf.writeString(startingState)
+    }
+
+    companion object {
+        fun decode(buf: RegistryFriendlyByteBuf): BattleCameraManagerEntry {
+            val id = buf.readIdentifier()
+            val states = buf.readMap({buf.readString()}, {BattleCameraState.decode(buf)}).toMutableMap()
+            val startState = buf.readString()
+            return BattleCameraManagerEntry(id, states, startState)
+        }
+    }
+}
+
+class BattleCameraState(
+    val camera: ResourceLocation,
+    val target: StadiumCameraTarget,
+    val listOfTransitions: MutableList<BattleCameraTransition>,
+    val loop: Boolean
+) {
+    fun encode(buf: RegistryFriendlyByteBuf) {
+        buf.writeIdentifier(camera)
+        buf.writeEnum(target)
+        buf.writeCollection(listOfTransitions) {_, transition -> transition.encode(buf)}
+        buf.writeBoolean(loop)
+    }
+
+    companion object {
+        fun decode(buf: RegistryFriendlyByteBuf): BattleCameraState {
+            val camera = buf.readIdentifier()
+            val target = buf.readEnum(StadiumCameraTarget::class.java)
+            val listOfTransitions = buf.readList { BattleCameraTransition.decode(buf) }.toMutableList()
+            val loop = buf.readBoolean()
+            return BattleCameraState(camera, target, listOfTransitions, loop)
+        }
+    }
+}
+
+class BattleCameraTransition(
+    val targetState: String,
+    val checkOnEnd: Boolean,
+    val condition: Expression
+) {
+    fun encode(buf: RegistryFriendlyByteBuf) {
+        buf.writeString(targetState)
+        buf.writeBoolean(checkOnEnd)
+        buf.writeString(condition.originalString)
+    }
+
+    companion object {
+        fun decode(buf: RegistryFriendlyByteBuf): BattleCameraTransition {
+            val targetState = buf.readString()
+            val checkOnEnd = buf.readBoolean()
+            val condition = buf.readString().asExpression()
+            return BattleCameraTransition(targetState, checkOnEnd, condition)
+        }
+    }
+}
+
+enum class StadiumCameraTarget {
+    CENTRE,
+    ACTIVE_POKEMON,
+    ENEMY_POKEMON,
+    TRAINER
+}
+
+object BattleCameraManagerAdapter: JsonDeserializer<BattleCameraManagerEntry> {
+    override fun deserialize(
+        json: JsonElement?,
+        typeOfT: Type?,
+        context: JsonDeserializationContext?
+    ): BattleCameraManagerEntry {
+        if (json is JsonObject) {
+            val states = mutableMapOf<String, BattleCameraState>()
+            json["states"]?.asJsonObject?.entrySet()?.forEach { (name, state) ->
+                val camera = state.asJsonObject["camera"]?.asString?.asResource() ?: "".asResource()
+                val target = when (state.asJsonObject["target"]?.asString) {
+                    "CENTRE" -> StadiumCameraTarget.CENTRE
+                    "ACTIVE_POKEMON" -> StadiumCameraTarget.ACTIVE_POKEMON
+                    "ENEMY_POKEMON" -> StadiumCameraTarget.ENEMY_POKEMON
+                    "TRAINER" -> StadiumCameraTarget.TRAINER
+                    else -> StadiumCameraTarget.CENTRE
+                }
+                val listOfTransitions = mutableListOf<BattleCameraTransition>()
+                state.asJsonObject["transitions"]?.asJsonArray?.forEach {
+                    val targetState = it.asJsonObject["targetState"]?.asString ?: ""
+                    val checkOnEnd = it.asJsonObject["checkOnEnd"]?.asBoolean ?: false
+                    val condition = it.asJsonObject["condition"]?.asString?.asExpression() ?: "0.0".asExpression()
+                    listOfTransitions.add(BattleCameraTransition(targetState, checkOnEnd, condition))
+                }
+                val loop = state.asJsonObject["loop"]?.asBoolean ?: false
+                states[name] = BattleCameraState(camera, target, listOfTransitions, loop)
+            }
+            val startingState = json["startingState"].asString ?: ""
+            return BattleCameraManagerEntry(cobblemonResource(""), states, startingState)
+        }
+        throw IllegalStateException("StadiumCameraManager could not be parsed")
+    }
+}
+

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraManagers.kt

@@ -0,0 +1,44 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object BattleCameraManagers: JsonDataRegistry<BattleCameraManagerEntry> {
+    override val id = cobblemonResource("stadium_managers")
+    override val type = PackType.SERVER_DATA
+
+    override val gson: Gson = GsonBuilder()
+        .disableHtmlEscaping()
+        .setPrettyPrinting()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(BattleCameraManagerEntry::class.java, BattleCameraManagerAdapter)
+        .create()
+
+    override val typeToken: TypeToken<BattleCameraManagerEntry> = TypeToken.get(BattleCameraManagerEntry::class.java)
+    override val resourcePath = "stadium_managers"
+
+    val managers = mutableMapOf<ResourceLocation, BattleCameraManagerEntry>()
+
+    override fun reload(data: Map<ResourceLocation, BattleCameraManagerEntry>) {
+        managers.clear()
+        data.forEach { location, manager ->
+            manager.id = location
+            managers[location] = manager
+        }
+        observable.emit(this)
+    }
+
+    override val observable = SimpleObservable<BattleCameraManagers>()
+
+    override fun sync(player: ServerPlayer) {
+        BattleCameraManagersSyncPacket(managers.values).sendToPlayer(player)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraManagersSyncPacket.kt

@@ -0,0 +1,27 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.net.messages.client.data.DataRegistrySyncPacket
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class BattleCameraManagersSyncPacket(managers: Collection<BattleCameraManagerEntry>) :
+    DataRegistrySyncPacket<BattleCameraManagerEntry, BattleCameraManagersSyncPacket>(managers) {
+    override fun encodeEntry(buffer: RegistryFriendlyByteBuf, entry: BattleCameraManagerEntry) {
+        entry.encode(buffer)
+    }
+
+    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): BattleCameraManagerEntry? {
+        return BattleCameraManagerEntry.decode(buffer)
+    }
+
+    override fun synchronizeDecoded(entries: Collection<BattleCameraManagerEntry>) {
+        BattleCameraManagers.reload(entries.associateBy { it.id })
+    }
+
+    override val id = ID
+
+    companion object {
+        val ID = cobblemonResource("stadium_camera_managers_sync")
+        fun decode(buffer: RegistryFriendlyByteBuf) = BattleCameraManagersSyncPacket(emptyList()).apply { decodeBuffer(buffer) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraPacket.kt

@@ -0,0 +1,29 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.api.net.NetworkPacket
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.cobblemon.mod.common.util.readIdentifier
+import com.cobblemon.mod.common.util.writeIdentifier
+import net.minecraft.network.RegistryFriendlyByteBuf
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.world.phys.Vec3
+import java.util.*
+
+class BattleCameraPacket(
+    val joiningBattle: UUID,
+    val cameraManager: ResourceLocation,
+    val center: Vec3,
+    val yRot: Float
+): NetworkPacket<BattleCameraPacket> {
+    override val id = ID
+    override fun encode(buffer: RegistryFriendlyByteBuf) {
+        buffer.writeUUID(this.joiningBattle)
+        buffer.writeIdentifier(cameraManager)
+        buffer.writeVec3(center)
+        buffer.writeFloat(yRot)
+    }
+    companion object {
+        val ID = cobblemonResource("stadium_join")
+        fun decode(buffer: RegistryFriendlyByteBuf) = BattleCameraPacket(buffer.readUUID(), buffer.readIdentifier(), buffer.readVec3(), buffer.readFloat())
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameraSetupHandler.kt

@@ -0,0 +1,10 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.api.net.ClientNetworkPacketHandler
+import net.minecraft.client.Minecraft
+
+object BattleCameraSetupHandler: ClientNetworkPacketHandler<BattleCameraPacket> {
+    override fun handle(packet: BattleCameraPacket, client: Minecraft) {
+        BattleCameraManagerClient.handleJoin(packet.joiningBattle, packet.cameraManager, packet.center, packet.yRot)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCameras.kt

@@ -0,0 +1,48 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
+import com.cobblemon.mod.common.api.reactive.SimpleObservable
+import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
+import com.cobblemon.mod.common.util.cobblemonResource
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import com.google.gson.reflect.TypeToken
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.server.packs.PackType
+
+object BattleCameras: JsonDataRegistry<BattleCameraEntry> {
+    override val id = cobblemonResource("stadium_cameras")
+    override val type = PackType.SERVER_DATA
+
+    override val gson: Gson = GsonBuilder()
+        .disableHtmlEscaping()
+        .setPrettyPrinting()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(BattleCameraEntry::class.java, BattleCameraEntry.CameraEntryAdapter)
+        .create()
+
+    override val typeToken: TypeToken<BattleCameraEntry> = TypeToken.get(BattleCameraEntry::class.java)
+    override val resourcePath = "stadium_cameras"
+
+    val cameras = mutableMapOf<ResourceLocation, BattleCameraEntry>()
+
+    override fun reload(data: Map<ResourceLocation, BattleCameraEntry>) {
+        cameras.clear()
+        data.forEach { location, camera ->
+            camera.id = location
+            cameras[location] = camera
+        }
+        observable.emit(this)
+    }
+
+    override val observable = SimpleObservable<BattleCameras>()
+
+    override fun sync(player: ServerPlayer) {
+        BattleCamerasSyncPacket(cameras.values).sendToPlayer(player)
+    }
+
+    fun getMoveCamera(move: String): BattleCameraEntry? {
+        return cameras.values.firstOrNull { it.move == move }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/BattleCamerasSyncPacket.kt

@@ -0,0 +1,27 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.net.messages.client.data.DataRegistrySyncPacket
+import com.cobblemon.mod.common.util.cobblemonResource
+import net.minecraft.network.RegistryFriendlyByteBuf
+
+class BattleCamerasSyncPacket(cameras: Collection<BattleCameraEntry>) :
+    DataRegistrySyncPacket<BattleCameraEntry, BattleCamerasSyncPacket>(cameras) {
+    override fun encodeEntry(buffer: RegistryFriendlyByteBuf, entry: BattleCameraEntry) {
+        entry.encode(buffer)
+    }
+
+    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): BattleCameraEntry? {
+        return BattleCameraEntry.decode(buffer)
+    }
+
+    override fun synchronizeDecoded(entries: Collection<BattleCameraEntry>) {
+        BattleCameras.reload(entries.associateBy { it.id })
+    }
+
+    override val id = ID
+
+    companion object {
+        val ID = cobblemonResource("stadium_cameras_sync")
+        fun decode(buffer: RegistryFriendlyByteBuf) = BattleCamerasSyncPacket(emptyList()).apply { decodeBuffer(buffer) }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/StadiumBattleDefenition.kt

@@ -0,0 +1,12 @@
+package com.cobblemon.mod.common.stadium
+
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.phys.Vec3
+import java.util.*
+
+abstract class StadiumBattleDefenition {
+    abstract fun playerPositions(): MutableList<Pair<Int, Vec3>>
+    abstract fun pokemonPositions(): MutableList<Pair<Int, Vec3>>
+
+
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/StadiumFormat.kt

@@ -0,0 +1,4 @@
+package com.cobblemon.mod.common.stadium
+
+class StadiumFormat {
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/StadiumServerManager.kt

@@ -0,0 +1,34 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import net.minecraft.resources.ResourceLocation
+import net.minecraft.server.level.ServerPlayer
+import java.util.UUID
+
+object StadiumServerManager {
+    val activeStadiumBattles = mutableMapOf<UUID, StadiumBattleInstance>()
+
+    fun createNewStadiumBattle(battle: UUID, managerResource: ResourceLocation, participants: MutableList<UUID> = mutableListOf<UUID>()) {
+        val newInstance = StadiumBattleInstance(battle, managerResource)
+        newInstance.participants = participants
+        activeStadiumBattles[battle] = newInstance
+    }
+
+    fun terminateNewStadiumBattle(battle: UUID) {
+        activeStadiumBattles.remove(battle)
+    }
+
+    fun addPlayerToStadiumBattle(battle: UUID, player: UUID) {
+        val instance = activeStadiumBattles[battle]
+        if (instance != null) {
+            if (!instance.participants.contains(player)) instance.participants.add(player)
+        }
+    }
+}
+
+class StadiumBattleInstance(
+    val stadiumBattleId: UUID,
+    val managerResource: ResourceLocation
+){
+    var participants = mutableListOf<UUID>()
+}

common/src/main/kotlin/com/cobblemon/mod/common/stadium/StadiumSingleBattle.kt

@@ -0,0 +1,73 @@
+package com.cobblemon.mod.common.stadium
+
+import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.battles.BattleBuilder
+import com.cobblemon.mod.common.battles.SuccessfulBattleStart
+import com.cobblemon.mod.common.util.getPlayer
+import com.cobblemon.mod.common.util.party
+import net.minecraft.server.level.ServerPlayer
+import net.minecraft.world.phys.Vec3
+
+class StadiumSingleBattle: StadiumBattleDefenition() {
+
+    override fun playerPositions(): MutableList<Pair<Int, Vec3>> {
+        return mutableListOf()
+    }
+
+    override fun pokemonPositions(): MutableList<Pair<Int, Vec3>> {
+        return mutableListOf()
+    }
+    /*
+    @JvmField
+    val MAX_PLAYERS = 2
+
+    var player1Position = Vec3(0.0,0.0,0.0)
+    var player2Position = Vec3(0.0,0.0,0.0)
+
+    var player1PokemonPosition = Vec3(0.0,0.0,0.0)
+    var player2PokemonPosition = Vec3(0.0,0.0,0.0)
+
+    var activeBattle: PokemonBattle? = null
+
+    override fun readyForBattle(): Boolean {
+        return this.getPlayers().count() == MAX_PLAYERS
+    }
+
+    override fun canAddPlayer(player: ServerPlayer): Boolean {
+        val party = player.party()
+        return party.occupied() > 0
+    }
+
+    override fun addPlayer(player: ServerPlayer) {
+        if (canAddPlayer(player)) {
+            participants.add(player.uuid)
+            player.sendPacket(BattleCameraPacket(player.uuid, BattleCameraManagers.managers.keys.first(), Vec3.ZERO, 0F))
+        }
+    }
+
+    override fun getPlayers(): MutableList<ServerPlayer> {
+        return participants.mapNotNull { it.getPlayer() }.toMutableList()
+    }
+
+    override fun initializeBattle() {
+        if (!readyForBattle()) return
+
+        val players = getPlayers()
+
+        val player1 = players[0]
+        val player2 = players[1]
+
+        val battleResult = BattleBuilder.pvp1v1(player1, player2)
+        var errored = false
+        battleResult.ifErrored { errored = true }
+        if (errored) return
+
+        val battle = (battleResult as SuccessfulBattleStart).battle
+    }
+
+    override fun getCurrentCamera(): BattleCameraEntry {
+        TODO("Not yet implemented")
+    }
+    */
+}

common/src/main/kotlin/com/cobblemon/mod/common/util/CameraExtensions.kt

@@ -0,0 +1,14 @@
+package com.cobblemon.mod.common.util
+
+import com.cobblemon.mod.common.util.math.toEulerXYZ
+import net.minecraft.client.Camera
+import org.joml.Quaternionf
+
+fun Camera.setRotation(yaw: Float, pitch: Float, roll: Float) {
+    this.xRot = yaw
+    this.yRot = pitch
+    this.rotation.rotationYXZ(Math.PI.toFloat() - pitch * (Math.PI.toFloat() / 180F),-yaw * (Math.PI.toFloat() / 180F),roll * (Math.PI.toFloat() / 180F))
+    Camera.FORWARDS.rotate(this.rotation, this.forwards)
+    Camera.UP.rotate(this.rotation, this.up)
+    Camera.LEFT.rotate(this.rotation, this.left)
+}

common/src/main/resources/assets/cobblemon/bedrock/drone/animations/rotom_drone.animation.json

@@ -0,0 +1,41 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"animation.rotom_drone.sleep": {
+			"loop": true,
+			"bones": {
+				"body": {
+					"rotation": [
+						"math.sin(query.anim_time * 120) * 6",
+						0,
+						"math.cos(query.anim_time * 100) * 4"
+					],
+					"position": [
+						0,
+						"18 + math.sin(query.anim_time * 90) * 1",
+						0
+					]
+				},
+				"head": {
+					"relative_to": {
+						"rotation": "entity"
+					},
+					"rotation": [
+						0,
+						0,
+						0.01
+					]
+				}
+			}
+		},
+		"animation.rotom_drone.circle": {
+			"loop": true,
+			"bones": {
+				"rotom_drone": {
+					"rotation": [30, "90 - q.anim_time*90", 0],
+					"position": ["48*math.cos(q.anim_time*90)", 64, "48*math.sin(q.anim_time*90)"]
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/drone/models/rotom_drone.geo.json

@@ -0,0 +1,208 @@
+{
+	"format_version": "1.12.0",
+	"minecraft:geometry": [
+		{
+			"description": {
+				"identifier": "geometry.drone_rotom",
+				"texture_width": 64,
+				"texture_height": 32,
+				"visible_bounds_width": 8,
+				"visible_bounds_height": 6.5,
+				"visible_bounds_offset": [0, 2.75, 0]
+			},
+			"bones": [
+				{
+					"name": "rotom_drone",
+					"pivot": [0, 0, 0]
+				},
+				{
+					"name": "body",
+					"parent": "rotom_drone",
+					"pivot": [0, 8, 0]
+				},
+				{
+					"name": "head",
+					"parent": "body",
+					"pivot": [0, 6.5, 0],
+					"cubes": [
+						{"origin": [-5.5, 6.5, -3.5], "size": [11, 6, 7], "uv": [0, 0]}
+					]
+				},
+				{
+					"name": "eyes",
+					"parent": "head",
+					"pivot": [0.5, 6.5, -2.5]
+				},
+				{
+					"name": "eye_right",
+					"parent": "eyes",
+					"pivot": [-2.9, 9.5, -3.5],
+					"rotation": [0, 0, -7.5],
+					"cubes": [
+						{"origin": [-3.9, 7.5, -3.5], "size": [2, 4, 0], "inflate": 0.01, "uv": [0, 0], "mirror": true},
+						{"origin": [-3.9, 9, -3.5], "size": [2, 1, 0], "inflate": 0.02, "uv": [0, 6], "mirror": true}
+					]
+				},
+				{
+					"name": "pupil_right",
+					"parent": "eye_right",
+					"pivot": [-2.9, 9.5, -3.5],
+					"cubes": [
+						{"origin": [-3.4, 8, -3.5], "size": [1, 3, 0], "inflate": 0.03, "uv": [5, 0], "mirror": true}
+					]
+				},
+				{
+					"name": "eye_left",
+					"parent": "eyes",
+					"pivot": [2.9, 9.5, -3.5],
+					"rotation": [0, 0, 7.5],
+					"cubes": [
+						{"origin": [1.9, 7.5, -3.5], "size": [2, 4, 0], "inflate": 0.01, "uv": [0, 13]},
+						{"origin": [1.9, 9, -3.5], "size": [2, 1, 0], "inflate": 0.02, "uv": [0, 5]}
+					]
+				},
+				{
+					"name": "pupil_left",
+					"parent": "eye_left",
+					"pivot": [2.9, 9.5, -3.5],
+					"cubes": [
+						{"origin": [2.4, 8, -3.5], "size": [1, 3, 0], "inflate": 0.03, "uv": [6, 13]}
+					]
+				},
+				{
+					"name": "mouth_smile",
+					"parent": "head",
+					"pivot": [0, 7.55, -3.5],
+					"cubes": [
+						{"origin": [-1, 6.95, -3.5], "size": [2, 1, 0], "inflate": 0.02, "uv": [36, 7]},
+						{"origin": [-1.5, 7.25, -3.5], "size": [1, 1, 0], "inflate": 0.01, "uv": [40, 7]},
+						{"origin": [0.5, 7.25, -3.5], "size": [1, 1, 0], "inflate": 0.01, "uv": [42, 7]}
+					]
+				},
+				{
+					"name": "mouth_closed",
+					"parent": "head",
+					"pivot": [0, 7.45, -3.4],
+					"cubes": [
+						{"origin": [-0.5, 6.95, -3.4], "size": [1, 1, 0], "inflate": 0.02, "uv": [38, 8]}
+					]
+				},
+				{
+					"name": "mouth_open",
+					"parent": "head",
+					"pivot": [0, 7.45, -3.4],
+					"cubes": [
+						{"origin": [-0.5, 6.95, -3.4], "size": [1, 1, 0], "inflate": 0.02, "uv": [36, 8]}
+					]
+				},
+				{
+					"name": "mouth_sad",
+					"parent": "head",
+					"pivot": [0, 7.6, -3.3],
+					"cubes": [
+						{"origin": [-1, 7.3, -3.3], "size": [2, 1, 0], "inflate": 0.02, "uv": [36, 9]},
+						{"origin": [-1.5, 7, -3.3], "size": [1, 1, 0], "inflate": 0.01, "uv": [40, 9]},
+						{"origin": [0.5, 7, -3.3], "size": [1, 1, 0], "inflate": 0.01, "uv": [42, 9]}
+					]
+				},
+				{
+					"name": "head_spike1",
+					"parent": "head",
+					"pivot": [0, 12.5, 0],
+					"cubes": [
+						{"origin": [-1.5, 11.5, -1.5], "size": [3, 4, 3], "uv": [29, 0]}
+					]
+				},
+				{
+					"name": "head_spike2",
+					"parent": "head_spike1",
+					"pivot": [0, 15.5, 0],
+					"cubes": [
+						{"origin": [-1, 14.5, -1], "size": [2, 4, 2], "uv": [8, 13]}
+					]
+				},
+				{
+					"name": "head_spike3",
+					"parent": "head_spike2",
+					"pivot": [0, 18.5, 0],
+					"cubes": [
+						{"origin": [-0.5, 17.5, -0.5], "size": [1, 3, 1], "uv": [44, 6]}
+					]
+				},
+				{
+					"name": "torso",
+					"parent": "body",
+					"pivot": [0, 7, 0],
+					"cubes": [
+						{"origin": [-2, 3, -1.5], "size": [4, 4, 3], "uv": [34, 10]}
+					]
+				},
+				{
+					"name": "camera",
+					"parent": "torso",
+					"pivot": [0, 4.65, -1.25],
+					"cubes": [
+						{"origin": [-1, 3.65, -2.75], "size": [2, 2, 2], "uv": [24, 13]},
+						{"origin": [-0.5, 4.15, -2.75], "size": [1, 1, 0], "inflate": 0.01, "uv": [38, 0]}
+					]
+				},
+				{
+					"name": "propeller_front_right",
+					"parent": "torso",
+					"pivot": [-1.5, 5, -1],
+					"rotation": [0, 45, 0],
+					"cubes": [
+						{"origin": [-2, 5, -3.5], "size": [1, 0, 3], "uv": [37, 0]},
+						{"origin": [-5.5, 5, -11.5], "size": [8, 0, 8], "uv": [40, 0]}
+					]
+				},
+				{
+					"name": "propeller_front_left",
+					"parent": "torso",
+					"pivot": [1.5, 5, -1],
+					"rotation": [0, -45, 0],
+					"cubes": [
+						{"origin": [1, 5, -3.5], "size": [1, 0, 3], "uv": [27, 0]},
+						{"origin": [-2.5, 5, -11.5], "size": [8, 0, 8], "uv": [40, 0]}
+					]
+				},
+				{
+					"name": "propeller_back_right",
+					"parent": "torso",
+					"pivot": [-1.5, 5, 1],
+					"rotation": [0, -45, 0],
+					"cubes": [
+						{"origin": [-2, 5, 0.5], "size": [1, 0, 3], "uv": [39, 0]},
+						{"origin": [-5.5, 5, 3.5], "size": [8, 0, 8], "uv": [40, 0]}
+					]
+				},
+				{
+					"name": "propeller_back_left",
+					"parent": "torso",
+					"pivot": [1.5, 5, 1],
+					"rotation": [0, 45, 0],
+					"cubes": [
+						{"origin": [1, 5, 0.5], "size": [1, 0, 3], "uv": [42, 3]},
+						{"origin": [-2.5, 5, 3.5], "size": [8, 0, 8], "uv": [40, 0]}
+					]
+				},
+				{
+					"name": "tail1",
+					"parent": "torso",
+					"pivot": [0, 3, 0],
+					"cubes": [
+						{"origin": [-1, 1, -1], "size": [2, 3, 2], "uv": [16, 13]}
+					]
+				},
+				{
+					"name": "tail2",
+					"parent": "tail1",
+					"pivot": [0, 1, 0],
+					"cubes": [
+						{"origin": [-0.5, -1, -0.5], "size": [1, 3, 1], "uv": [41, 3]}
+					]
+				}
+			]
+		}
+	]
+}

common/src/main/resources/assets/cobblemon/bedrock/drone/posers/rotom_drone.json

@@ -0,0 +1,8 @@
+{
+  "poses": {
+    "sleep": {
+      "poseTypes": ["SLEEP"],
+      "animations": ["q.bedrock('rotom_drone', 'sleep')"]
+    }
+  }
+}

common/src/main/resources/assets/cobblemon/bedrock/drone/variations/rotom_drone.json

@@ -0,0 +1,13 @@
+{
+  "name": "cobblemon:rotom_drone",
+  "order": 0,
+  "variations": [
+    {
+      "aspects": [],
+      "poser": "cobblemon:rotom_drone",
+      "model": "cobblemon:rotom_drone.geo",
+      "texture": "cobblemon:textures/drone/rotom_drone.png",
+      "layers": []
+    }
+  ]
+}

common/src/main/resources/assets/cobblemon/blockstates/stadium_block.json

@@ -0,0 +1,7 @@
+{
+  "variants": {
+    "": {
+      "model": "cobblemon:block/stadium_block"
+    }
+  }
+}

common/src/main/resources/assets/cobblemon/lang/en_us.json

@@ -850,6 +850,7 @@
   "block.cobblemon.healing_machine.tooltip2": "Charges over time.",
   "block.cobblemon.pc": "PC",
   "block.cobblemon.lectern": "Lectern",
+  "block.cobblemon.stadium_block": "Stadium Block",
   "block.cobblemon.restoration_tank": "Restoration Tank",
   "block.cobblemon.fossil_analyzer": "Fossil Analyzer",
   "block.cobblemon.monitor": "Data Monitor",

common/src/main/resources/assets/cobblemon/models/block/stadium_block.json

@@ -0,0 +1,6 @@
+{
+    "parent": "minecraft:block/cube_all",
+    "textures": {
+        "all": "cobblemon:block/stadium_block"
+    }
+}

common/src/main/resources/assets/cobblemon/models/item/stadium_block.json

@@ -0,0 +1,3 @@
+{
+  "parent": "cobblemon:block/stadium_block"
+}

common/src/main/resources/cobblemon-common.accesswidener

@@ -127,6 +127,19 @@ transitive-accessible class net/minecraft/client/renderer/RenderStateShard$Light
 transitive-accessible field net/minecraft/world/entity/LivingEntity jumping Z
 transitive-accessible field net/minecraft/world/entity/Entity FLAG_SHIFT_KEY_DOWN I
 transitive-accessible field net/minecraft/world/entity/Entity DATA_SHARED_FLAGS_ID Lnet/minecraft/network/syncher/EntityDataAccessor;
+
+transitive-accessible method net/minecraft/client/Camera setPosition (Lnet/minecraft/world/phys/Vec3;)V
+transitive-accessible field net/minecraft/client/Camera FORWARDS Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera UP Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera LEFT Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera forwards Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera up Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera left Lorg/joml/Vector3f;
+transitive-accessible field net/minecraft/client/Camera xRot F
+transitive-accessible field net/minecraft/client/Camera yRot F
+transitive-accessible field net/minecraft/client/Camera rotation Lorg/joml/Quaternionf;
+transitive-accessible method net/minecraft/client/Camera setRotation (FF)V
+
 transitive-accessible class net/minecraft/client/gui/Font$StringRenderOutput
 
 transitive-accessible method net/minecraft/world/inventory/MenuType register (Ljava/lang/String;Lnet/minecraft/world/inventory/MenuType$MenuSupplier;)Lnet/minecraft/world/inventory/MenuType;

common/src/main/resources/data/cobblemon/loot_table/blocks/stadium_block.json

@@ -0,0 +1,13 @@
+{
+    "type": "minecraft:block",
+    "pools": [{
+        "rolls": 1,
+        "entries": [{
+            "type": "minecraft:item",
+            "name": "cobblemon:stadium_block"
+        }],
+        "conditions": [{
+            "condition": "minecraft:survives_explosion"
+        }]
+    }]
+}