The great java annotation

Add register method for types
Expose PNX to FormeChangeEvent and MoLang
2026-01-17 06:20:57 -06:00 · 2026-01-17 04:19:07 -06:00 · 2026-01-17 04:02:44 -06:00 · 2026-01-17 03:57:38 -06:00
1650 changed files with 9588 additions and 81888 deletions
@@ -1,60 +1,78 @@
 # Changelog
-## [1.7.4 (MONTH Xth, 2026)](#1-7-4)
+## [1.7.2 (MONTH Xth, YEAR)](#1-7-2)

 ### Additions
- Added config options to award experience to fainted Pokémon for opponents they helped defeat (`awardExperienceToFaintedPokemon`) and to still award experience for defeated enemies even after battle loss/forfeit (`awardExperienceOnBattleLoss`)
- Party Overlay Exp Gained Animation will now display the amount of EXP the Pokémon gained
- Added a toast to notify players of how they can scroll through their party. Did you know you can hold R and scroll instead of using arrow keys??!
- Added new layer property that makes a layer scroll in a direction. "scrolling": {"speedU": 0.1, "speedV": 0.1}
- Added missing crops to Botany Pots integration
-
-### New rideable Pokémon
-
-### Pokémon Added
-
-### Model updates for the following Pokémon
-
-### Animation updates for the following Pokémon
+- Added riding statistics: `Distance by Pokémon on Land`, `Distance by Pokémon in Air` and `Distance by Pokémon in Liquid`.
+- Added the Partner Mark, which party Pokémon have a very small chance to earn as the player walks, provided they have enough friendship.
+- Added trades for Saccharine Saplings, Hearty Grains, Chipped Pot, and Masterpiece Teacup to the Wandering Trader.
+- Added brewing recipe for Throat Spray.
+- Added new effects
+  - Mental Restoration: Reduces "Time Since Last Rest" statistic, which controls Insomnia, by half a minute per second per effect level
+  - Negative Effect Cleanse: Removes all negative effects
+  - Effect Cleanse: Removes all effects
+- Added more seasonings for sinister tea
+  - Mental Herb - Mental Restoration I for 10 seconds
+  - White Herb - Negative Effect Cleanse
+  - Milk - Effect Cleanse
+  - Moomoo Milk - Effect Cleanse
+- Added `label` as an alternate key to the `tag` property.
+- Added Saccharine wood furniture for Adorn.

 ### Changes
- Restructured Botany Pots integration folder structure
- Decrease default pastured mon wander radius to 32.
- Factor in the weight of pokemon when calculating pushing forces between hitboxes.
- Remade the Starter Selection Screen with new assets
- Refactored berry trees to be less impactful on TPS (more performant)
+- Ride sounds have been separated into stereo for passengers and mono for other players. Riding will now sound more spacious.
+- Added a new config option, `Enable In-Flight Dismounting` (default: off), which lets you dismount while riding a Pokémon in the air.
+- Battle AI now uses a smarter threshold for switching, reducing unnecessary switches.
+- AI will always use the most damaging move when at low HP and when it is not switching, improving endgame decision-making.
+- Added support for optional message variants in battle activate instructions for more context-specific battle text.
+  - Example: `this.add('-activate', pokemon, 'ability: example', '[msg]message1');` will parse to lang key `cobblemon.battle.activate.example.message1`

 ### Fixes
- Fixes https://gitlab.com/cable-mc/cobblemon/-/issues/1943
- Fix occasional crash on retrieving revived fossils
- Fixed a compatibility issue with World Game Rules which caused some log spam in specific cases.
- Fixed improper validation of Pokémon when performing a trade.
- Fixed issue where particle like beam can disappear when you don't see the beginning of the beam or you look away
- - Fixes https://gitlab.com/cable-mc/cobblemon/-/issues/1943
- - Fix occasional crash on retrieving revived fossils
- - Fix brushing not working on Neoforge
- - [Various Submarine Ride Fixes](https://gitlab.com/cable-mc/cobblemon/-/merge_requests/2157)
- - Fix Pastured mons despawning and running away.
- - Fix Apricorn trees crashing when other mods bonemeal it
- - [Various UFO Ride Improvements](https://gitlab.com/cable-mc/cobblemon/-/merge_requests/2156)
- Fixed NeoForge brewing stand unexpectedly crashing users when shift clicking items within it's menu
- Fixed NPCs switching pokemon very often during battles
- Fixed Campfire pot causing crashes under certain circumstances
- Fixed Type Gems not being consumed upon use
- Fixed Ancient Pokeball's to their respective modifiers
- Fixed a Server warning when recalling Pokemon
- Fixed sliding particles incorrectly handling block collision
- Fixed Full Heal not curing status conditions in battle
+- Fixed an issue in the OmniPathNodeMaker/Navigation that prevented Combees from pathing into and out of Saccharine leaves.
+- Fixed orientation not getting reset after crashing while flying and getting back on the Pokémon.
+- Fixed Furfrou not being trimmable on NeoForge.
+- Fixed shiny Pokémon not respecting the silent flag on spawn.
+- Fixed honey from Saccharine Leaves being harvestable at less than the max age.
+- Items given from interacting with Saccharine Leaves are placed in the active hotbar slot if possible.
+- Fix all Pokémon being saved to chunks and never despawning.
+- Fixed possible error on world generation when Combees are placed in naturally generated bee nests.
+- Fixed PokeSnacks crashing if there was no available spawn.
+- Fixed Pokémon spawn influences not being specific to regional forms
+- Fixed crashing when viewing another player in spectator mode
+- Fixed missing apricorn textures for Adorn blocks
+- Fixed crashing when riding due to malformed json file, instead resetting it
+- Fixed mochi items consuming two items at a time
+- Fix item interaction sometimes not working properly when playing on servers.
+- Fixed Soothe Bell not being properly tagged as a held item.
+- Fixed Mint Leaves not being usable for filling the Resurrection Machine.
+- Added Saccharine Boats and Saccharine Boat with Chests to relevant boat tags.
+- Fixed the `run_script` Molang function to not fail if the environment's context is null.
+- Fixed issue #1917 
+- Fixed the movesets of certain Pokémon being incorrectly sanitized upon reload.
+- Fixed the ordering of Aprijuice's riding stat boosts to always have the same order.
+- Fixed the Molang functions `date_local_time`, `date_of`, `date_is_after` to use the correct date format.
+- Fixed the bottom half of pasture blocks having an incorrect hit-box when facing north or south.
+- Fixed Galarian Mr. Mime incorrectly being rideable.
+- Fixed gimmicks not being usable in double / triple battles
+- Fixed gimmick buttons showing when already used in the same turn in double / triple battles
+- Fixed Apricorn block model rotation for counters/sinks/cupboards/drawers to match that of most recent version of Adorn.
+- Fixed Fresh Start Mochi EV reset not syncing health changes properly.
+- Fixed requirements such as `biomeCondition` crashing the game when used to define Pokémon interactions.
+- Fixed Pokémon interactions not playing sound effects when the volume was not specified.
+- Fixed Pokémon interaction cooldowns taking longer than intended when the Pokémon was in the player’s party.
+- Fixed Pokémon interactions occasionally crashing the game when spamming an interaction with a 0 cooldown.
+- Fixed Pokémon fullness decreasing more than intended when the Pokémon was pastured.
+- Fixed crashing when sending a Pokémon out after editing its form 
+- Fixed Super Potion recipes incorrectly using Hondew Berry instead of Aguav Berry.

 ### Developer
- Added `PokeSnackSpawnerFactory` which allows influence registration on PokeSnack encounters
- Added `FishingSpawnerFactory` which allows influence registration on fishing encounters
- Added `BattleFleeAttemptEvent` fired from `PokemonBattle.checkFleeAttempt`, allowing developers to intercept and control flee attempts
+- Changed the `owner` parameter in the `OwnerQueryRequirement` interface from `ServerPlayer` to `Player`. This method is now also called on the client to verify whether a Pokémon interaction succeeded, so make sure to update your implementations to handle both server and client contexts.

 ### Molang & Datapacks
- q.item.is_enchanted()
- q.item.has_enchantment(minecraft:sharpness, 3)
- Added `has_chosen_starter` & `get_starter_uuid` as available Molang functions
- Added `marks`, `has_mark`, & `remove_marks` as available Molang functions for pokemon
+- Ride sounds can now be set as exclusive to passengers
+- Ride sounds no longer play when submerged unless specified with a new setting
+- Exception handling has been added to `run_molang`, resolving some crashes caused by malformed MoLang expressions.
+
+### Particles

 ### Localization
 - Updated translations for:
@@ -1,510 +0,0 @@
-{
-	"format_version": "1.21.11",
-	"credit": "Made with Blockbench",
-	"texture_size": [128, 128],
-	"textures": {
-		"2": "block/texture"
-	},
-	"elements": [
-		{
-			"from": [9.999, 10.999, -0.001],
-			"to": [15.001, 12.001, 0.001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 1]},
-			"faces": {
-				"north": {"uv": [0.25, 1.125, 0.875, 1.25], "texture": "#2"},
-				"east": {"uv": [0.25, 1.125, 0.25, 1.25], "texture": "#2"},
-				"south": {"uv": [0.875, 1.125, 1.5, 1.25], "texture": "#2"},
-				"west": {"uv": [0.875, 1.125, 0.875, 1.25], "texture": "#2"},
-				"up": {"uv": [0.875, 1.125, 0.25, 1.125], "texture": "#2"},
-				"down": {"uv": [1.5, 1.125, 0.875, 1.125], "texture": "#2"}
-			}
-		},
-		{
-			"from": [-0.0001, 8.9999, 2.9999],
-			"to": [2.0001, 13.0001, 13.0001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 2]},
-			"faces": {
-				"north": {"uv": [4.25, 6, 4.5, 6.5], "texture": "#2"},
-				"east": {"uv": [3, 6, 4.25, 6.5], "texture": "#2"},
-				"south": {"uv": [5.75, 6, 6, 6.5], "texture": "#2"},
-				"west": {"uv": [4.5, 6, 5.75, 6.5], "texture": "#2"},
-				"up": {"uv": [4.5, 6, 4.25, 4.75], "texture": "#2"},
-				"down": {"uv": [4.75, 4.75, 4.5, 6], "texture": "#2"}
-			}
-		},
-		{
-			"from": [-0.0001, 8.9999, -0.0001],
-			"to": [16.0001, 13.0001, 3.0001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 1]},
-			"faces": {
-				"north": {"uv": [0.375, 3.375, 2.375, 3.875], "texture": "#2"},
-				"east": {"uv": [0, 3.375, 0.375, 3.875], "texture": "#2"},
-				"south": {"uv": [2.75, 3.375, 4.75, 3.875], "texture": "#2"},
-				"west": {"uv": [2.375, 3.375, 2.75, 3.875], "texture": "#2"},
-				"up": {"uv": [2.375, 3.375, 0.375, 3], "texture": "#2"},
-				"down": {"uv": [4.375, 3, 2.375, 3.375], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2.995, 10.995, -0.005],
-			"to": [15.005, 13.005, 2.005],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 1]},
-			"faces": {
-				"north": {"uv": [0.25, 6.75, 1.75, 7], "texture": "#2"},
-				"east": {"uv": [0, 6.75, 0.25, 7], "texture": "#2"},
-				"south": {"uv": [2, 6.75, 3.5, 7], "texture": "#2"},
-				"west": {"uv": [1.75, 6.75, 2, 7], "texture": "#2"},
-				"up": {"uv": [1.75, 6.75, 0.25, 6.5], "texture": "#2"},
-				"down": {"uv": [3.25, 6.5, 1.75, 6.75], "texture": "#2"}
-			}
-		},
-		{
-			"from": [9.999, 10.999, -0.001],
-			"to": [15.001, 12.001, 0.001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 1]},
-			"faces": {
-				"north": {"uv": [0.25, 1.375, 0.875, 1.5], "texture": "#2"},
-				"east": {"uv": [0.25, 1.375, 0.25, 1.5], "texture": "#2"},
-				"south": {"uv": [0.875, 1.375, 1.5, 1.5], "texture": "#2"},
-				"west": {"uv": [0.875, 1.375, 0.875, 1.5], "texture": "#2"},
-				"up": {"uv": [0.875, 1.375, 0.25, 1.375], "texture": "#2"},
-				"down": {"uv": [1.5, 1.375, 0.875, 1.375], "texture": "#2"}
-			}
-		},
-		{
-			"from": [13.9999, 8.9999, 2.9999],
-			"to": [16.0001, 13.0001, 13.0001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 2]},
-			"faces": {
-				"north": {"uv": [1.25, 6, 1.5, 6.5], "texture": "#2"},
-				"east": {"uv": [0, 6, 1.25, 6.5], "texture": "#2"},
-				"south": {"uv": [2.75, 6, 3, 6.5], "texture": "#2"},
-				"west": {"uv": [1.5, 6, 2.75, 6.5], "texture": "#2"},
-				"up": {"uv": [1.5, 6, 1.25, 4.75], "texture": "#2"},
-				"down": {"uv": [1.75, 4.75, 1.5, 6], "texture": "#2"}
-			}
-		},
-		{
-			"from": [-0.0001, 8.9999, 12.9999],
-			"to": [16.0001, 13.0001, 16.0001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, -1, 1]},
-			"faces": {
-				"north": {"uv": [0.375, 4.25, 2.375, 4.75], "texture": "#2"},
-				"east": {"uv": [0, 4.25, 0.375, 4.75], "texture": "#2"},
-				"south": {"uv": [2.75, 4.25, 4.75, 4.75], "texture": "#2"},
-				"west": {"uv": [2.375, 4.25, 2.75, 4.75], "texture": "#2"},
-				"up": {"uv": [2.375, 4.25, 0.375, 3.875], "texture": "#2"},
-				"down": {"uv": [4.375, 3.875, 2.375, 4.25], "texture": "#2"}
-			}
-		},
-		{
-			"from": [1, 0, 1],
-			"to": [15, 10, 15],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]},
-			"faces": {
-				"north": {"uv": [1.75, 1.75, 3.5, 3], "texture": "#2"},
-				"east": {"uv": [0, 1.75, 1.75, 3], "texture": "#2"},
-				"south": {"uv": [5.25, 1.75, 7, 3], "texture": "#2"},
-				"west": {"uv": [3.5, 1.75, 5.25, 3], "texture": "#2"},
-				"up": {"uv": [3.5, 1.75, 1.75, 0], "texture": "#2"},
-				"down": {"uv": [5.25, 0, 3.5, 1.75], "texture": "#2"}
-			}
-		},
-		{
-			"from": [3.999, 1.999, 0.999],
-			"to": [12.001, 10.001, 1.001],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]},
-			"faces": {
-				"north": {"uv": [0, 7.375, 1, 8.375], "texture": "#2"},
-				"east": {"uv": [0, 7.375, 0, 8.375], "texture": "#2"},
-				"south": {"uv": [1, 7.375, 2, 8.375], "texture": "#2"},
-				"west": {"uv": [1, 7.375, 1, 8.375], "texture": "#2"},
-				"up": {"uv": [1, 7.375, 0, 7.375], "texture": "#2"},
-				"down": {"uv": [2, 7.375, 1, 7.375], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 5],
-			"to": [14, 12, 6],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 1]},
-			"faces": {
-				"north": {"uv": [5.125, 3.375, 6.625, 3.5], "texture": "#2"},
-				"east": {"uv": [4.75, 3.375, 4.875, 3.5], "texture": "#2"},
-				"south": {"uv": [7, 3.375, 8.5, 3.5], "texture": "#2"},
-				"west": {"uv": [6.875, 3.375, 7, 3.5], "texture": "#2"},
-				"up": {"uv": [6.625, 3.125, 5.125, 3], "texture": "#2"},
-				"down": {"uv": [8.125, 3, 6.625, 3.125], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 4],
-			"to": [14, 12, 5],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 1]},
-			"faces": {
-				"north": {"uv": [5.125, 3.375, 6.625, 3.5], "texture": "#2"},
-				"east": {"uv": [4.875, 3.375, 5, 3.5], "texture": "#2"},
-				"south": {"uv": [7, 3.375, 8.5, 3.5], "texture": "#2"},
-				"west": {"uv": [6.75, 3.375, 6.875, 3.5], "texture": "#2"},
-				"up": {"uv": [6.625, 3.25, 5.125, 3.125], "texture": "#2"},
-				"down": {"uv": [8.125, 3.125, 6.625, 3.25], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 3],
-			"to": [14, 12, 4],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 1]},
-			"faces": {
-				"north": {"uv": [5.125, 3.375, 6.625, 3.5], "texture": "#2"},
-				"east": {"uv": [5, 3.375, 5.125, 3.5], "texture": "#2"},
-				"south": {"uv": [7, 3.375, 8.5, 3.5], "texture": "#2"},
-				"west": {"uv": [6.625, 3.375, 6.75, 3.5], "texture": "#2"},
-				"up": {"uv": [6.625, 3.375, 5.125, 3.25], "texture": "#2"},
-				"down": {"uv": [8.125, 3.25, 6.625, 3.375], "texture": "#2"}
-			}
-		},
-		{
-			"from": [10, 11, 6],
-			"to": [14, 12, 8],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 1]},
-			"faces": {
-				"north": {"uv": [5, 4.25, 5.5, 4.375], "texture": "#2"},
-				"east": {"uv": [4.75, 4.25, 5, 4.375], "texture": "#2"},
-				"south": {"uv": [5.75, 4.25, 6.25, 4.375], "texture": "#2"},
-				"west": {"uv": [5.5, 4.25, 5.75, 4.375], "texture": "#2"},
-				"up": {"uv": [5.5, 4.25, 5, 4], "texture": "#2"},
-				"down": {"uv": [6, 4, 5.5, 4.25], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 6],
-			"to": [6, 12, 8],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 1]},
-			"faces": {
-				"north": {"uv": [5, 4.625, 5.5, 4.75], "texture": "#2"},
-				"east": {"uv": [4.75, 4.625, 5, 4.75], "texture": "#2"},
-				"south": {"uv": [5.75, 4.625, 6.25, 4.75], "texture": "#2"},
-				"west": {"uv": [5.5, 4.625, 5.75, 4.75], "texture": "#2"},
-				"up": {"uv": [5.5, 4.625, 5, 4.375], "texture": "#2"},
-				"down": {"uv": [6, 4.375, 5.5, 4.625], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 10],
-			"to": [14, 12, 11],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [5.125, 3.875, 6.625, 4], "texture": "#2"},
-				"east": {"uv": [5, 3.875, 5.125, 4], "texture": "#2"},
-				"south": {"uv": [7, 3.875, 8.5, 4], "texture": "#2"},
-				"west": {"uv": [6.625, 3.875, 6.75, 4], "texture": "#2"},
-				"up": {"uv": [6.625, 3.875, 5.125, 3.75], "texture": "#2"},
-				"down": {"uv": [8.125, 3.75, 6.625, 3.875], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 11],
-			"to": [14, 12, 12],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [5.125, 3.875, 6.625, 4], "texture": "#2"},
-				"east": {"uv": [4.875, 3.875, 5, 4], "texture": "#2"},
-				"south": {"uv": [7, 3.875, 8.5, 4], "texture": "#2"},
-				"west": {"uv": [6.75, 3.875, 6.875, 4], "texture": "#2"},
-				"up": {"uv": [6.625, 3.75, 5.125, 3.625], "texture": "#2"},
-				"down": {"uv": [8.125, 3.625, 6.625, 3.75], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 12],
-			"to": [14, 12, 13],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [5.125, 3.875, 6.625, 4], "texture": "#2"},
-				"east": {"uv": [4.75, 3.875, 4.875, 4], "texture": "#2"},
-				"south": {"uv": [7, 3.875, 8.5, 4], "texture": "#2"},
-				"west": {"uv": [6.875, 3.875, 7, 4], "texture": "#2"},
-				"up": {"uv": [6.625, 3.625, 5.125, 3.5], "texture": "#2"},
-				"down": {"uv": [8.125, 3.5, 6.625, 3.625], "texture": "#2"}
-			}
-		},
-		{
-			"from": [10, 11, 8],
-			"to": [14, 12, 10],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.25, 5, 6.75, 5.125], "texture": "#2"},
-				"east": {"uv": [6, 5, 6.25, 5.125], "texture": "#2"},
-				"south": {"uv": [7, 5, 7.5, 5.125], "texture": "#2"},
-				"west": {"uv": [6.75, 5, 7, 5.125], "texture": "#2"},
-				"up": {"uv": [6.75, 5, 6.25, 4.75], "texture": "#2"},
-				"down": {"uv": [7.25, 4.75, 6.75, 5], "texture": "#2"}
-			}
-		},
-		{
-			"from": [6, 11, 9],
-			"to": [10, 12, 10],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.125, 5.625, 6.625, 5.75], "texture": "#2"},
-				"east": {"uv": [6, 5.625, 6.125, 5.75], "texture": "#2"},
-				"south": {"uv": [6.75, 5.625, 7.25, 5.75], "texture": "#2"},
-				"west": {"uv": [6.625, 5.625, 6.75, 5.75], "texture": "#2"},
-				"up": {"uv": [6.625, 5.625, 6.125, 5.5], "texture": "#2"},
-				"down": {"uv": [7.125, 5.5, 6.625, 5.625], "texture": "#2"}
-			}
-		},
-		{
-			"from": [2, 11, 8],
-			"to": [6, 12, 10],
-			"rotation": {"angle": 0, "axis": "y", "origin": [-3, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.25, 5.375, 6.75, 5.5], "texture": "#2"},
-				"east": {"uv": [6, 5.375, 6.25, 5.5], "texture": "#2"},
-				"south": {"uv": [7, 5.375, 7.5, 5.5], "texture": "#2"},
-				"west": {"uv": [6.75, 5.375, 7, 5.5], "texture": "#2"},
-				"up": {"uv": [6.75, 5.375, 6.25, 5.125], "texture": "#2"},
-				"down": {"uv": [7.25, 5.125, 6.75, 5.375], "texture": "#2"}
-			}
-		},
-		{
-			"from": [9, 11, 7],
-			"to": [10, 12, 9],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.5, 4.25, 6.625, 4.375], "texture": "#2"},
-				"east": {"uv": [6.25, 4.25, 6.5, 4.375], "texture": "#2"},
-				"south": {"uv": [6.875, 4.25, 7, 4.375], "texture": "#2"},
-				"west": {"uv": [6.625, 4.25, 6.875, 4.375], "texture": "#2"},
-				"up": {"uv": [6.625, 4.25, 6.5, 4], "texture": "#2"},
-				"down": {"uv": [6.75, 4, 6.625, 4.25], "texture": "#2"}
-			}
-		},
-		{
-			"from": [6, 11, 7],
-			"to": [7, 12, 9],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.5, 4.625, 6.625, 4.75], "texture": "#2"},
-				"east": {"uv": [6.25, 4.625, 6.5, 4.75], "texture": "#2"},
-				"south": {"uv": [6.875, 4.625, 7, 4.75], "texture": "#2"},
-				"west": {"uv": [6.625, 4.625, 6.875, 4.75], "texture": "#2"},
-				"up": {"uv": [6.625, 4.625, 6.5, 4.375], "texture": "#2"},
-				"down": {"uv": [6.75, 4.375, 6.625, 4.625], "texture": "#2"}
-			}
-		},
-		{
-			"from": [7, 11, 7],
-			"to": [9, 12, 9],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.25, 6.25, 6.5, 6.375], "texture": "#2"},
-				"east": {"uv": [6, 6.25, 6.25, 6.375], "texture": "#2"},
-				"south": {"uv": [6.75, 6.25, 7, 6.375], "texture": "#2"},
-				"west": {"uv": [6.5, 6.25, 6.75, 6.375], "texture": "#2"},
-				"up": {"uv": [6.5, 6.25, 6.25, 6], "texture": "#2"},
-				"down": {"uv": [6.75, 6, 6.5, 6.25], "texture": "#2"}
-			}
-		},
-		{
-			"from": [6, 11, 6],
-			"to": [10, 12, 7],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 11, 6]},
-			"faces": {
-				"north": {"uv": [6.125, 5.875, 6.625, 6], "texture": "#2"},
-				"east": {"uv": [6, 5.875, 6.125, 6], "texture": "#2"},
-				"south": {"uv": [6.75, 5.875, 7.25, 6], "texture": "#2"},
-				"west": {"uv": [6.625, 5.875, 6.75, 6], "texture": "#2"},
-				"up": {"uv": [6.625, 5.875, 6.125, 5.75], "texture": "#2"},
-				"down": {"uv": [7.125, 5.75, 6.625, 5.875], "texture": "#2"}
-			}
-		},
-		{
-			"from": [0, 13, 11],
-			"to": [0, 15, 12],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, -2]},
-			"faces": {
-				"north": {"uv": [6.375, 6.5, 6.375, 6.75], "texture": "#2"},
-				"east": {"uv": [6.25, 6.5, 6.375, 6.75], "texture": "#2"},
-				"south": {"uv": [6.5, 6.5, 6.5, 6.75], "texture": "#2"},
-				"west": {"uv": [6.375, 6.5, 6.5, 6.75], "texture": "#2"},
-				"up": {"uv": [6.375, 6.5, 6.375, 6.375], "texture": "#2"},
-				"down": {"uv": [6.375, 6.375, 6.375, 6.5], "texture": "#2"}
-			}
-		},
-		{
-			"from": [0, 13, 14],
-			"to": [0, 20, 15],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]},
-			"faces": {
-				"north": {"uv": [6.125, 6.5, 6.125, 7.375], "texture": "#2"},
-				"east": {"uv": [6, 6.5, 6.125, 7.375], "texture": "#2"},
-				"south": {"uv": [6.25, 6.5, 6.25, 7.375], "texture": "#2"},
-				"west": {"uv": [6.125, 6.5, 6.25, 7.375], "texture": "#2"},
-				"up": {"uv": [6.125, 6.5, 6.125, 6.375], "texture": "#2"},
-				"down": {"uv": [6.125, 6.375, 6.125, 6.5], "texture": "#2"}
-			}
-		},
-		{
-			"from": [0, 13, 14],
-			"to": [0, 20, 15],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]},
-			"faces": {
-				"north": {"uv": [6.625, 6.5, 6.625, 7.375], "texture": "#2"},
-				"east": {"uv": [6.5, 6.5, 6.625, 7.375], "texture": "#2"},
-				"south": {"uv": [6.75, 6.5, 6.75, 7.375], "texture": "#2"},
-				"west": {"uv": [6.625, 6.5, 6.75, 7.375], "texture": "#2"},
-				"up": {"uv": [6.625, 6.5, 6.625, 6.375], "texture": "#2"},
-				"down": {"uv": [6.625, 6.375, 6.625, 6.5], "texture": "#2"}
-			}
-		},
-		{
-			"from": [0, 13, 14],
-			"to": [0, 20, 15],
-			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 1]},
-			"faces": {
-				"north": {"uv": [6.875, 6.5, 6.875, 7.375], "texture": "#2"},
-				"east": {"uv": [6.75, 6.5, 6.875, 7.375], "texture": "#2"},
-				"south": {"uv": [7, 6.5, 7, 7.375], "texture": "#2"},
-				"west": {"uv": [6.875, 6.5, 7, 7.375], "texture": "#2"},
-				"up": {"uv": [6.875, 6.5, 6.875, 6.375], "texture": "#2"},
-				"down": {"uv": [6.875, 6.375, 6.875, 6.5], "texture": "#2"}
-			}
-		}
-	],
-	"groups": [
-		{
-			"name": "bone",
-			"origin": [1, 0, 1],
-			"color": 0,
-			"children": [
-				{
-					"name": "bone9",
-					"origin": [12.5, 11.5, 0],
-					"color": 0,
-					"children": [0]
-				},
-				1,
-				2,
-				{
-					"name": "bone5",
-					"origin": [9, 12, 1],
-					"color": 0,
-					"children": [3]
-				},
-				{
-					"name": "bone4",
-					"origin": [12.5, 11.5, 0],
-					"color": 0,
-					"children": [4]
-				},
-				5,
-				6,
-				7,
-				{
-					"name": "bone8",
-					"origin": [8, 6, 1],
-					"color": 0,
-					"children": [8]
-				},
-				{
-					"name": "opening",
-					"origin": [8, 11.5, 6],
-					"color": 0,
-					"children": [
-						{
-							"name": "bone3",
-							"origin": [8, 11.5, 3],
-							"color": 0,
-							"children": [
-								{
-									"name": "bone10",
-									"origin": [8, 11.5, 5.5],
-									"color": 0,
-									"children": [
-										9,
-										{
-											"name": "bone11",
-											"origin": [8, 11.5, 4.5],
-											"color": 0,
-											"children": [
-												10,
-												{
-													"name": "bone12",
-													"origin": [8, 11.5, 3.5],
-													"color": 0,
-													"children": [11]
-												}
-											]
-										}
-									]
-								},
-								12,
-								13
-							]
-						},
-						{
-							"name": "bone2",
-							"origin": [8, 11.5, 13.0375],
-							"color": 0,
-							"children": [
-								{
-									"name": "bone13",
-									"origin": [8, 11.5, 10.5],
-									"color": 0,
-									"children": [
-										14,
-										{
-											"name": "bone14",
-											"origin": [8, 11.5, 11.5],
-											"color": 0,
-											"children": [15]
-										},
-										{
-											"name": "bone15",
-											"origin": [8, 11.5, 12.5],
-											"color": 0,
-											"children": [16]
-										}
-									]
-								},
-								17,
-								18,
-								19,
-								20,
-								21,
-								22,
-								23
-							]
-						}
-					]
-				},
-				24,
-				{
-					"name": "bone7",
-					"origin": [1, 0, 1],
-					"color": 0,
-					"children": [
-						{
-							"name": "bone6",
-							"origin": [0, 16.5, 14.5],
-							"color": 0,
-							"children": [25]
-						},
-						{
-							"name": "bone5red",
-							"origin": [0, 16.5, 14.5],
-							"color": 0,
-							"children": [26]
-						},
-						{
-							"name": "bone8green",
-							"origin": [0, 16.5, 14.5],
-							"color": 0,
-							"children": [27]
-						}
-					]
-				}
-			]
-		}
-	]
-}
@@ -1,137 +0,0 @@
-# Changelog
-## [1.7.2 (January 25th, 2026)](#1-7-2)
-
-### Additions
- Added Saccharine wood furniture for Adorn.
- Added the Partner Mark, which party Pokémon have a very small chance to earn as the player walks, provided they have enough friendship.
- Added decorative block models for existing items: Potion, Super Potion, Hyper Potion, Max Potion, Full Restore, Antidote, Awakening, Burn Heal, Ice Heal, Paralyze Heal, Full Heal, Ether, Elixir, Max Ether, Max Elixir, X Accuracy, X Attack, X Defence, X Special Attack, X Special Defence, X Speed, Dire Hit, Guard Spec, Weakness Policy, Blunder Policy, Cleanse Tag, and Spell Tag.
- Added decorative sign blocks called Plaques.
- Added ride style labels to ride stats in Pokédex, as well as ride style icons in the summary GUI.
- Added more seasonings for sinister tea:
-  - Mental Herb - Mental Restoration I for 10 seconds, which staves off Insomnia.
-  - White Herb - Removes negative effects.
-  - Milk, Moomoo Milk - Removes effects.
- Added dispenser support for:
-  - Applying a Honey Bottle to Saccharine Logs.
-  - Washing honey off of Saccharine Slathered Logs.
-  - Applying and removing honey on Saccharine Leaves.
- Added riding statistics: `Distance by Pokémon on Land`, `Distance by Pokémon in Air` and `Distance by Pokémon in Liquid`.
-
-### New rideable Pokémon
- Honchkrow 
- Mantine
-
-### Pokémon Added
-
-#### Gen 5
- Throh
- Sawk
-
-#### Gen 6
- Litleo
- Pyroar
- Spritzee
- Aromatisse
- Swirlix
- Slurpuff
-
-### Model updates for the following Pokémon
- Falinks
- Cottonee
- Whimsicott
- Ferroseed
- Ferrothorn
- Chingling
- Chimecho
-
-### Animation updates for the following Pokémon
- Mantine (ride animations)
- Flygon (ride jump animation)
- Honchkrow (ride animations)
- Croagunk
- Toxicroak
-
-### Changes
- Added a new config option, `Enable In-Flight Dismounting` (default: off), which lets you dismount while riding a Pokémon in the air. This is the textbook definition of caveat emptor.
- Ride sounds have been separated into stereo for passengers and mono for other players. Riding will now sound more spacious.
- Battle AI now uses a smarter threshold for switching, reducing unnecessary switches.
- AI will always use the most damaging move when at low HP and when it is not switching, improving endgame decision-making.
- Items given from interacting with Saccharine Leaves are placed in the active hotbar slot if possible.
- Added `label` as an alternate key to the `tag` property.
-
-### Fixes
- Fixed crashing when viewing another player in spectator mode. Some said this was reason to release this update a month ago. They were probably right.
- Fixed crashing when sending a Pokémon out after editing its form.
- Fixed all Pokémon being saved to chunks and never despawning even when they should be.
- Fixed Poké Snacks crashing if there was no available spawn.
- Fixed Poké Snack / Bait effects so that EV Yield, Type, and Egg Group filters now all apply together when weighting spawns. And you thought you were going crazy.
- Fixed Furfrou not being trimmable on NeoForge specifically.
- Fixed honey from Saccharine Leaves being harvestable at less than the max age.
- Fixed possible error on world generation when Combee are placed in naturally generated bee nests.
- Fixed Galarian Weezing crashing the world if it decides to blink the wrong way. The same could happen to you!
- Fixed Galarian Mr. Mime incorrectly being rideable. Some would argue that regular Mr. Mime shouldn't be rideable, but that would make them wrong.
- Fixed missing apricorn textures for Adorn blocks.
- Fixed Apricorn block model rotation for counters/sinks/cupboards/drawers to match that of most recent version of Adorn.
- Fixed item interaction sometimes not working properly when playing on servers.
- Fixed Mint Leaves not being usable for filling the Resurrection Machine.
- Fixed Super Potion recipes incorrectly using Hondew Berry instead of Aguav Berry. They look similar, to be fair.
- Fixed Wishiwashi not schooling properly.
- Fixed battle item duplication issue. How did it work? Wouldn't you like to know, weather boy.
- Fixed the ordering of Aprijuice's riding stat boosts so they always have the same order.
- Fixed the movesets of certain Pokémon being incorrectly sanitized upon reload, causing some forms to keep losing moves.
- Fixed selected leading Pokémon in battle not being used when levels are set.
- Fixed the bottom half of pasture blocks having an incorrect hit-box when facing north or south.
- Fixed gimmicks not being usable in double and triple battles.
- Fixed gimmick buttons showing when already used in the same turn in double and triple battles.
- Fixed mochi items consuming two items at a time.
- Fixed Fresh Start Mochi's EV reset not syncing health changes properly.
- Fixed Pokémon spawn influences not being specific to regional forms.
- Fixed memory leak from battles not being cleaned up after ending.
- Fixed orientation not getting reset after crashing while flying and getting back on the Pokémon.
- Fixed shiny Pokémon not respecting the `silent` flag on spawn.
- Fixed 'Plain' prefix not being applied to all low-quality Aprijuice.
- Fixed Pokémon interactions not playing sound effects when the volume was not specified.
- Fixed Pokémon interaction cooldowns taking longer than intended when the Pokémon was in the player’s party.
- Fixed Pokémon interactions occasionally crashing the game when spamming an interaction with a 0 cooldown.
- Fixed Pokémon fullness decreasing more than intended when the Pokémon was pastured.
- Fixed Scraggy line, Milcery line, and Morpeko spawning on unnatural blocks. 
- Fixed invulnerability-bypassed damage being resisted by invulnerable NPC entities.
- Fixed Fabric network packets not being handled immediately, fixing incompatibilities with Supplementaries, Prometheus, Sleep Tight, and others.
- Fixed killer not being set early enough on a wild Pokémon entity from `WinInstruction`.
- Fixed requirements such as `biomeCondition` crashing the game when used to define Pokémon interactions.
- Fixed an issue that prevented registering custom dispenser behaviours (no longer overrides vanilla behaviour).
- Fixed an issue navigation that prevented Combee from pathing into and out of Saccharine Leaves.
- Added Saccharine Boats and Saccharine Boat with Chests to relevant boat tags.
- Fixed Soothe Bell not being properly tagged as a held item.
- Fixed `/calculateseatpositions` expecting a locator format that even we don't use. It needs an underscore after "seat".
- Fixed the `run_script` Molang function to not fail if the environment's context is null.
- Fixed the Molang functions `date_local_time`, `date_of`, `date_is_after` to use the correct date format.
-
-### Developer
- Changed the `owner` parameter in the `OwnerQueryRequirement` interface from `ServerPlayer` to `Player`. This method is now also called on the client to verify whether a Pokémon interaction succeeded, so make sure to update your implementations to handle both server and client contexts.
- Added the `pnx` to the `BattleFaintedEvent` and `FormeChangeEvent`.
- Added register methods for custom instructions to `ShowdownInterpreter`.
- Changed callback operations in `BattlePokemon` to allow multiple callbacks and be mutable.
- Added `display_name`, `description`, and `max_pp` functions to the `MoveTemplate` struct.
- Changed the implementations of `AIBattleActor` to be open classes to allow extension.
- Changed the resource location of Poké Ball icons in the GUI to use the balls namespace instead of Cobblemon's, allowing mods to properly use their own namespace for these textures.
-
-### Molang & Datapacks
- Ride sounds can now be set as exclusive to passengers.
- Ride sounds no longer play when submerged unless specified with a new setting.
- Exception handling has been added to `run_molang`, resolving some crashes caused by malformed MoLang expressions.
- Added the `create_itemstack`, `has_inventory_space`, `set_inventory_slot`, and `give_item` MoLang functions for item and inventory utility.
- Added the `get_move_from_id` MoLang function for general move info queries without requiring a Moveset object to access.
- Added support for optional message variants in battle activate instructions for more context-specific battle text.
-  - Example: `this.add('-activate', pokemon, 'ability: example', '[msg]message1');` will parse to lang key `cobblemon.battle.activate.example.message1`.
-
-### Localization
- Updated translations for:
-  - French
-  - Canadian French
-  - Simplified Chinese
-  - Ukrainian
-  - Brazilian Portuguese
-  - Spanish
-  - Korean
-  - Japanese
@@ -1,22 +0,0 @@
-# Changelog
-## [1.7.3 (January 31st, 2026)](#1-7-3)
-
-### Fixes
- Fixed mounted Pokémon not playing sounds.
- Fixed players failing to join servers randomly.
- Fixed some Pokémon having no stamina for flying.
- Fixed `/pctake` not respecting the actual size of the PC.
-### Developer
- Poké Ball GUI textures now respect the ball's namespace, enabling proper texture loading for custom balls from other mods.
-
-### Molang & Datapacks
- Added a `chance` requirement type for Pokémon interactions.
-
-### Localization
- Updated translations for:
-  - French
-  - Canadian French
-  - Korean
-  - Portuguese
-  - Simplified Chinese
-  - Spanish
@@ -55,7 +55,7 @@ dependencies {
    // modCompileOnly(libs.flywheelFabric)

    // Showdown
-    modCompileOnly(libs.graal.core)
+    modCompileOnly(libs.graal)

    // Data Storage
    modCompileOnly(libs.bundles.mongo)
@@ -1,146 +0,0 @@
-/*
- * 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.camera;
-
-import com.cobblemon.mod.common.client.util.compat.SodiumCompat;
-import com.cobblemon.mod.common.platform.events.ClientChunkEvent;
-import com.cobblemon.mod.common.platform.events.PlatformEvents;
-import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
-import kotlin.Unit;
-import kotlin.jvm.functions.Function1;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.LevelChunk;
-
-import java.util.function.Consumer;
-
-public class CameraClientChunkCacheExtension {
-    private static final int MIN_RENDER_DISTANCE = 2;
-    private static final int MAX_RENDER_DISTANCE = 64;
-    private static final int RENDER_DISTANCE_MARGIN = 2;
-
-    private static final Long2ObjectOpenHashMap<LevelChunk> CHUNK_MAP = new Long2ObjectOpenHashMap<>();
-    private static final Long2ObjectOpenHashMap<LevelChunk> CHUNK_MAP_OTHER_THREADS = new Long2ObjectOpenHashMap<>();
-    private static volatile ChunkPos CAMERA_CENTER;
-
-    private CameraClientChunkCacheExtension() {}
-
-    public static void drop(ClientLevel level, ChunkPos chunkPos) {
-        if (Minecraft.getInstance().isSameThread()) {
-            long chunkPosLong = chunkPos.toLong();
-            LevelChunk chunk = CHUNK_MAP.get(chunkPosLong);
-
-            if (chunk != null) {
-                modifyChunkMaps(map -> map.remove(chunkPosLong));
-                SodiumCompat.getInstance().notifyChunkRemoved(level, chunkPos.x, chunkPos.z);
-                PlatformEvents.CLIENT_CHUNK_UNLOAD.postEvents(new ClientChunkEvent.Unload(chunk, level));
-                level.unload(chunk);
-            }
-        }
-    }
-
-    public static LevelChunk getChunk(int x, int z) {
-        long chunkPos = ChunkPos.asLong(x, z);
-
-        if (Minecraft.getInstance().isSameThread())
-            return CHUNK_MAP.get(chunkPos);
-        else {
-            synchronized (CHUNK_MAP_OTHER_THREADS) {
-                return CHUNK_MAP_OTHER_THREADS.get(chunkPos);
-            }
-        }
-    }
-
-    public static LevelChunk replaceWithPacketData(ClientLevel level, int x, int z, FriendlyByteBuf packetData, CompoundTag chunkTag, Consumer<ClientboundLevelChunkPacketData.BlockEntityTagOutput> tagOutput) {
-        if (!Minecraft.getInstance().isSameThread())
-            throw new UnsupportedOperationException("replaceWithPacketData called off-thread, this shouldn't happen!");
-
-        ChunkPos chunkPos = new ChunkPos(x, z);
-        long longChunkPos = chunkPos.toLong();
-        LevelChunk chunk = CHUNK_MAP.get(longChunkPos);
-
-        if (chunk == null) {
-            LevelChunk newChunk = new LevelChunk(level, chunkPos);
-
-            chunk = newChunk;
-            chunk.replaceWithPacketData(packetData, chunkTag, tagOutput);
-            modifyChunkMaps(map -> map.put(longChunkPos, newChunk));
-        }
-
-        level.onChunkLoaded(chunkPos);
-        SodiumCompat.getInstance().notifyChunkAdded(level, x, z);
-        PlatformEvents.CLIENT_CHUNK_LOAD.postEvents(new ClientChunkEvent.Load(chunk, level));
-        return chunk;
-    }
-
-    private static void modifyChunkMaps(Consumer<Long2ObjectOpenHashMap<LevelChunk>> operation) {
-        operation.accept(CHUNK_MAP);
-
-        synchronized (CHUNK_MAP_OTHER_THREADS) {
-            operation.accept(CHUNK_MAP_OTHER_THREADS);
-        }
-    }
-
-    public static void clear() {
-        CHUNK_MAP.clear();
-        CHUNK_MAP_OTHER_THREADS.clear();
-        CAMERA_CENTER = null;
-    }
-
-    public static boolean hasCameraChunks() {
-        if (Minecraft.getInstance().isSameThread()) {
-            return !CHUNK_MAP.isEmpty();
-        } else {
-            synchronized (CHUNK_MAP_OTHER_THREADS) {
-                return !CHUNK_MAP_OTHER_THREADS.isEmpty();
-            }
-        }
-    }
-
-    /**
-     * Computes render distance using Chebyshev distance with a safety margin.
-     */
-    public static int getSuggestedRenderDistance(ChunkPos center) {
-        int maxDistance = 0;
-
-        if (Minecraft.getInstance().isSameThread()) {
-            for (long key : CHUNK_MAP.keySet()) {
-                int x = ChunkPos.getX(key);
-                int z = ChunkPos.getZ(key);
-                int dx = Math.abs(x - center.x);
-                int dz = Math.abs(z - center.z);
-                maxDistance = Math.max(maxDistance, Math.max(dx, dz));
-            }
-        } else {
-            synchronized (CHUNK_MAP_OTHER_THREADS) {
-                for (long key : CHUNK_MAP_OTHER_THREADS.keySet()) {
-                    int x = ChunkPos.getX(key);
-                    int z = ChunkPos.getZ(key);
-                    int dx = Math.abs(x - center.x);
-                    int dz = Math.abs(z - center.z);
-                    maxDistance = Math.max(maxDistance, Math.max(dx, dz));
-                }
-            }
-        }
-
-        return Math.max(MIN_RENDER_DISTANCE, Math.min(MAX_RENDER_DISTANCE, maxDistance + RENDER_DISTANCE_MARGIN));
-    }
-
-    public static void setCameraCenter(ChunkPos center) {
-        CAMERA_CENTER = center;
-    }
-
-    public static ChunkPos getCameraCenter() {
-        return CAMERA_CENTER;
-    }
-}
@@ -1,86 +0,0 @@
-/*
- * 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.camera;
-
-import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
-import net.minecraft.client.renderer.chunk.SectionRenderDispatcher;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.SectionPos;
-import net.minecraft.world.level.Level;
-
-public final class CameraViewAreaExtension {
-    private static final Long2ObjectOpenHashMap<SectionRenderDispatcher.RenderSection> SECTIONS = new Long2ObjectOpenHashMap<>();
-    private static SectionRenderDispatcher sectionRenderDispatcher;
-    private static int minSectionY;
-    private static int maxSectionY;
-
-    private CameraViewAreaExtension() {
-    }
-
-    public static void allChanged(SectionRenderDispatcher dispatcher, Level level) {
-        clear();
-        sectionRenderDispatcher = dispatcher;
-        minSectionY = level.getMinSection();
-        maxSectionY = level.getMaxSection();
-    }
-
-    public static SectionRenderDispatcher.RenderSection rawFetch(int cx, int cy, int cz, boolean generateNew) {
-        if (cy < minSectionY || cy >= maxSectionY) {
-            return null;
-        }
-
-        long sectionPos = SectionPos.asLong(cx, cy, cz);
-        return generateNew ? provideSection(sectionPos) : SECTIONS.get(sectionPos);
-    }
-
-    public static void setDirty(int cx, int cy, int cz, boolean playerChanged) {
-        SectionRenderDispatcher.RenderSection section = rawFetch(cx, cy, cz, false);
-        if (section != null) {
-            section.setDirty(playerChanged);
-        }
-    }
-
-    public static void onChunkUnload(int sectionX, int sectionZ) {
-        for (int sectionY = minSectionY; sectionY < maxSectionY; sectionY++) {
-            long sectionPos = SectionPos.asLong(sectionX, sectionY, sectionZ);
-            SectionRenderDispatcher.RenderSection section = SECTIONS.remove(sectionPos);
-
-            if (section != null) {
-                section.releaseBuffers();
-            }
-        }
-    }
-
-    public static void clear() {
-        for (SectionRenderDispatcher.RenderSection section : SECTIONS.values()) {
-            section.releaseBuffers();
-        }
-        SECTIONS.clear();
-    }
-
-    public static int minSectionY() {
-        return minSectionY;
-    }
-
-    public static int maxSectionY() {
-        return maxSectionY;
-    }
-
-    private static SectionRenderDispatcher.RenderSection provideSection(long sectionPos) {
-        return SECTIONS.computeIfAbsent(sectionPos, CameraViewAreaExtension::createSection);
-    }
-
-    private static SectionRenderDispatcher.RenderSection createSection(long sectionPos) {
-        if (sectionRenderDispatcher == null) {
-            throw new IllegalStateException("SectionRenderDispatcher not initialised");
-        }
-        BlockPos origin = SectionPos.of(sectionPos).origin();
-        return sectionRenderDispatcher.new RenderSection(0, origin.getX(), origin.getY(), origin.getZ());
-    }
-}
@@ -1,15 +0,0 @@
-/*
- * 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.camera.accessor;
-
-import net.minecraft.client.renderer.culling.Frustum;
-
-public interface CameraLevelRendererAccessor {
-    Frustum cobblemonGetFrustum();
-}
@@ -15,8 +15,6 @@ import com.cobblemon.mod.common.api.events.CobblemonEvents;
 import com.cobblemon.mod.common.api.events.item.LeftoversCreatedEvent;
 import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.pokemon.PokemonSpecies;
-import com.cobblemon.mod.common.api.riding.RidingStyle;
-import com.cobblemon.mod.common.api.riding.behaviour.types.air.HoverBehaviour;
 import com.cobblemon.mod.common.api.storage.party.PartyStore;
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore;
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags;
@@ -61,7 +59,6 @@ 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;
-import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;

@@ -172,32 +169,6 @@ public abstract class PlayerMixin extends LivingEntity implements ScannableEntit
        }
    }

-    @Redirect(
-            method = "getDestroySpeed",
-            at = @At(
-                    value = "INVOKE",
-                    target = "Lnet/minecraft/world/entity/player/Player;onGround()Z"
-            )
-    )
-    private boolean cobblemon$considerHoverOnGround(Player player) {
-        // If riding a Hover Mount, return true to bypass the 5x slowdown
-        if (player.getVehicle() instanceof PokemonEntity vehicle) {
-
-            var ridingController = vehicle.getRidingController();
-            if (ridingController == null) player.onGround();
-
-            var activeContext = ridingController.getContext();
-            if (activeContext == null) player.onGround();
-
-            if (activeContext.getStyle() == RidingStyle.AIR &&
-                activeContext.getBehaviour().equals(HoverBehaviour.Companion.getKEY())) {
-                return true;
-            }
-        }
-        // Otherwise, return the actual value
-        return player.onGround();
-    }
-
    @Inject(
        method = "eat",
        at = @At(
@@ -33,7 +33,7 @@ public class SimpleBlockFeatureMixin {
        if (!(blockState.getBlock() instanceof HeartyGrainsBlock)) {
            return;
        }
-        if (blockState.getValue(HeartyGrainsBlock.Companion.getAGE()) <= HeartyGrainsBlock.AGE_AFTER_HARVEST) {
+        if (blockState.getValue(HeartyGrainsBlock.AGE) <= HeartyGrainsBlock.AGE_AFTER_HARVEST) {
            return; //block is too young to be double
        }
        if (!worldGenLevel.isEmptyBlock(blockPos.above())) {
@@ -43,4 +43,4 @@ public class SimpleBlockFeatureMixin {
        DoublePlantBlock.placeAt(worldGenLevel, blockState, blockPos, Block.UPDATE_CLIENTS);
        cir.setReturnValue(true);
    }
-}
+}
@@ -1,23 +0,0 @@
-/*
- * 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.mixin.accessor;
-
-import net.minecraft.client.Camera;
-import net.minecraft.world.level.BlockGetter;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(Camera.class)
-public interface CameraAccessor {
-    @Accessor("level")
-    BlockGetter getLevel();
-
-    @Accessor("detached")
-    void setDetached(boolean detached);
-}
@@ -1,26 +0,0 @@
-/*
- * 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.mixin.accessor;
-
-import net.minecraft.world.item.Item;
-import net.minecraft.core.dispenser.DispenseItemBehavior;
-import net.minecraft.world.level.block.DispenserBlock;
-
-import java.util.Map;
-
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(DispenserBlock.class)
-public interface DispenserBlockAccessor {
-	@Accessor("DISPENSER_REGISTRY")
-	static Map<Item, DispenseItemBehavior> getItemBehaviors() {
-		throw new AssertionError();
-	}
-}
@@ -1,23 +0,0 @@
-/*
- * 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.mixin.accessor;
-
-import net.minecraft.client.Camera;
-import net.minecraft.client.renderer.GameRenderer;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-@Mixin(GameRenderer.class)
-public interface GameRendererAccessor {
-    @Accessor("mainCamera")
-    Camera cobblemon$getMainCamera();
-
-    @Accessor("mainCamera")
-    void cobblemon$setMainCamera(Camera camera);
-}
@@ -1,105 +0,0 @@
-/*
- * 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.mixin.camera;
-
-import java.util.HashSet;
-import java.util.Set;
-
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import com.cobblemon.mod.common.api.camera.CameraManager;
-import com.cobblemon.mod.common.api.camera.CameraManager.ChunkViewUpdate;
-import com.llamalad7.mixinextras.sugar.Local;
-import com.mojang.logging.LogUtils;
-
-import net.minecraft.server.level.ChunkMap;
-import net.minecraft.server.level.ChunkTrackingView;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.LevelChunk;
-import org.slf4j.Logger;
-
-@Mixin(value = ChunkMap.class, priority = 1100)
-public abstract class ChunkMapMixin {
-    private static final Logger COBBLEMON$CAMERA_LOGGER = LogUtils.getLogger();
-
-    @Shadow
-    protected abstract void markChunkPendingToSend(ServerPlayer player, ChunkPos pos);
-
-    @Shadow
-    private static void markChunkPendingToSend(ServerPlayer player, LevelChunk chunk) {}
-
-    @Shadow
-    private static void dropChunk(ServerPlayer player, ChunkPos chunkPos) {}
-
-    @Inject(method = "updateChunkTracking", at = @At("HEAD"))
-    private void cobblemon$handleCameraChunkUpdates(ServerPlayer player, CallbackInfo ci) {
-        ChunkViewUpdate update = CameraManager.consumeChunkViewUpdate(player);
-
-        if (update != null) {
-            ChunkTrackingView playerView = player.getChunkTrackingView();
-            ChunkTrackingView current = update.getCurrent();
-            ChunkTrackingView previous = update.getPrevious();
-
-            if (current != null) {
-                ChunkTrackingView.difference(playerView, current, chunkPos -> cobblemon$queueChunkForPlayer(player, chunkPos), chunkPos -> {});
-            }
-
-            if (previous != null) {
-                Set<ChunkPos> droppingChunks = new HashSet<>();
-
-                ChunkTrackingView targetComparison = current != null ? current : playerView;
-                ChunkTrackingView.difference(previous, targetComparison, chunkPos -> {}, droppingChunks::add);
-
-                for (ChunkPos chunkPos : droppingChunks) {
-                    if (playerView == null || !playerView.contains(chunkPos)) {
-                        dropChunk(player, chunkPos);
-                    }
-                }
-            }
-        }
-    }
-
-    @Inject(method = "onChunkReadyToSend", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;getChunkTrackingView()Lnet/minecraft/server/level/ChunkTrackingView;"))
-    private void cobblemon$queueCameraChunk(LevelChunk chunk, CallbackInfo ci, @Local ServerPlayer player) {
-        ChunkTrackingView view = CameraManager.getPlayerChunkView(player);
-
-        if (view != null && view.contains(chunk.getPos())) {
-            markChunkPendingToSend(player, chunk);
-        }
-    }
-
-    @Inject(method = "isChunkTracked", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$isCameraChunkTracked(ServerPlayer player, int x, int z, CallbackInfoReturnable<Boolean> cir) {
-        ChunkTrackingView view = CameraManager.getPlayerChunkView(player);
-
-        if (view != null && view.contains(x, z) && !player.connection.chunkSender.isPending(ChunkPos.asLong(x, z))) {
-            cir.setReturnValue(true);
-        }
-    }
-
-    @Inject(method = "dropChunk", at = @At("HEAD"), cancellable = true)
-    private static void cobblemon$preventCameraChunkDrop(ServerPlayer player, ChunkPos pos, CallbackInfo ci) {
-        ChunkTrackingView view = CameraManager.getPlayerChunkView(player);
-
-        if (view != null && view.contains(pos)) {
-            ci.cancel();
-        }
-    }
-
-    private void cobblemon$queueChunkForPlayer(ServerPlayer player, ChunkPos chunkPos) {
-        markChunkPendingToSend(player, chunkPos);
-    }
-}
-
@@ -1,135 +0,0 @@
-/*
- * 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.mixin.client;
-
-import com.cobblemon.mod.common.client.render.camera.CameraFeedHandler;
-import com.cobblemon.mod.common.client.render.camera.CameraViewAreaExtension;
-import com.cobblemon.mod.common.client.render.camera.accessor.CameraLevelRendererAccessor;
-import com.cobblemon.mod.common.client.util.compat.SodiumCompat;
-import com.llamalad7.mixinextras.injector.v2.WrapWithCondition;
-import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import net.minecraft.client.Camera;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.renderer.ViewArea;
-import net.minecraft.client.renderer.chunk.SectionRenderDispatcher;
-import net.minecraft.client.renderer.culling.Frustum;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.SectionPos;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.ModifyVariable;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-@Mixin(value = LevelRenderer.class, priority = 1100)
-public abstract class CameraLevelRendererMixin implements CameraLevelRendererAccessor {
-    private static final int CINEMATIC_RENDER_DISTANCE_CHUNKS = 32;
-    private static final float CINEMATIC_FOG_DISTANCE = CINEMATIC_RENDER_DISTANCE_CHUNKS * 16;
-
-    @Shadow
-    @Final
-    private Minecraft minecraft;
-    @Shadow
-    private SectionRenderDispatcher sectionRenderDispatcher;
-    @Shadow
-    private ClientLevel level;
-
-    @Shadow private Frustum capturedFrustum;
-
-    @Shadow public Frustum cullingFrustum;
-
-    @WrapWithCondition(method = "setupRender", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/ViewArea;repositionCamera(DD)V"))
-    private boolean cobblemon$shouldRepositionCamera(ViewArea viewArea, double x, double z) {
-        return !CameraFeedHandler.isCapturing();
-    }
-
-    /**
-     * Cancel vanilla setupRender during feed capture to avoid overwriting
-     * the camera feed's visible sections. When Sodium is active, let it
-     * proceed since Sodium manages its own chunk rendering pipeline and
-     * needs setupRender to run.
-     */
-    @Inject(method = "setupRender", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$onSetupRender(Camera camera, Frustum frustum, boolean hasCapturedFrustum, boolean isSpectator, CallbackInfo ci) {
-        if (CameraFeedHandler.isCapturing() && !SodiumCompat.getInstance().isActive())
-            ci.cancel();
-    }
-
-    @Inject(method = "allChanged", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/SectionOcclusionGraph;waitAndReset(Lnet/minecraft/client/renderer/ViewArea;)V"))
-    private void cobblemon$onAllChanged(CallbackInfo ci) {
-        CameraViewAreaExtension.allChanged(sectionRenderDispatcher, level);
-    }
-
-    @Inject(method = "isSectionCompiled", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$onIsSectionCompiled(BlockPos pos, CallbackInfoReturnable<Boolean> cir) {
-        if (CameraFeedHandler.isCapturing()) {
-            SectionPos sectionPos = SectionPos.of(pos);
-            SectionRenderDispatcher.RenderSection section = CameraViewAreaExtension.rawFetch(sectionPos.x(), sectionPos.y(), sectionPos.z(), false);
-
-            if (section != null && section.getCompiled() != SectionRenderDispatcher.CompiledSection.UNCOMPILED) {
-                cir.setReturnValue(true);
-            }
-        }
-    }
-
-    @ModifyVariable(method = "renderLevel", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/FogRenderer;setupColor(Lnet/minecraft/client/Camera;FLnet/minecraft/client/multiplayer/ClientLevel;IF)V"), ordinal = 1)
-    private float cobblemon$modifyFogRenderDistance(float original) {
-        if (CameraFeedHandler.isCapturing())
-            return CINEMATIC_FOG_DISTANCE;
-
-        return original;
-    }
-
-    /**
-     * During feed capture the camera entity is a Marker, which causes the vanilla condition
-     * {@code !(entity instanceof LocalPlayer) || camera.getEntity() == entity} to fail for
-     * the local player — preventing them from rendering.
-     *
-     * By returning the local player from {@code getEntity()} and {@code true} from
-     * {@code isDetached()}, both condition2 and condition3 in the entity rendering check pass:
-     * <ul>
-     *   <li>condition2: {@code entity != player || isDetached()==true} → passes</li>
-     *   <li>condition3: {@code player == player} → passes</li>
-     * </ul>
-     */
-    @WrapOperation(
-            method = "renderLevel",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Camera;getEntity()Lnet/minecraft/world/entity/Entity;")
-    )
-    private Entity cobblemon$getCameraEntityDuringCapture(Camera camera, Operation<Entity> original) {
-        if (CameraFeedHandler.isCapturing()) {
-            Entity player = Minecraft.getInstance().player;
-            if (player != null) return player;
-        }
-        return original.call(camera);
-    }
-
-    @WrapOperation(
-            method = "renderLevel",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/client/Camera;isDetached()Z")
-    )
-    private boolean cobblemon$isCameraDetachedDuringCapture(Camera camera, Operation<Boolean> original) {
-        if (CameraFeedHandler.isCapturing()) {
-            return true;
-        }
-        return original.call(camera);
-    }
-
-    @Override
-    public Frustum cobblemonGetFrustum() {
-            return this.capturedFrustum != null ? this.capturedFrustum : this.cullingFrustum;
-    }
-}
@@ -8,32 +8,22 @@

 package com.cobblemon.mod.common.mixin.client;

-import com.cobblemon.mod.common.Cobblemon;
-import com.cobblemon.mod.common.OrientationControllable;
-import com.cobblemon.mod.common.api.camera.CameraRotation;
-import com.cobblemon.mod.common.api.orientation.OrientationController;
 import com.cobblemon.mod.common.api.riding.Rideable;
 import com.cobblemon.mod.common.client.MountedPokemonAnimationRenderController;
-import com.cobblemon.mod.common.client.camera.ClientCameraController;
-import com.cobblemon.mod.common.client.render.camera.CameraFeedHandler;
 import com.cobblemon.mod.common.client.render.camera.MountedCameraRenderer;
 import com.cobblemon.mod.common.duck.CameraDuck;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.Camera;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.LevelRenderer;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.level.BlockGetter;
-import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.phys.Vec3;
 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;

@Mixin(Camera.class)
@@ -42,7 +32,6 @@ public abstract class CameraMixin implements CameraDuck {
    @Shadow private float eyeHeightOld;
    @Shadow private BlockGetter level;
    @Shadow private Entity entity;
-    @Final @Shadow private Quaternionf rotation;
    @Final @Shadow private Vector3f forwards;
    @Final @Shadow private Vector3f up;
    @Final @Shadow private Vector3f left;
@@ -54,11 +43,6 @@ public abstract class CameraMixin implements CameraDuck {
    @Override public BlockGetter cobblemon$getLevel() {
       return level;
    }
-    @Shadow protected abstract void setRotation(float yRot, float xRot);
-
-    @Unique private float returnTimer = 0;
-    @Unique private float rollAngleStart = 0;
-    @Unique Minecraft minecraft = Minecraft.getInstance();

    @Override public Entity cobblemon$getEntity() {
        return entity;
@@ -82,28 +66,6 @@ public abstract class CameraMixin implements CameraDuck {
        Entity vehicle = entity.getVehicle();
        MountedPokemonAnimationRenderController.INSTANCE.reset();

-        // Check for cinematic camera override
-        if (ClientCameraController.isActive()) {
-            // When capturing a feed, use that specific camera's transform
-            // instead of the primary camera to avoid both feeds sharing the same position.
-            java.util.UUID capturedId = CameraFeedHandler.getCurrentlyCapturedCamera();
-            ClientCameraController.ActiveTransform cameraTransform = capturedId != null
-                    ? ClientCameraController.getActiveCameraTransform(capturedId)
-                    : ClientCameraController.getCameraTransform();
-            if (cameraTransform != null) {
-                Vec3 position = cameraTransform.getPosition();
-                CameraRotation rotation = cameraTransform.getRotation();
-                setPosition(new Vec3(position.x, position.y, position.z));
-                setRotation(rotation.getYaw(), rotation.getPitch());
-
-
-                OrientationController.Companion.getFORWARDS().rotate(this.rotation, this.forwards);
-                OrientationController.Companion.getUP().rotate(this.rotation, this.up);
-                OrientationController.Companion.getLEFT().rotate(this.rotation, this.left);
-                return;
-            }
-        }
-
        if(vehicle instanceof Rideable){
            Vec3 position = MountedCameraRenderer.INSTANCE.getCameraPosition(
                instance,
@@ -1,83 +0,0 @@
-/*
- * 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.mixin.client;
-
-import com.cobblemon.mod.common.client.camera.CameraClientChunkCacheExtension;
-import com.cobblemon.mod.common.client.camera.CameraChunkVisibilityManager;
-import com.cobblemon.mod.common.client.render.camera.CameraFeedHandler;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ClientChunkCache;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.network.protocol.game.ClientboundLevelChunkPacketData;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.chunk.LevelChunk;
-import net.minecraft.world.level.chunk.status.ChunkStatus;
-import org.spongepowered.asm.mixin.Final;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.function.Consumer;
-
-@Mixin(value = ClientChunkCache.class, priority = 1100)
-public abstract class ClientChunkCacheMixin {
-    @Shadow
-    volatile ClientChunkCache.Storage storage;
-    @Shadow
-    @Final
-    ClientLevel level;
-    /**
-     * Intercept updateViewCenter to use camera position when active.
-     */
-    @Inject(method = "drop", at = @At("HEAD"))
-    private void cobblemon$onDrop(ChunkPos chunkPos, CallbackInfo ci) {
-        int renderDistance = Minecraft.getInstance().options.renderDistance().get();
-
-        if (CameraChunkVisibilityManager.shouldKeepChunk(chunkPos, renderDistance)
-            || CameraFeedHandler.shouldAddChunk(chunkPos, renderDistance)) {
-            return;
-        }
-
-        CameraClientChunkCacheExtension.drop(level, chunkPos);
-    }
-
-    /**
-     * Override replaceWithPacketData to accept chunks based on camera position.
-     */
-    @Inject(method = "replaceWithPacketData", at = @At("HEAD"), cancellable = true)
-    public void cobblemon$onReplaceWithPacketData(int x, int z, FriendlyByteBuf buffer, CompoundTag chunkTag, Consumer<ClientboundLevelChunkPacketData.BlockEntityTagOutput> tagOutputConsumer, CallbackInfoReturnable<LevelChunk> cir) {
-        int renderDistance = Minecraft.getInstance().options.renderDistance().get();
-        ChunkPos chunkPos = new ChunkPos(x, z);
-        boolean isInPlayerRange = storage.inRange(x, z);
-        boolean shouldAddChunk = CameraChunkVisibilityManager.shouldKeepChunk(chunkPos, renderDistance)
-            || CameraFeedHandler.shouldAddChunk(chunkPos, renderDistance);
-
-        if (shouldAddChunk) {
-            LevelChunk newChunk = CameraClientChunkCacheExtension.replaceWithPacketData(level, x, z, new FriendlyByteBuf(buffer.copy()), chunkTag, tagOutputConsumer);
-            if (!isInPlayerRange)
-                cir.setReturnValue(newChunk);
-        }
-    }
-
-    @Inject(method = "getChunk(IILnet/minecraft/world/level/chunk/status/ChunkStatus;Z)Lnet/minecraft/world/level/chunk/LevelChunk;", at = @At("TAIL"), cancellable = true)
-    private void cobblemon$onGetChunk(int x, int z, ChunkStatus chunkStatus, boolean requireChunk, CallbackInfoReturnable<LevelChunk> cir) {
-        if (!storage.inRange(x, z)) {
-            LevelChunk chunk = CameraClientChunkCacheExtension.getChunk(x, z);
-
-            if (chunk != null)
-                cir.setReturnValue(chunk);
-        }
-    }
-}
-
@@ -9,122 +9,43 @@
 package com.cobblemon.mod.common.mixin.client;

 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker;
-import com.cobblemon.mod.common.api.tween.TweenManager;
-import com.cobblemon.mod.common.client.camera.GameCamera;
-import com.cobblemon.mod.common.client.camera.ClientCameraController;
-import com.cobblemon.mod.common.client.render.camera.CameraFeedHandler;
-import com.cobblemon.mod.common.client.render.camera.compositor.CompositorManager;
-import net.minecraft.client.Camera;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.client.DeltaTracker;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
 import net.minecraft.world.entity.Entity;
-import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Mutable;
-import org.spongepowered.asm.mixin.Shadow;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.level.BlockGetter;
 import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.ModifyArg;
-import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;

 import java.util.function.Predicate;

@Mixin(GameRenderer.class)
-public abstract class GameRendererMixin {
-
-    @Shadow @Final @Mutable
-    private Camera mainCamera;
-
+public class GameRendererMixin {
    @Unique
-    private Camera cobblemon$playerCamera;
+    long lastTime = -1;

-    @Unique
-    private final GameCamera cobblemon$gameCamera = new GameCamera();
-
-    @Unique
-    private boolean cobblemon$usingCinematic;
-
-    @Unique
-    private long cobblemon$lastTime = -1;
-
-    @Inject(method = "render", at = @At("HEAD"))
-    private void cobblemon$swapCamera(DeltaTracker counter, boolean tick, CallbackInfo ci) {
+    @Inject(
+            method = "render",
+            at = @At(value = "TAIL")
+    )
+    public void render(DeltaTracker counter, boolean tick, CallbackInfo ci) {
        Minecraft client = Minecraft.getInstance();
-        if (client.level == null) {
-            cobblemon$restoreCamera();
-            return;
-        }
-
-        if (ClientCameraController.shouldUseCinematicCamera()) {
-            if (!cobblemon$usingCinematic) {
-                cobblemon$playerCamera = mainCamera;
-                mainCamera = cobblemon$gameCamera;
-                cobblemon$usingCinematic = true;
-            }
-            ClientCameraController.prepareCinematicCamera(client, counter.getGameTimeDeltaPartialTick(tick));
-        } else if (cobblemon$usingCinematic) {
-            cobblemon$restoreCamera();
-        }
-    }
-
-    /**
-     * Skip the vanilla renderLevel() call when a fullscreen compositor is active since
-     * the compositor covers the entire screen with camera feeds.
-     * This avoids a full wasted scene render every frame.
-     */
-    @Redirect(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GameRenderer;renderLevel(Lnet/minecraft/client/DeltaTracker;)V"))
-    private void cobblemon$skipVanillaRenderLevel(GameRenderer instance, DeltaTracker deltaTracker) {
-        if (!CompositorManager.isFullscreenActive()) {
-            instance.renderLevel(deltaTracker);
-        }
-    }
-
-    @Inject(method = "render", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/GameRenderer;tryTakeScreenshotIfNeeded()V"))
-    private void cobblemon$afterLevelRendering(DeltaTracker deltaTracker, boolean renderLevel, CallbackInfo ci) {
-        // Only capture feeds when a compositor is actively consuming them.
-        // This avoids expensive full-resolution renders (especially with Iris)
-        // when feeds aren't being displayed.
-        boolean compositorNeedsFeeds = CompositorManager.isFullscreenActive()
-                || !CompositorManager.INSTANCE.getRequiredFeeds().isEmpty();
-        if (compositorNeedsFeeds && CameraFeedHandler.hasFeeds()) {
-            CameraFeedHandler.captureFeeds(deltaTracker);
-        }
-        if (CompositorManager.isFullscreenActive()) {
-            CompositorManager.INSTANCE.compositeAll();
-            CompositorManager.renderFullscreen();
-        }
-    }
-
-    @Inject(method = "pick", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$preventFramePick(float partialTicks, CallbackInfo ci) {
-        if (CameraFeedHandler.isCapturing())
-            ci.cancel();
-    }
-
-    @Inject(method = "render", at = @At(value = "TAIL"))
-    private void cobblemon$afterRender(DeltaTracker counter, boolean tick, CallbackInfo ci) {
-        Minecraft client = Minecraft.getInstance();
-
        long newTime = System.currentTimeMillis();
-
+        // Don't play scheduled animations when the game is paused
        if (client.isPaused()) {
-            cobblemon$lastTime = newTime;
+            lastTime = newTime;
            return;
        }

-        if (cobblemon$lastTime != -1) {
-            float delta = (newTime - cobblemon$lastTime) / 1000F;
-            ClientTaskTracker.INSTANCE.update(delta);
-            TweenManager.Companion.getClient().update(delta);
+        if (lastTime != -1) {
+            ClientTaskTracker.INSTANCE.update((newTime - lastTime) / 1000F);
        }
-        cobblemon$lastTime = newTime;
+        lastTime = newTime;
    }

    @ModifyArg(
@@ -139,12 +60,4 @@ public abstract class GameRendererMixin {
        return (entityX) -> !(entity.getVehicle() == entityX && entityX instanceof PokemonEntity) && original.test(entityX);
    }

-    @Unique
-    private void cobblemon$restoreCamera() {
-        if (cobblemon$usingCinematic) {
-            mainCamera = cobblemon$playerCamera;
-            cobblemon$playerCamera = null;
-            cobblemon$usingCinematic = false;
-        }
-    }
 }
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.mixin.client;

 import com.cobblemon.mod.common.OrientationControllable;
-import com.cobblemon.mod.common.client.camera.ClientCameraController;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Minecraft;
@@ -29,12 +28,6 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public class ItemInHandRendererMixin {
    @Inject(method = "renderArmWithItem", at = @At(value = "HEAD"), cancellable = true)
    private void cobblemon$renderArmWithItem(AbstractClientPlayer abstractClientPlayer, float f, float g, InteractionHand interactionHand, float h, ItemStack itemStack, float i, PoseStack poseStack, MultiBufferSource multiBufferSource, int j, CallbackInfo ci) {
-        // Hide arms when cinematic camera is active
-        if (ClientCameraController.isActive()) {
-            ci.cancel();
-            return;
-        }
-        
        if (abstractClientPlayer.isUsingItem() && abstractClientPlayer.getUseItem().getItem() instanceof PokedexItem) {
            ci.cancel();
        }
@@ -35,7 +35,6 @@ import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import com.cobblemon.mod.common.client.gui.party.PartyTutorialToasts;

 import static com.google.common.primitives.Floats.min;
 import static net.minecraft.util.Mth.lerp;
@@ -86,13 +85,11 @@ public abstract class MouseHandlerMixin {
                CobblemonClient.INSTANCE.getStorage().shiftSelected(false);
                ci.cancel();
                PartySendBinding.INSTANCE.actioned();
-                PartyTutorialToasts.INSTANCE.onHoldKeyScrollSwitchedSlot();
            } else if (i < 0) {
                accumulatedScrollY -= i;
                CobblemonClient.INSTANCE.getStorage().shiftSelected(true);
                ci.cancel();
                PartySendBinding.INSTANCE.actioned();
-                PartyTutorialToasts.INSTANCE.onHoldKeyScrollSwitchedSlot();
            }
        }
    }
@@ -313,7 +310,7 @@ public abstract class MouseHandlerMixin {
        var playerRotater = (RidePassenger)player;
        playerRotater.cobblemon$setRideXRot(playerRotater.cobblemon$getRideXRot() + f);
        playerRotater.cobblemon$setRideYRot(playerRotater.cobblemon$getRideYRot() + g);
-        playerRotater.cobblemon$setRideXRot(Mth.clamp(playerRotater.cobblemon$getRideXRot(), -89.0F, 89.0F));
+        playerRotater.cobblemon$setRideXRot(Mth.clamp(playerRotater.cobblemon$getRideXRot(), -90.0F, 90.0F));
        playerRotater.cobblemon$setRideYRot(Mth.clamp(playerRotater.cobblemon$getRideYRot(), -105.0F, 105.0F));
        if (player.getVehicle() != null) {
            player.getVehicle().onPassengerTurned(player);
@@ -8,14 +8,11 @@

 package com.cobblemon.mod.common.mixin.client;

-import com.cobblemon.mod.common.client.camera.ClientCameraController;
 import com.cobblemon.mod.common.client.render.ClientPlayerIcon;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.CameraType;
-import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.PlayerModel;
 import net.minecraft.client.player.AbstractClientPlayer;
 import net.minecraft.client.renderer.MultiBufferSource;
@@ -25,7 +22,6 @@ import net.minecraft.client.renderer.entity.player.PlayerRenderer;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;

@Mixin(PlayerRenderer.class)
@@ -35,27 +31,6 @@ public abstract class PlayerRendererMixin extends LivingEntityRenderer<AbstractC
        super(context, model, shadowRadius);
    }

-    /**
-     * Override the camera type check to force player body rendering when cinematic camera is active.
-     * This makes Minecraft think we're not in first person mode (for rendering purposes only),
-     * so the local player's body is rendered even though the camera entity is still the player.
-     */
-    @Redirect(
-            method = "render(Lnet/minecraft/client/player/AbstractClientPlayer;FFLcom/mojang/blaze3d/vertex/PoseStack;Lnet/minecraft/client/renderer/MultiBufferSource;I)V",
-            at = @At(
-                    value = "INVOKE",
-                    target = "Lnet/minecraft/client/CameraType;isFirstPerson()Z"
-            )
-    )
-    private boolean cobblemon$allowBodyRenderInCinematic(CameraType instance) {
-        // When cinematic camera is active and configured to show player body,
-        // pretend we're not in first person so the player body renders
-        if (ClientCameraController.isActive() && ClientCameraController.shouldRenderPlayerBody()) {
-            return false;
-        }
-        return instance.isFirstPerson();
-    }
-
    @Inject(method = "render", at = @At(value = "TAIL"))
    public void renderPlayer(AbstractClientPlayer player, float f, float g, PoseStack poseStack, MultiBufferSource multiBufferSource, int i, CallbackInfo ci) {
        ClientPlayerIcon.Companion.onRenderPlayer(player);
@@ -1,25 +0,0 @@
-/*
- * 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.mixin.client;
-
-import com.cobblemon.mod.common.client.render.camera.CameraViewAreaExtension;
-import net.minecraft.client.renderer.ViewArea;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ViewArea.class)
-public class ViewAreaMixin {
-    @Inject(method = "setDirty", at = @At("HEAD"))
-    private void cobblemon$markCinematicDirty(int cx, int cy, int cz, boolean reRenderOnMainThread, CallbackInfo ci) {
-        CameraViewAreaExtension.setDirty(cx, cy, cz, reRenderOnMainThread);
-    }
-}
-
@@ -14,14 +14,9 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.pokemon.Pokemon;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
-import com.llamalad7.mixinextras.sugar.Local;
-import com.llamalad7.mixinextras.sugar.Share;
-import com.llamalad7.mixinextras.sugar.ref.LocalBooleanRef;
-import com.llamalad7.mixinextras.sugar.ref.LocalFloatRef;
 import net.minecraft.client.player.LocalPlayer;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Direction;
-import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
@@ -94,61 +89,4 @@ public abstract class EntityMixin {
        cir.setReturnValue(customEyePos);
    }

-
-    @WrapOperation(
-            method = "push(Lnet/minecraft/world/entity/Entity;)V",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;push(DDD)V", ordinal = 0)
-    )
-    public void cobblemon$customPusherLogic(Entity pusher, double x, double y, double z,
-                                            Operation<Void> original,
-                                            @Local(argsOnly = true) Entity pushee,
-                                            @Local(name = "e") double e, @Local(name = "d") double d,
-                                            @Share("pusherIsPlayerOrPokemon") LocalBooleanRef pusherIsPlayerOrPokemon,
-                                            @Share("pusheeIsPlayerOrPokemon") LocalBooleanRef pusheeIsPlayerOrPokemon,
-                                            @Share("pusheeReceivedForce")LocalFloatRef pusheeReceivedForce) {
-        pusherIsPlayerOrPokemon.set(pusher instanceof PokemonEntity || pusher instanceof Player);
-        pusheeIsPlayerOrPokemon.set(pushee instanceof PokemonEntity || pushee instanceof Player);
-
-        if (!pusheeIsPlayerOrPokemon.get() || !pusherIsPlayerOrPokemon.get()) {
-            original.call(pusher, x, y, z);
-            return;
-        }
-
-        /**********************************************
-         * Custom portion of the code:
-         * Handle collisions with weight in mind. Use
-         * the weight value of pokemon to determine
-         * which side gets what portion of the total
-         * force.
-         *********************************************/
-        // Weights in hectograms
-        // Check to see if the pusher or pushee is a player. 200ish pounds. Steve's like a 6'6 miner
-        var pusherWeight = pusher instanceof PokemonEntity pusherPokemon ? pusherPokemon.getPokemon().getSpecies().getWeight() : 900F;
-        var pusheeWeight = pushee instanceof PokemonEntity pusheePokemon ? pusheePokemon.getPokemon().getSpecies().getWeight() : 900F;
-
-        // Calculate the portion of force received for both entities. Bigger receives less from the
-        // collision than the smaller one.
-        var totalWeight = pusherWeight + pusheeWeight;
-        var pusherReceivedForce = pusheeWeight / totalWeight * 2F;
-        pusheeReceivedForce.set((pusherWeight / totalWeight) * 2F);
-
-        original.call(pusher, -d * pusherReceivedForce, 0.0, -e * pusherReceivedForce);
-    }
-
-    @WrapOperation(
-            method = "push(Lnet/minecraft/world/entity/Entity;)V",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/world/entity/Entity;push(DDD)V", ordinal = 1)
-    )
-    public void cobblemon$customPusheeLogic(Entity pusher, double x, double y, double z, Operation<Void> original,
-                                            @Local(name = "e") double e, @Local(name = "d") double d,
-                                            @Share("pusherIsPlayerOrPokemon") LocalBooleanRef pusherIsPlayerOrPokemon,
-                                            @Share("pusheeIsPlayerOrPokemon") LocalBooleanRef pusheeIsPlayerOrPokemon,
-                                            @Share("pusheeReceivedForce")LocalFloatRef pusheeReceivedForce) {
-        if (!pusheeIsPlayerOrPokemon.get() || !pusherIsPlayerOrPokemon.get()) {
-            original.call(pusher, x, y, z);
-            return;
-        }
-
-        original.call(pusher, d * pusheeReceivedForce.get(), 0.0, e * pusheeReceivedForce.get());
-    }
 }
@@ -1,21 +0,0 @@
-/*
- * 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.mixin.invoker;
-
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.world.inventory.Slot;
-import org.jetbrains.annotations.Nullable;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Invoker;
-
-@Mixin(AbstractContainerScreen.class)
-public interface AbstractContainerScreenInvoker {
-    @Invoker("findSlot")
-    @Nullable Slot callFindSlot(double mouseX, double mouseY);
-}
@@ -65,30 +65,18 @@ import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataMongoBacken
 import com.cobblemon.mod.common.api.storage.player.factory.CachedPlayerDataStoreFactory
 import com.cobblemon.mod.common.api.tags.CobblemonEntityTypeTags
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
-import com.cobblemon.mod.common.battles.BagItems
-import com.cobblemon.mod.common.battles.BattleFormat
-import com.cobblemon.mod.common.battles.BattleRegistry
-import com.cobblemon.mod.common.battles.BattleSide
-import com.cobblemon.mod.common.battles.ShowdownThread
+import com.cobblemon.mod.common.battles.*
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.battles.pokemon.BattlePokemon
-import com.cobblemon.mod.common.api.camera.track.CameraTrackDeserializers
-import com.cobblemon.mod.common.block.dispenser.DispenserBehaviorRegistry
+import com.cobblemon.mod.common.block.DispenserBehaviorRegistry
 import com.cobblemon.mod.common.client.CobblemonPack
-import com.cobblemon.mod.common.api.tween.EasingRegistry
-import com.cobblemon.mod.common.api.tween.TweenManager
 import com.cobblemon.mod.common.command.argument.*
 import com.cobblemon.mod.common.config.CobblemonConfig
 import com.cobblemon.mod.common.config.LastChangedVersion
 import com.cobblemon.mod.common.config.constraint.IntConstraint
 import com.cobblemon.mod.common.config.starter.StarterConfig
 import com.cobblemon.mod.common.data.CobblemonDataProvider
-import com.cobblemon.mod.common.events.AdvancementHandler
-import com.cobblemon.mod.common.events.CallbackHandler
-import com.cobblemon.mod.common.events.EntityCallbackHandler
-import com.cobblemon.mod.common.events.PokedexHandler
-import com.cobblemon.mod.common.events.ServerTickHandler
-import com.cobblemon.mod.common.events.StatHandler
+import com.cobblemon.mod.common.events.*
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.permission.LaxPermissionValidator
 import com.cobblemon.mod.common.platform.events.PlatformEvents
@@ -102,23 +90,11 @@ import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatu
 import com.cobblemon.mod.common.pokemon.feature.SlowpokeTailRegrowthSpeciesFeatureProvider
 import com.cobblemon.mod.common.pokemon.feature.TagSeasonResolver
 import com.cobblemon.mod.common.pokemon.helditem.CobblemonHeldItemManager
-import com.cobblemon.mod.common.pokemon.properties.AspectPropertyType
-import com.cobblemon.mod.common.pokemon.properties.BattleCloneProperty
-import com.cobblemon.mod.common.pokemon.properties.FreezeFrameProperty
-import com.cobblemon.mod.common.pokemon.properties.HiddenAbilityPropertyType
+import com.cobblemon.mod.common.pokemon.properties.*
 import com.cobblemon.mod.common.pokemon.properties.LabelProperty
-import com.cobblemon.mod.common.pokemon.properties.NoAIProperty
-import com.cobblemon.mod.common.pokemon.properties.UnaspectPropertyType
-import com.cobblemon.mod.common.pokemon.properties.UncatchableProperty
 import com.cobblemon.mod.common.pokemon.stat.CobblemonStatProvider
 import com.cobblemon.mod.common.starter.CobblemonStarterHandler
-import com.cobblemon.mod.common.util.DataKeys
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.ifDedicatedServer
-import com.cobblemon.mod.common.util.isLaterVersion
-import com.cobblemon.mod.common.util.party
-import com.cobblemon.mod.common.util.requestWallpapers
-import com.cobblemon.mod.common.util.server
+import com.cobblemon.mod.common.util.*
 import com.cobblemon.mod.common.world.feature.CobblemonPlacedFeatures
 import com.cobblemon.mod.common.world.feature.ore.CobblemonOrePlacedFeatures
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
@@ -126,17 +102,6 @@ import com.mongodb.ConnectionString
 import com.mongodb.MongoClientSettings
 import com.mongodb.client.MongoClient
 import com.mongodb.client.MongoClients
-import java.io.File
-import java.io.FileReader
-import java.io.FileWriter
-import java.io.PrintWriter
-import java.util.UUID
-import java.util.concurrent.TimeUnit
-import kotlin.math.roundToInt
-import kotlin.properties.Delegates
-import kotlin.reflect.full.memberProperties
-import kotlin.reflect.jvm.isAccessible
-import kotlin.reflect.jvm.javaField
 import net.minecraft.client.Minecraft
 import net.minecraft.commands.synchronization.SingletonArgumentInfo
 import net.minecraft.resources.ResourceKey
@@ -149,6 +114,17 @@ import net.minecraft.world.level.Level
 import net.minecraft.world.level.storage.LevelResource
 import org.apache.logging.log4j.LogManager
 import org.apache.logging.log4j.Logger
+import java.io.File
+import java.io.FileReader
+import java.io.FileWriter
+import java.io.PrintWriter
+import java.util.*
+import java.util.concurrent.TimeUnit
+import kotlin.math.roundToInt
+import kotlin.properties.Delegates
+import kotlin.reflect.full.memberProperties
+import kotlin.reflect.jvm.isAccessible
+import kotlin.reflect.jvm.javaField

 object Cobblemon {
    const val MODID = CobblemonBuildDetails.MOD_ID
@@ -188,8 +164,8 @@ object Cobblemon {

    val statistics: CobblemonStats = CobblemonStats

-    @JvmStatic
-    val builtinPacks = listOf(
+    @JvmField
+    val builtinPacks = listOf<CobblemonPack>(
        CobblemonPack(id = "adorncompatibility", name = "Adorn Compatibility", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.ALWAYS_ENABLED, neededMods = setOf("adorn")),
        CobblemonPack(id = "gyaradosjump", name = "Gyarados Jump Patterns", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
        CobblemonPack(id = "regionbiasforms", name = "Region Bias Forms", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED),
@@ -259,7 +235,6 @@ object Cobblemon {
            playerDataManager.onPlayerDisconnect(it.player)
            RequestManager.onLogoff(it.player)
            serverPlayerStructs.remove(it.player.uuid)
-            com.cobblemon.mod.common.api.molangui.MolangUiSessionManager.closeAllForPlayer(it.player.uuid)
        }
        PlatformEvents.PLAYER_DEATH.subscribe {
            PCLinkManager.removeLink(it.player.uuid)
@@ -302,7 +277,6 @@ object Cobblemon {
        HeldItemProvider.register(CobblemonHeldItemManager, Priority.LOWEST)
    }

-
    fun sendServerSettingsPacketToPlayer(player: ServerPlayer) {
        ServerSettingsPacket(
            this.config.preventCompletePartyDeposit,
@@ -348,10 +322,6 @@ object Cobblemon {
        CustomPokemonProperty.register(FreezeFrameProperty)
        CustomPokemonProperty.register(NoAIProperty)

-        // Tween & camera system initialization
-        EasingRegistry.registerBuiltinEasings()
-        CameraTrackDeserializers.registerBuiltinTracks()
-
        CobblemonEvents.POKEMON_PROPERTY_INITIALISED.emit(Unit)

        CallbackHandler.setup()
@@ -364,7 +334,6 @@ object Cobblemon {
        PlatformEvents.SERVER_TICK_POST.subscribe {
            ServerTaskTracker.update(1/20F)
            ServerRealTimeTaskTracker.update()
-            TweenManager.server.update(1/20F)
        }
        PlatformEvents.SERVER_TICK_PRE.subscribe {
            ServerRealTimeTaskTracker.update()
@@ -482,7 +451,7 @@ object Cobblemon {
            server()?.getLevel(dimension)
        } else {
            val mc = Minecraft.getInstance()
-            mc.singleplayerServer?.getLevel(dimension) ?: mc.level
+            return mc.singleplayerServer?.getLevel(dimension) ?: mc.level
        }
    }

@@ -600,4 +569,4 @@ object Cobblemon {
        this.implementation.registerCommandArgument(cobblemonResource("model_part"), ModelPartArgumentType::class, SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart))
    }

-}
+}
@@ -106,10 +106,4 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
        "poke_snack",
        BlockEntityType.Builder.of(::PokeSnackBlockEntity, CobblemonBlocks.POKE_SNACK, CobblemonBlocks.POKE_CAKE).build(null)
    )
-
-    @JvmField
-    val STADIUM_BLOCK: BlockEntityType<StadiumBlockEntity> = this.create(
-        "stadium_block",
-        BlockEntityType.Builder.of(::StadiumBlockEntity, CobblemonBlocks.STADIUM_BLOCK).build(null)
-    )
 }
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common

 import com.cobblemon.mod.common.api.apricorn.Apricorn
-import com.cobblemon.mod.common.api.pokemon.stats.Stats
 import com.cobblemon.mod.common.block.*
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
 import com.cobblemon.mod.common.block.LecternBlock
@@ -42,11 +41,11 @@ import net.minecraft.world.level.block.state.BlockBehaviour
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.block.state.properties.BlockSetType
 import net.minecraft.world.level.block.state.properties.BlockStateProperties
+import net.minecraft.world.level.block.state.properties.BlockStateProperties.LIT
 import net.minecraft.world.level.block.state.properties.NoteBlockInstrument
 import net.minecraft.world.level.block.state.properties.WoodType
 import net.minecraft.world.level.material.MapColor
 import net.minecraft.world.level.material.PushReaction
-import net.minecraft.world.phys.shapes.Shapes

@Suppress("SameParameterValue", "HasPlatformType", "MemberVisibilityCanBePrivate", "unused")
 object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<Block>>, Block>() {
@@ -244,9 +243,9 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    val REVIVAL_HERB = this.create("revival_herb", RevivalHerbBlock(BlockBehaviour.Properties.of().pushReaction(PushReaction.DESTROY).mapColor(MapColor.PLANT).ignitedByLava().noCollission().instabreak().sound(CobblemonSounds.REVIVAL_HERB_SOUNDS)))

    @JvmField
-    val POKE_CAKE = this.create("poke_cake", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(BlockStateProperties.LIT)) 3 else 0 }, false))
+    val POKE_CAKE = this.create("poke_cake", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(LIT)) 3 else 0 }, false))
    @JvmField
-    val POKE_SNACK = this.create("poke_snack", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(BlockStateProperties.LIT)) 3 else 0 }, true))
+    val POKE_SNACK = this.create("poke_snack", PokeSnackBlock(BlockBehaviour.Properties.of().forceSolidOn().strength(0.5F).sound(SoundType.WOOL).pushReaction(PushReaction.DESTROY).lightLevel { if (it.getValue(LIT)) 3 else 0 }, true))

    @JvmField
    val TUMBLESTONE_CLUSTER = tumblestoneBlock("tumblestone_cluster", GrowableStoneBlock.STAGE_3, 7, 3, null)
@@ -478,99 +477,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val GIMMIGHOUL_CHEST = create("gimmighoul_chest", GildedChestBlock(BlockBehaviour.Properties.ofFullCopy(Blocks.CHEST).noOcclusion().sound(CobblemonSounds.GILDED_CHEST_SOUNDS), GildedChestBlock.Type.FAKE))

-    @JvmField
-    val WHITE_PLAQUE = create("white_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val LIGHT_GRAY_PLAQUE = create("light_gray_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val GRAY_PLAQUE = create("gray_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val BLACK_PLAQUE = create("black_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val BROWN_PLAQUE = create("brown_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val RED_PLAQUE = create("red_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val ORANGE_PLAQUE = create("orange_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val YELLOW_PLAQUE = create("yellow_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val LIME_PLAQUE = create("lime_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val GREEN_PLAQUE = create("green_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val CYAN_PLAQUE = create("cyan_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val LIGHT_BLUE_PLAQUE = create("light_blue_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val BLUE_PLAQUE = create("blue_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val PURPLE_PLAQUE = create("purple_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val MAGENTA_PLAQUE = create("magenta_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-    @JvmField
-    val PINK_PLAQUE = create("pink_plaque", PlaqueBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.METAL).noOcclusion().pushReaction(PushReaction.DESTROY).strength(5.0F)))
-
-    @JvmField
-    val CLEANSE_TAG = create("cleanse_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))
-    @JvmField
-    val SPELL_TAG = create("spell_tag", WallAttachedStackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().noCollission(), WallAttachedStackableItemBlock.WallStackableItemBlockType.TAG))
-
-    @JvmField
-    val BLUNDER_POLICY = create("blunder_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
-    @JvmField
-    val WEAKNESS_POLICY = create("weakness_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
-
-    @JvmField
-    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-
-    @JvmField
-    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-
-    @JvmField
-    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
-    @JvmField
-    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
-
-    @JvmField
-    val DIRE_HIT = create("dire_hit", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val GUARD_SPEC = create("guard_spec", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-    @JvmField
-    val X_SPEED = create("x_${Stats.SPEED.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
-
    @JvmField
    val MONITOR = create("monitor", MonitorBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).lightLevel { if (it.getValue(MonitorBlock.SCREEN) != MonitorBlock.MonitorScreen.OFF) 13 else 0 }))
    @JvmField
@@ -581,9 +487,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
    @JvmField
    val HEALING_MACHINE = create("healing_machine", HealingMachineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2f).noOcclusion().lightLevel { if (it.getValue(HealingMachineBlock.CHARGE_LEVEL) >= HealingMachineBlock.MAX_CHARGE_LEVEL) 12 else 5 }))

-    @JvmField
-    val STADIUM_BLOCK = create("stadium_block", StadiumBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).strength(3.5F, 6.0F).noOcclusion().pushReaction(PushReaction.BLOCK)))
-
    @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)) 13 else 0 }))

@@ -15,11 +15,7 @@ import net.minecraft.commands.CommandSourceStack
 import net.minecraft.commands.Commands

 object CobblemonCommands {
-    fun register(
-        dispatcher: CommandDispatcher<CommandSourceStack>,
-        registry: CommandBuildContext,
-        selection: Commands.CommandSelection
-    ) {
+    fun register(dispatcher: CommandDispatcher<CommandSourceStack>, registry: CommandBuildContext, selection: Commands.CommandSelection) {
        SpawnPokemon.register(dispatcher)
        SpawnNPCCommand.register(dispatcher)
        GivePokemon.register(dispatcher)
@@ -80,8 +76,5 @@ object CobblemonCommands {
        // with a certain system environment variable set
        CobblemonInfoCommand.register(dispatcher)
        CalculateSeatPositionCommand.register(dispatcher)
-        CameraDebugCommand.register(dispatcher)
-        StadiumBattleCommand.register(dispatcher)
-        MolangUiCommand.register(dispatcher)
    }
 }
@@ -39,7 +39,6 @@ import com.cobblemon.mod.common.item.interactive.PonigiriItem
 import com.cobblemon.mod.common.item.food.SinisterTeaItem
 import com.cobblemon.mod.common.item.interactive.*
 import com.cobblemon.mod.common.item.interactive.ability.AbilityChangeItem
-import com.cobblemon.mod.common.item.stadium.StadiumPlacementWandItem
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import com.cobblemon.mod.common.pokeball.PokeBall
 import com.cobblemon.mod.common.pokemon.IVs
@@ -76,9 +75,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val NPC_EDITOR = create("npc_editor", CobblemonItem(Item.Properties().stacksTo(1)))

-    @JvmField
-    val STADIUM_PLACEMENT_WAND = create("stadium_placement_wand", StadiumPlacementWandItem())
-
    @JvmField
    val pokeBalls = mutableListOf<PokeBallItem>()
    @JvmField
@@ -464,8 +460,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    val PASTURE = blockItem("pasture", CobblemonBlocks.PASTURE)
    @JvmField
    val DISPLAY_CASE = blockItem("display_case", CobblemonBlocks.DISPLAY_CASE)
-    @JvmField
-    val STADIUM_BLOCK = blockItem("stadium_block", CobblemonBlocks.STADIUM_BLOCK)
 //    @JvmField
 //    val INCENSE_SWEET = blockItem("incense_sweet", CobblemonBlocks.INCENSE_SWEET) // TODO after 1.7

@@ -513,23 +507,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField val SCROLL_OF_DARKNESS = noSettingsItem("scroll_of_darkness")
    @JvmField val SCROLL_OF_WATERS = noSettingsItem("scroll_of_waters")

-    @JvmField val WHITE_PLAQUE = blockItem("white_plaque", CobblemonBlocks.WHITE_PLAQUE)
-    @JvmField val LIGHT_GRAY_PLAQUE = blockItem("light_gray_plaque", CobblemonBlocks.LIGHT_GRAY_PLAQUE)
-    @JvmField val GRAY_PLAQUE = blockItem("gray_plaque", CobblemonBlocks.GRAY_PLAQUE)
-    @JvmField val BLACK_PLAQUE = blockItem("black_plaque", CobblemonBlocks.BLACK_PLAQUE)
-    @JvmField val BROWN_PLAQUE = blockItem("brown_plaque", CobblemonBlocks.BROWN_PLAQUE)
-    @JvmField val RED_PLAQUE = blockItem("red_plaque", CobblemonBlocks.RED_PLAQUE)
-    @JvmField val ORANGE_PLAQUE = blockItem("orange_plaque", CobblemonBlocks.ORANGE_PLAQUE)
-    @JvmField val YELLOW_PLAQUE = blockItem("yellow_plaque", CobblemonBlocks.YELLOW_PLAQUE)
-    @JvmField val LIME_PLAQUE = blockItem("lime_plaque", CobblemonBlocks.LIME_PLAQUE)
-    @JvmField val GREEN_PLAQUE = blockItem("green_plaque", CobblemonBlocks.GREEN_PLAQUE)
-    @JvmField val CYAN_PLAQUE = blockItem("cyan_plaque", CobblemonBlocks.CYAN_PLAQUE)
-    @JvmField val LIGHT_BLUE_PLAQUE = blockItem("light_blue_plaque", CobblemonBlocks.LIGHT_BLUE_PLAQUE)
-    @JvmField val BLUE_PLAQUE = blockItem("blue_plaque", CobblemonBlocks.BLUE_PLAQUE)
-    @JvmField val PURPLE_PLAQUE = blockItem("purple_plaque", CobblemonBlocks.PURPLE_PLAQUE)
-    @JvmField val MAGENTA_PLAQUE = blockItem("magenta_plaque", CobblemonBlocks.MAGENTA_PLAQUE)
-    @JvmField val PINK_PLAQUE = blockItem("pink_plaque", CobblemonBlocks.PINK_PLAQUE)
-
    private val berries = mutableMapOf<ResourceLocation, BerryItem>()
    // Plants
    @JvmField val CHERI_BERRY = berryItem("cheri", StatusCuringBerryItem(CobblemonBlocks.CHERI_BERRY, Statuses.PARALYSIS))
@@ -722,15 +699,15 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))

    @JvmField
-    val POTION = create("potion", PotionItem(PotionType.POTION, CobblemonBlocks.POTION))
+    val POTION = create("potion", PotionItem(PotionType.POTION))
    @JvmField
-    val SUPER_POTION = create("super_potion", PotionItem(PotionType.SUPER_POTION, CobblemonBlocks.SUPER_POTION))
+    val SUPER_POTION = create("super_potion", PotionItem(PotionType.SUPER_POTION))
    @JvmField
-    val HYPER_POTION = create("hyper_potion", PotionItem(PotionType.HYPER_POTION, CobblemonBlocks.HYPER_POTION))
+    val HYPER_POTION = create("hyper_potion", PotionItem(PotionType.HYPER_POTION))
    @JvmField
-    val MAX_POTION = create("max_potion", PotionItem(PotionType.MAX_POTION, CobblemonBlocks.MAX_POTION))
+    val MAX_POTION = create("max_potion", PotionItem(PotionType.MAX_POTION))
    @JvmField
-    val FULL_RESTORE = create("full_restore", PotionItem(PotionType.FULL_RESTORE, CobblemonBlocks.FULL_RESTORE))
+    val FULL_RESTORE = create("full_restore", PotionItem(PotionType.FULL_RESTORE))

    @JvmField
    val HEAL_POWDER = create("heal_powder", HealPowderItem())
@@ -815,27 +792,28 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val SERIOUS_MINT = mintItem("serious_mint", MintItem(Natures.SERIOUS))

-    @JvmField val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", XStatItem(Stats.ACCURACY, block = CobblemonBlocks.X_ACCURACY))
-    @JvmField val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", XStatItem(Stats.ATTACK, block = CobblemonBlocks.X_ATTACK))
-    @JvmField val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", XStatItem(Stats.DEFENCE, block = CobblemonBlocks.X_DEFENSE))
-    @JvmField val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", XStatItem(Stats.SPECIAL_ATTACK, block = CobblemonBlocks.X_SP_ATK))
-    @JvmField val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", XStatItem(Stats.SPECIAL_DEFENCE, block = CobblemonBlocks.X_SP_DEF))
-    @JvmField val X_SPEED = create("x_${Stats.SPEED.identifier.path}", XStatItem(Stats.SPEED, block = CobblemonBlocks.X_SPEED))
+    @JvmField val X_ACCURACY = create("x_${Stats.ACCURACY.identifier.path}", XStatItem(Stats.ACCURACY))
+    @JvmField val X_ATTACK = create("x_${Stats.ATTACK.identifier.path}", XStatItem(Stats.ATTACK))
+    @JvmField val X_DEFENSE = create("x_${Stats.DEFENCE.identifier.path}", XStatItem(Stats.DEFENCE))
+    @JvmField val X_SP_ATK = create("x_${Stats.SPECIAL_ATTACK.identifier.path}", XStatItem(Stats.SPECIAL_ATTACK))
+    @JvmField val X_SP_DEF = create("x_${Stats.SPECIAL_DEFENCE.identifier.path}", XStatItem(Stats.SPECIAL_DEFENCE))
+    @JvmField val X_SPEED = create("x_${Stats.SPEED.identifier.path}", XStatItem(Stats.SPEED))

-    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem(CobblemonBlocks.DIRE_HIT))
-    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem(CobblemonBlocks.GUARD_SPEC))
+    @JvmField val DIRE_HIT = create("dire_hit", DireHitItem())
+    @JvmField val GUARD_SPEC = create("guard_spec", GuardSpecItem())

-    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal", *Statuses.getPersistentStatuses().toTypedArray(), block = CobblemonBlocks.FULL_HEAL))
-    @JvmField val ANTIDOTE = create("antidote", StatusCureItem("item.cobblemon.antidote", Statuses.POISON, Statuses.POISON_BADLY, block = CobblemonBlocks.ANTIDOTE))
-    @JvmField val AWAKENING = create("awakening", StatusCureItem("item.cobblemon.awakening", Statuses.SLEEP, block = CobblemonBlocks.AWAKENING))
-    @JvmField val BURN_HEAL = create("burn_heal", StatusCureItem("item.cobblemon.burn_heal", Statuses.BURN, block = CobblemonBlocks.BURN_HEAL))
-    @JvmField val ICE_HEAL = create("ice_heal", StatusCureItem("item.cobblemon.ice_heal", Statuses.FROZEN, block = CobblemonBlocks.ICE_HEAL))
-    @JvmField val PARALYZE_HEAL = create("paralyze_heal", StatusCureItem("item.cobblemon.paralyze_heal", Statuses.PARALYSIS, block = CobblemonBlocks.PARALYZE_HEAL))
+    @JvmField val BURN_HEAL = create("burn_heal", StatusCureItem("item.cobblemon.burn_heal", Statuses.BURN))
+    @JvmField val PARALYZE_HEAL = create("paralyze_heal", StatusCureItem("item.cobblemon.paralyze_heal", Statuses.PARALYSIS))
+    @JvmField val ICE_HEAL = create("ice_heal", StatusCureItem("item.cobblemon.ice_heal", Statuses.FROZEN))
+    @JvmField val ANTIDOTE = create("antidote", StatusCureItem("item.cobblemon.antidote", Statuses.POISON, Statuses.POISON_BADLY))
+    @JvmField val AWAKENING = create("awakening", StatusCureItem("item.cobblemon.awakening", Statuses.SLEEP))

-    @JvmField val ETHER = create("ether", EtherItem(max = false, CobblemonBlocks.ETHER))
-    @JvmField val MAX_ETHER = create("max_ether", EtherItem(max = true, CobblemonBlocks.MAX_ETHER))
-    @JvmField val ELIXIR = create("elixir", ElixirItem(max = false, CobblemonBlocks.ELIXIR))
-    @JvmField val MAX_ELIXIR = create("max_elixir", ElixirItem(max = true, CobblemonBlocks.MAX_ELIXIR))
+    @JvmField val FULL_HEAL = create("full_heal", StatusCureItem("item.cobblemon.full_heal"))
+
+    @JvmField val ETHER = create("ether", EtherItem(max = false))
+    @JvmField val MAX_ETHER = create("max_ether", EtherItem(max = true))
+    @JvmField val ELIXIR = create("elixir", ElixirItem(max = false))
+    @JvmField val MAX_ELIXIR = create("max_elixir", ElixirItem(max = true))

    @JvmField
    val ABILITY_CAPSULE = this.create("ability_capsule", AbilityChangeItem(AbilityChanger.COMMON_ABILITY))
@@ -944,7 +922,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val BLACK_SLUDGE = heldItem("black_sludge")
    @JvmField
-    val BLUNDER_POLICY = itemNameBlockItem("blunder_policy", CobblemonBlocks.BLUNDER_POLICY)
+    val BLUNDER_POLICY = heldItem("blunder_policy")
    @JvmField
    val CELL_BATTERY = heldItem("cell_battery")
    @JvmField
@@ -952,7 +930,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val CHOICE_SCARF = heldItem("choice_scarf")
    @JvmField
-    val CLEANSE_TAG = itemNameBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
+    val CLEANSE_TAG = heldItem("cleanse_tag")
    @JvmField
    val CLEAR_AMULET = heldItem("clear_amulet")
    @JvmField
@@ -1060,7 +1038,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val SOFT_SAND = heldItem("soft_sand")
    @JvmField
-    val SPELL_TAG = itemNameBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
+    val SPELL_TAG = heldItem("spell_tag")
    @JvmField
    val SMOKE_BALL = heldItem("smoke_ball")
    @JvmField
@@ -1078,7 +1056,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
    @JvmField
    val UTILITY_UMBRELLA = heldItem("utility_umbrella")
    @JvmField
-    val WEAKNESS_POLICY = itemNameBlockItem("weakness_policy", CobblemonBlocks.WEAKNESS_POLICY)
+    val WEAKNESS_POLICY = heldItem("weakness_policy")
    @JvmField
    val WIDE_LENS = heldItem("wide_lens")
    @JvmField
@@ -1575,7 +1553,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
            }
        }
    )
-
    private fun heldItem(name: String, item: Item, remappedName: String? = null) = create(
        name = name,
        entry = item.also {
@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common


-import com.cobblemon.mod.common.api.molangui.container.MolangContainerMenu
 import com.cobblemon.mod.common.block.campfirepot.CookingPotMenu
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
@@ -21,7 +20,6 @@ import net.minecraft.world.inventory.MenuType
 object CobblemonMenuType : PlatformRegistry<Registry<MenuType<*>>, ResourceKey<Registry<MenuType<*>>>, MenuType<*>>() {

    val COOKING_POT = MenuType.register("cooking_pot", ::CookingPotMenu)
-    val MOLANG_UI = MenuType.register("molang_ui", ::MolangContainerMenu)

    override val registry: Registry<MenuType<*>>
        get() = BuiltInRegistries.MENU
@@ -18,41 +18,23 @@ import com.cobblemon.mod.common.client.net.battle.*
 import com.cobblemon.mod.common.client.net.callback.move.OpenMoveCallbackHandler
 import com.cobblemon.mod.common.client.net.callback.party.OpenPartyCallbackHandler
 import com.cobblemon.mod.common.client.net.callback.partymove.OpenPartyMoveCallbackHandler
-import com.cobblemon.mod.common.client.net.camera.CameraDebugHandler
-import com.cobblemon.mod.common.client.net.camera.CameraEndHandler
-import com.cobblemon.mod.common.client.net.camera.CameraFocusHandler
-import com.cobblemon.mod.common.client.net.camera.CameraStartHandler
-import com.cobblemon.mod.common.client.net.camera.CameraStateHandler
-import com.cobblemon.mod.common.client.net.camera.CameraTransformHandler
-import com.cobblemon.mod.common.client.net.camera.CompositorHandler
-import com.cobblemon.mod.common.client.net.camera.SplitScreenHandler
 import com.cobblemon.mod.common.client.net.cooking.ToggleCookingPotLidHandler
 import com.cobblemon.mod.common.client.net.data.CobblemonMechanicsSyncHandler
 import com.cobblemon.mod.common.client.net.data.DataRegistrySyncPacketHandler
+import com.cobblemon.mod.common.client.net.data.PokemonInteractionsSyncHandler
 import com.cobblemon.mod.common.client.net.data.RideSettingsSyncHandler
 import com.cobblemon.mod.common.client.net.debug.OpenRidingStatsDebugGUIHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueClosedHandler
 import com.cobblemon.mod.common.client.net.dialogue.DialogueOpenedHandler
-import com.cobblemon.mod.common.client.net.effect.PokeSnackBlockParticlesHandler
-import com.cobblemon.mod.common.client.net.effect.RunPosableMoLangHandler
-import com.cobblemon.mod.common.client.net.effect.SaccharineLogBlockParticlesHandler
-import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormEntityParticleHandler
-import com.cobblemon.mod.common.client.net.effect.SpawnSnowstormParticleHandler
+import com.cobblemon.mod.common.client.net.effect.*
 import com.cobblemon.mod.common.client.net.gui.ExpGainedDataPacketHandler
 import com.cobblemon.mod.common.client.net.gui.InteractPokemonUIPacketHandler
 import com.cobblemon.mod.common.client.net.gui.PokedexUIPacketHandler
-import com.cobblemon.mod.common.client.net.molangui.MolangUiCloseHandler
-import com.cobblemon.mod.common.client.net.molangui.MolangUiOpenHandler
-import com.cobblemon.mod.common.client.net.molangui.MolangUiUpdateHandler
 import com.cobblemon.mod.common.client.net.gui.SummaryUIPacketHandler
 import com.cobblemon.mod.common.client.net.npc.CloseNPCEditorHandler
 import com.cobblemon.mod.common.client.net.npc.OpenNPCEditorHandler
 import com.cobblemon.mod.common.client.net.orientation.ClientboundUpdateOrientationHandler
-import com.cobblemon.mod.common.client.net.pasture.ClosePastureHandler
-import com.cobblemon.mod.common.client.net.pasture.OpenPastureHandler
-import com.cobblemon.mod.common.client.net.pasture.PokemonPasturedHandler
-import com.cobblemon.mod.common.client.net.pasture.PokemonUnpasturedHandler
-import com.cobblemon.mod.common.client.net.pasture.UpdatePastureConflictFlagHandler
+import com.cobblemon.mod.common.client.net.pasture.*
 import com.cobblemon.mod.common.client.net.pokedex.ServerConfirmedRegisterHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.ClientboundUpdateRidingStateHandler
 import com.cobblemon.mod.common.client.net.pokemon.update.PokemonUpdatePacketHandler
@@ -60,7 +42,6 @@ import com.cobblemon.mod.common.client.net.riding.ClientboundUpdateDriverInputHa
 import com.cobblemon.mod.common.client.net.settings.OpenCobblemonConfigEditorHandler
 import com.cobblemon.mod.common.client.net.settings.ServerSettingsPacketHandler
 import com.cobblemon.mod.common.client.net.sound.UnvalidatedPlaySoundS2CPacketHandler
-import com.cobblemon.mod.common.client.net.stadium.OpenStadiumConfigHandler
 import com.cobblemon.mod.common.client.net.spawn.SpawnExtraDataEntityHandler
 import com.cobblemon.mod.common.client.net.starter.StarterUIPacketHandler
 import com.cobblemon.mod.common.client.net.storage.RemoveClientPokemonHandler
@@ -71,14 +52,7 @@ import com.cobblemon.mod.common.client.net.storage.party.SetPartyPokemonHandler
 import com.cobblemon.mod.common.client.net.storage.party.SetPartyReferenceHandler
 import com.cobblemon.mod.common.client.net.storage.pc.*
 import com.cobblemon.mod.common.client.net.toast.ToastPacketHandler
-import com.cobblemon.mod.common.client.net.trade.TradeAcceptanceChangedHandler
-import com.cobblemon.mod.common.client.net.trade.TradeCancelledHandler
-import com.cobblemon.mod.common.client.net.trade.TradeCompletedHandler
-import com.cobblemon.mod.common.client.net.trade.TradeOfferExpiredHandler
-import com.cobblemon.mod.common.client.net.trade.TradeOfferNotificationHandler
-import com.cobblemon.mod.common.client.net.trade.TradeProcessStartedHandler
-import com.cobblemon.mod.common.client.net.trade.TradeStartedHandler
-import com.cobblemon.mod.common.client.net.trade.TradeUpdatedHandler
+import com.cobblemon.mod.common.client.net.trade.*
 import com.cobblemon.mod.common.net.PacketRegisterInfo
 import com.cobblemon.mod.common.net.messages.client.CalculateSeatPositionsPacket
 import com.cobblemon.mod.common.net.messages.client.OpenBehaviourEditorPacket
@@ -86,14 +60,6 @@ import com.cobblemon.mod.common.net.messages.client.PlayerInteractOptionsPacket
 import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
 import com.cobblemon.mod.common.net.messages.client.animation.PlayPosableAnimationPacket
 import com.cobblemon.mod.common.net.messages.client.battle.*
-import com.cobblemon.mod.common.net.messages.client.camera.CameraDebugPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraEndPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraFocusPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraStartPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraStatePacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraTransformPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CompositorPacket
-import com.cobblemon.mod.common.net.messages.client.camera.SplitScreenPacket
 import com.cobblemon.mod.common.net.messages.client.callback.OpenMoveCallbackPacket
 import com.cobblemon.mod.common.net.messages.client.callback.OpenPartyCallbackPacket
 import com.cobblemon.mod.common.net.messages.client.callback.OpenPartyMoveCallbackPacket
@@ -101,32 +67,20 @@ import com.cobblemon.mod.common.net.messages.client.cooking.SeasoningRegistrySyn
 import com.cobblemon.mod.common.net.messages.client.cooking.ToggleCookingPotLidPacket
 import com.cobblemon.mod.common.net.messages.client.data.*
 import com.cobblemon.mod.common.net.messages.client.debug.RequestOpenRidingStatsDebugGUIPacket
-import com.cobblemon.mod.common.net.messages.client.molangui.MolangUiClosePacket
-import com.cobblemon.mod.common.net.messages.client.molangui.MolangUiOpenPacket
-import com.cobblemon.mod.common.net.messages.client.molangui.MolangUiUpdatePacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueClosedPacket
 import com.cobblemon.mod.common.net.messages.client.dialogue.DialogueOpenedPacket
-import com.cobblemon.mod.common.net.messages.client.effect.PokeSnackBlockParticlesPacket
-import com.cobblemon.mod.common.net.messages.client.effect.RunPosableMoLangPacket
-import com.cobblemon.mod.common.net.messages.client.effect.SaccharineLogBlockParticlesPacket
-import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
-import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
+import com.cobblemon.mod.common.net.messages.client.effect.*
 import com.cobblemon.mod.common.net.messages.client.npc.CloseNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.npc.OpenNPCEditorPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateDriverInputPacket
 import com.cobblemon.mod.common.net.messages.client.orientation.ClientboundUpdateOrientationPacket
-import com.cobblemon.mod.common.net.messages.client.pasture.ClosePasturePacket
-import com.cobblemon.mod.common.net.messages.client.pasture.OpenPasturePacket
-import com.cobblemon.mod.common.net.messages.client.pasture.PokemonPasturedPacket
-import com.cobblemon.mod.common.net.messages.client.pasture.PokemonUnpasturedPacket
-import com.cobblemon.mod.common.net.messages.client.pasture.UpdatePastureConflictFlagPacket
+import com.cobblemon.mod.common.net.messages.client.pasture.*
 import com.cobblemon.mod.common.net.messages.client.pokedex.ServerConfirmedRegisterPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.*
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.AddEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.ClearEvolutionsPacket
 import com.cobblemon.mod.common.net.messages.client.pokemon.update.evolution.RemoveEvolutionPacket
 import com.cobblemon.mod.common.net.messages.client.settings.OpenCobblemonConfigScreenPacket
-import com.cobblemon.mod.common.net.messages.client.stadium.OpenStadiumConfigPacket
 import com.cobblemon.mod.common.net.messages.client.settings.ServerSettingsPacket
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
 import com.cobblemon.mod.common.net.messages.client.spawn.SpawnGenericBedrockPacket
@@ -140,37 +94,19 @@ import com.cobblemon.mod.common.net.messages.client.storage.party.InitializePart
 import com.cobblemon.mod.common.net.messages.client.storage.party.MoveClientPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.client.storage.party.SetPartyReferencePacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.ClosePCPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.InitializePCPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.MoveClientPCPokemonPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.OpenPCPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.RenamePCBoxPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCBoxPacket
-import com.cobblemon.mod.common.net.messages.client.storage.pc.SetPCPokemonPacket
+import com.cobblemon.mod.common.net.messages.client.storage.pc.*
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.ChangePCBoxWallpaperPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.RequestPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.SetPCBoxWallpapersPacket
 import com.cobblemon.mod.common.net.messages.client.storage.pc.wallpaper.UnlockPCBoxWallpaperPacket
 import com.cobblemon.mod.common.net.messages.client.toast.ToastPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeAcceptanceChangedPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeCancelledPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeCompletedPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferExpiredPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeOfferNotificationPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeProcessStartedPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeStartedPacket
-import com.cobblemon.mod.common.net.messages.client.trade.TradeUpdatedPacket
+import com.cobblemon.mod.common.net.messages.client.trade.*
 import com.cobblemon.mod.common.net.messages.client.ui.ExpGainedDataPacket
 import com.cobblemon.mod.common.net.messages.client.ui.InteractPokemonUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.PokedexUIPacket
 import com.cobblemon.mod.common.net.messages.client.ui.SummaryUIPacket
 import com.cobblemon.mod.common.net.messages.server.*
-import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
-import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamLeavePacket
-import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamRequestPacket
-import com.cobblemon.mod.common.net.messages.server.battle.BattleTeamResponsePacket
-import com.cobblemon.mod.common.net.messages.server.battle.RemoveSpectatorPacket
-import com.cobblemon.mod.common.net.messages.server.battle.SpectateBattlePacket
+import com.cobblemon.mod.common.net.messages.server.battle.*
 import com.cobblemon.mod.common.net.messages.server.behaviour.DamageOnCollisionPacket
 import com.cobblemon.mod.common.net.messages.server.behaviour.SetEntityBehaviourPacket
 import com.cobblemon.mod.common.net.messages.server.block.AdjustBlockEntityViewerCountPacket
@@ -186,13 +122,7 @@ import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidin
 import com.cobblemon.mod.common.net.messages.server.debug.ServerboundUpdateRidingStatsPacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.EscapeDialoguePacket
 import com.cobblemon.mod.common.net.messages.server.dialogue.InputToDialoguePacket
-import com.cobblemon.mod.common.net.messages.server.molangui.MolangUiActionPacket
-import com.cobblemon.mod.common.net.messages.server.molangui.MolangUiClosedPacket
-import com.cobblemon.mod.common.net.messages.server.molangui.MolangUiVersionPacket
 import com.cobblemon.mod.common.net.messages.server.npc.SaveNPCPacket
-import com.cobblemon.mod.common.net.messages.server.stadium.RequestStadiumPlacementWandPacket
-import com.cobblemon.mod.common.net.messages.server.stadium.StadiumPlacementSetPacket
-import com.cobblemon.mod.common.net.messages.server.stadium.UpdateStadiumBlockPacket
 import com.cobblemon.mod.common.net.messages.server.orientation.ServerboundUpdateOrientationPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.PasturePokemonPacket
 import com.cobblemon.mod.common.net.messages.server.pasture.SetPastureConflictPacket
@@ -201,11 +131,7 @@ import com.cobblemon.mod.common.net.messages.server.pasture.UnpasturePokemonPack
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.FinishScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokedex.scanner.StartScanningPacket
 import com.cobblemon.mod.common.net.messages.server.pokemon.interact.InteractPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.ServerboundUpdateRidingStatePacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetActiveMarkPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetItemHiddenPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetMarkingsPacket
-import com.cobblemon.mod.common.net.messages.server.pokemon.update.SetNicknamePacket
+import com.cobblemon.mod.common.net.messages.server.pokemon.update.*
 import com.cobblemon.mod.common.net.messages.server.pokemon.update.evolution.AcceptEvolutionPacket
 import com.cobblemon.mod.common.net.messages.server.riding.DismountPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateDriverInputPacket
@@ -213,25 +139,14 @@ import com.cobblemon.mod.common.net.messages.server.riding.ServerboundUpdateRide
 import com.cobblemon.mod.common.net.messages.server.starter.RequestStarterScreenPacket
 import com.cobblemon.mod.common.net.messages.server.storage.SwapPCPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.MovePartyPokemonPacket
-import com.cobblemon.mod.common.net.messages.server.storage.party.PartyTutorialPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.ReleasePartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.party.SwapPartyPokemonPacket
 import com.cobblemon.mod.common.net.messages.server.storage.pc.*
-import com.cobblemon.mod.common.net.messages.server.trade.AcceptTradeRequestPacket
-import com.cobblemon.mod.common.net.messages.server.trade.CancelTradePacket
-import com.cobblemon.mod.common.net.messages.server.trade.ChangeTradeAcceptancePacket
-import com.cobblemon.mod.common.net.messages.server.trade.OfferTradePacket
-import com.cobblemon.mod.common.net.messages.server.trade.PerformTradePacket
-import com.cobblemon.mod.common.net.messages.server.trade.UpdateTradeOfferPacket
+import com.cobblemon.mod.common.net.messages.server.trade.*
 import com.cobblemon.mod.common.net.serverhandling.ChallengeHandler
 import com.cobblemon.mod.common.net.serverhandling.ChallengeResponseHandler
 import com.cobblemon.mod.common.net.serverhandling.RequestInteractionsHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.BattleSelectActionsHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.RemoveSpectatorHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.SpectateBattleHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.TeamLeaveHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestHandler
-import com.cobblemon.mod.common.net.serverhandling.battle.TeamRequestResponseHandler
+import com.cobblemon.mod.common.net.serverhandling.battle.*
 import com.cobblemon.mod.common.net.serverhandling.behaviour.DamageOnCollisionPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.behaviour.SetEntityBehaviourHandler
 import com.cobblemon.mod.common.net.serverhandling.block.AdjustBlockEntityViewerCountHandler
@@ -247,16 +162,9 @@ import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRiding
 import com.cobblemon.mod.common.net.serverhandling.debug.ServerboundUpdateRidingStatsHandler
 import com.cobblemon.mod.common.net.serverhandling.dialogue.EscapeDialogueHandler
 import com.cobblemon.mod.common.net.serverhandling.dialogue.InputToDialogueHandler
-import com.cobblemon.mod.common.net.serverhandling.molangui.MolangUiActionHandler
-import com.cobblemon.mod.common.net.serverhandling.molangui.MolangUiClosedHandler
-import com.cobblemon.mod.common.net.serverhandling.molangui.MolangUiVersionHandler
 import com.cobblemon.mod.common.net.serverhandling.evolution.AcceptEvolutionHandler
 import com.cobblemon.mod.common.net.serverhandling.npc.SaveNPCHandler
-import com.cobblemon.mod.common.net.serverhandling.stadium.RequestStadiumPlacementWandHandler
-import com.cobblemon.mod.common.net.serverhandling.stadium.StadiumPlacementSetHandler
-import com.cobblemon.mod.common.net.serverhandling.stadium.UpdateStadiumBlockHandler
 import com.cobblemon.mod.common.net.serverhandling.orientation.ServerboundUpdateOrientationHandler
-import com.cobblemon.mod.common.net.serverhandling.storage.party.PartyTutorialPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.PasturePokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.SetPastureConflictHandler
 import com.cobblemon.mod.common.net.serverhandling.pasture.UnpastureAllPokemonHandler
@@ -264,11 +172,7 @@ import com.cobblemon.mod.common.net.serverhandling.pasture.UnpasturePokemonHandl
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.FinishScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokedex.scanner.StartScanningHandler
 import com.cobblemon.mod.common.net.serverhandling.pokemon.interact.InteractPokemonHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.ServerboundUpdateRidingStateHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetActiveMarkHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetItemHiddenHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetMarkingsHandler
-import com.cobblemon.mod.common.net.serverhandling.pokemon.update.SetNicknameHandler
+import com.cobblemon.mod.common.net.serverhandling.pokemon.update.*
 import com.cobblemon.mod.common.net.serverhandling.riding.DismountPokemonPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.DriverInputPacketHandler
 import com.cobblemon.mod.common.net.serverhandling.riding.ServerboundUpdateRiderRotationHandler
@@ -282,12 +186,7 @@ import com.cobblemon.mod.common.net.serverhandling.storage.party.MovePartyPokemo
 import com.cobblemon.mod.common.net.serverhandling.storage.party.ReleasePCPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.party.SwapPartyPokemonHandler
 import com.cobblemon.mod.common.net.serverhandling.storage.pc.*
-import com.cobblemon.mod.common.net.serverhandling.trade.AcceptTradeRequestHandler
-import com.cobblemon.mod.common.net.serverhandling.trade.CancelTradeHandler
-import com.cobblemon.mod.common.net.serverhandling.trade.ChangeTradeAcceptanceHandler
-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.net.serverhandling.trade.*
 import com.cobblemon.mod.common.util.server
 import net.minecraft.server.level.ServerPlayer

@@ -415,85 +314,9 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(BattlePersistentStatusPacket.ID, BattlePersistentStatusPacket::decode, BattlePersistentStatusHandler))
        list.add(PacketRegisterInfo(BattleMadeInvalidChoicePacket.ID, BattleMadeInvalidChoicePacket::decode, BattleMadeInvalidChoiceHandler))
        list.add(PacketRegisterInfo(BattleMusicPacket.ID, BattleMusicPacket::decode, BattleMusicHandler))
-        list.add(
-            PacketRegisterInfo(
-                BattleChallengeExpiredPacket.ID,
-                BattleChallengeExpiredPacket::decode,
-                BattleChallengeExpiredHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                BattleReplacePokemonPacket.ID,
-                BattleReplacePokemonPacket::decode,
-                BattleReplacePokemonHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                BattleTransformPokemonPacket.ID,
-                BattleTransformPokemonPacket::decode,
-                BattleTransformPokemonHandler
-            )
-        )
-
-        // Camera packets
-        list.add(
-            PacketRegisterInfo(
-                CameraStartPacket.ID,
-                CameraStartPacket::decode,
-                CameraStartHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CameraEndPacket.ID,
-                CameraEndPacket::decode,
-                CameraEndHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CameraDebugPacket.ID,
-                CameraDebugPacket::decode,
-                CameraDebugHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CameraTransformPacket.ID,
-                CameraTransformPacket::decode,
-                CameraTransformHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CameraFocusPacket.ID,
-                CameraFocusPacket::decode,
-                CameraFocusHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CameraStatePacket.ID,
-                CameraStatePacket::decode,
-                CameraStateHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                SplitScreenPacket.ID,
-                SplitScreenPacket::decode,
-                SplitScreenHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                CompositorPacket.ID,
-                CompositorPacket::decode,
-                CompositorHandler
-            )
-        )
+        list.add(PacketRegisterInfo(BattleChallengeExpiredPacket.ID, BattleChallengeExpiredPacket::decode, BattleChallengeExpiredHandler))
+        list.add(PacketRegisterInfo(BattleReplacePokemonPacket.ID, BattleReplacePokemonPacket::decode, BattleReplacePokemonHandler))
+        list.add(PacketRegisterInfo(BattleTransformPokemonPacket.ID, BattleTransformPokemonPacket::decode, BattleTransformPokemonHandler))

        // MultiBattleTeam Packets
        list.add(PacketRegisterInfo(TeamRequestNotificationPacket.ID, TeamRequestNotificationPacket::decode, TeamRequestNotificationHandler))
@@ -509,7 +332,7 @@ object CobblemonNetwork {
        // Data registries
        list.add(PacketRegisterInfo(AbilityRegistrySyncPacket.ID, AbilityRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(CobblemonMechanicsSyncPacket.ID, CobblemonMechanicsSyncPacket::decode, CobblemonMechanicsSyncHandler))
-        list.add(PacketRegisterInfo(PokemonInteractionsSyncPacket.ID, PokemonInteractionsSyncPacket::decode, DataRegistrySyncPacketHandler()))
+        list.add(PacketRegisterInfo(PokemonInteractionsSyncPacket.ID, PokemonInteractionsSyncPacket::decode, PokemonInteractionsSyncHandler))
        list.add(PacketRegisterInfo(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -532,11 +355,6 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(MarkRegistrySyncPacket.ID, MarkRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
        list.add(PacketRegisterInfo(RideSettingsSyncPacket.ID, RideSettingsSyncPacket::decode, RideSettingsSyncHandler))

-        // Molang UI packets
-        list.add(PacketRegisterInfo(MolangUiOpenPacket.ID, MolangUiOpenPacket::decode, MolangUiOpenHandler))
-        list.add(PacketRegisterInfo(MolangUiClosePacket.ID, MolangUiClosePacket::decode, MolangUiCloseHandler))
-        list.add(PacketRegisterInfo(MolangUiUpdatePacket.ID, MolangUiUpdatePacket::decode, MolangUiUpdateHandler))
-
        // Effects
        list.add(PacketRegisterInfo(SpawnSnowstormParticlePacket.ID, SpawnSnowstormParticlePacket::decode, SpawnSnowstormParticleHandler))
        list.add(PacketRegisterInfo(SpawnSnowstormEntityParticlePacket.ID, SpawnSnowstormEntityParticlePacket::decode, SpawnSnowstormEntityParticleHandler))
@@ -566,23 +384,8 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(OpenPasturePacket.ID, OpenPasturePacket::decode, OpenPastureHandler))
        list.add(PacketRegisterInfo(ClosePasturePacket.ID, ClosePasturePacket::decode, ClosePastureHandler))
        list.add(PacketRegisterInfo(PokemonPasturedPacket.ID, PokemonPasturedPacket::decode, PokemonPasturedHandler))
-        list.add(
-            PacketRegisterInfo(
-                PokemonUnpasturedPacket.ID,
-                PokemonUnpasturedPacket::decode,
-                PokemonUnpasturedHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                UpdatePastureConflictFlagPacket.ID,
-                UpdatePastureConflictFlagPacket::decode,
-                UpdatePastureConflictFlagHandler
-            )
-        )
-
-        // Stadium
-        list.add(PacketRegisterInfo(OpenStadiumConfigPacket.ID, OpenStadiumConfigPacket::decode, OpenStadiumConfigHandler))
+        list.add(PacketRegisterInfo(PokemonUnpasturedPacket.ID, PokemonUnpasturedPacket::decode, PokemonUnpasturedHandler))
+        list.add(PacketRegisterInfo(UpdatePastureConflictFlagPacket.ID, UpdatePastureConflictFlagPacket::decode, UpdatePastureConflictFlagHandler))

        // Orientation
        list.add(PacketRegisterInfo(ClientboundUpdateOrientationPacket.ID, ClientboundUpdateOrientationPacket::decode, ClientboundUpdateOrientationHandler))
@@ -657,7 +460,7 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(ReleasePCPokemonPacket.ID, ReleasePCPokemonPacket::decode, ReleasePCPokemonHandler))
        list.add(PacketRegisterInfo(UnlinkPlayerFromPCPacket.ID, UnlinkPlayerFromPCPacket::decode, UnlinkPlayerFromPCHandler))

-        list.add(PacketRegisterInfo(RequestRenamePCBoxPacket.ID, RequestRenamePCBoxPacket::decode, RequestRenamePCBoxHandler))
+        list.add(PacketRegisterInfo(RequestRenamePCBoxPacket.Companion.ID, RequestRenamePCBoxPacket.Companion::decode, RequestRenamePCBoxHandler))
        list.add(PacketRegisterInfo(PCBoxWallpapersPacket.ID, PCBoxWallpapersPacket::decode, PCBoxWallpapersHandler))
        list.add(PacketRegisterInfo(RequestChangePCBoxWallpaperPacket.ID, RequestChangePCBoxWallpaperPacket::decode, RequestChangePCBoxWallpaperHandler))
        list.add(PacketRegisterInfo(MarkPCBoxWallpapersSeenPacket.ID, MarkPCBoxWallpapersSeenPacket::decode, MarkPCBoxWallpapersSeenHandler))
@@ -715,9 +518,6 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(PartyPokemonMoveSelectedPacket.ID, PartyPokemonMoveSelectedPacket::decode, PartyPokemonMoveSelectedHandler))
        list.add(PacketRegisterInfo(PartyMoveSelectCancelledPacket.ID, PartyMoveSelectCancelledPacket::decode, PartyMoveSelectCancelledHandler))

-        //Party move tutorial toasts packets
-        list.add(PacketRegisterInfo(PartyTutorialPacket.ID, PartyTutorialPacket::decode, PartyTutorialPacketHandler))
-
        // Dialogue packets
        list.add(PacketRegisterInfo(EscapeDialoguePacket.ID, EscapeDialoguePacket::decode, EscapeDialogueHandler))
        list.add(PacketRegisterInfo(InputToDialoguePacket.ID, InputToDialoguePacket::decode, InputToDialogueHandler))
@@ -739,30 +539,8 @@ object CobblemonNetwork {
        list.add(PacketRegisterInfo(ToggleCookingPotLidPacket.ID, ToggleCookingPotLidPacket::decode, ToggleCookingPotLidHandler))

        // Behaviour Packets
-        list.add(
-            PacketRegisterInfo(
-                SetEntityBehaviourPacket.ID,
-                SetEntityBehaviourPacket::decode,
-                SetEntityBehaviourHandler
-            )
-        )
-        list.add(
-            PacketRegisterInfo(
-                DamageOnCollisionPacket.ID,
-                DamageOnCollisionPacket::decode,
-                DamageOnCollisionPacketHandler
-            )
-        )
-
-        // Molang UI packets
-        list.add(PacketRegisterInfo(MolangUiActionPacket.ID, MolangUiActionPacket::decode, MolangUiActionHandler))
-        list.add(PacketRegisterInfo(MolangUiClosedPacket.ID, MolangUiClosedPacket::decode, MolangUiClosedHandler))
-        list.add(PacketRegisterInfo(MolangUiVersionPacket.ID, MolangUiVersionPacket::decode, MolangUiVersionHandler))
-
-        // Stadium
-        list.add(PacketRegisterInfo(UpdateStadiumBlockPacket.ID, UpdateStadiumBlockPacket::decode, UpdateStadiumBlockHandler))
-        list.add(PacketRegisterInfo(RequestStadiumPlacementWandPacket.ID, RequestStadiumPlacementWandPacket::decode, RequestStadiumPlacementWandHandler))
-        list.add(PacketRegisterInfo(StadiumPlacementSetPacket.ID, StadiumPlacementSetPacket::decode, StadiumPlacementSetHandler))
+        list.add(PacketRegisterInfo(SetEntityBehaviourPacket.ID, SetEntityBehaviourPacket::decode, SetEntityBehaviourHandler))
+        list.add(PacketRegisterInfo(DamageOnCollisionPacket.ID, DamageOnCollisionPacket::decode, DamageOnCollisionPacketHandler))

        // Debug
        list.add(PacketRegisterInfo(RequestOpenRidingStatsDebugGUIPacket.ID, RequestOpenRidingStatsDebugGUIPacket::decode, RequestOpenRidingStatsDebugGUIHandler))
@@ -23,6 +23,7 @@ class AspectCriterion(
 ): SimpleCriterionCondition<MutableMap<ResourceLocation, MutableSet<String>>>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<AspectCriterion> = RecordCodecBuilder.create { it.group(
            //All three of these codecs used to use Codecs.createStrictOptionalFieldCodec, that no longer exists
            ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(AspectCriterion::playerCtx),
@@ -35,4 +36,4 @@ class AspectCriterion(
        val caughtAspects = context.getOrDefault(species, mutableSetOf())
        return this.aspects.all { it in caughtAspects }
    }
-}
+}
@@ -25,6 +25,7 @@ class BattleCountableCriterion(
 ): CountableCriterion<BattleCountableContext>(playerCtx, count) {

    companion object {
+        @JvmField
        val CODEC: Codec<BattleCountableCriterion> = RecordCodecBuilder.create { it.group(
            ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(BattleCountableCriterion::playerCtx),
            Codec.STRING.listOf().optionalFieldOf("battle_types", listOf("any")).forGetter(BattleCountableCriterion::battleTypes),
@@ -25,6 +25,7 @@ class CastPokeRodCriterionCondition(
 ): SimpleCriterionCondition<CastPokeRodContext>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<CastPokeRodCriterionCondition> = RecordCodecBuilder.create { it.group(
                EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(CastPokeRodCriterionCondition::playerCtx),
                Codec.STRING.optionalFieldOf("baitId", "empty_bait").forGetter(CastPokeRodCriterionCondition::baitId)
@@ -34,4 +35,4 @@ class CastPokeRodCriterionCondition(
    override fun matches(player: ServerPlayer, context: CastPokeRodContext): Boolean {
        return (context.baitId == this.baitId.asIdentifierDefaultingNamespace() || this.baitId == "empty_bait")
    }
-}
+}
@@ -31,6 +31,7 @@ class CaughtPokemonCriterion(
 ): CountableCriterion<CountablePokemonTypeContext>(playerCtx, count) {

    companion object {
+        @JvmField
        val CODEC: Codec<CaughtPokemonCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(CaughtPokemonCriterion::playerCtx),
            Codec.STRING.optionalFieldOf("type", "any").forGetter(CaughtPokemonCriterion::type),
@@ -42,4 +43,4 @@ class CaughtPokemonCriterion(
    override fun matches(player: ServerPlayer, context: CountablePokemonTypeContext): Boolean {
        return super.matches(player, context) && (context.type == type || type == "any")// && (context.species == species || species == "any")
    }
-}
+}
@@ -23,6 +23,7 @@ open class CountableCriterion<T : CountableContext>(
 ): SimpleCriterionCondition<T>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<CountableCriterion<CountableContext>> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(CountableCriterion<CountableContext>::playerCtx),
            Codec.INT.optionalFieldOf("count", 0).forGetter(CountableCriterion<CountableContext>::count)
@@ -26,6 +26,7 @@ class EvolvePokemonCriterion(
 ): CountableCriterion<EvolvePokemonContext>(playerCtx, count) {

    companion object {
+        @JvmField
        val CODEC: Codec<EvolvePokemonCriterion> = RecordCodecBuilder.create { it.group(
            ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(EvolvePokemonCriterion::playerCtx),
            Codec.STRING.optionalFieldOf("species", "any").forGetter(EvolvePokemonCriterion::species),
@@ -25,6 +25,7 @@ class LevelUpCriterion(
 ): SimpleCriterionCondition<LevelUpContext>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<LevelUpCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(LevelUpCriterion::playerCtx),
            Codec.INT.optionalFieldOf("level", 0).forGetter(LevelUpCriterion::level),
@@ -42,4 +43,4 @@ class LevelUpCriterion(
        return level == context.level && evolutionCheck == evolved
    }

-}
+}
@@ -24,6 +24,7 @@ class PartyCheckCriterion(
 ): SimpleCriterionCondition<PlayerPartyStore>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<PartyCheckCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(PartyCheckCriterion::playerCtx),
            ResourceLocation.CODEC.listOf().optionalFieldOf("party", listOf()).forGetter(PartyCheckCriterion::party)
@@ -47,4 +48,4 @@ class PartyCheckCriterion(
        }
        return matches.containsAll(party) && matches.size == party.size
    }
-}
+}
@@ -23,6 +23,7 @@ class PlantTumblestoneCriterion(
 ): SimpleCriterionCondition<PlantTumblestoneContext>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<PlantTumblestoneCriterion> = RecordCodecBuilder.create { it.group(
            ContextAwarePredicate.CODEC.optionalFieldOf("player").forGetter(PlantTumblestoneCriterion::playerCtx)
        ).apply(it, ::PlantTumblestoneCriterion) }
@@ -24,6 +24,7 @@ class PokemonCriterion(
 ): SimpleCriterionCondition<Pokemon>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<PokemonCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(PokemonCriterion::playerCtx),
            Codec.STRING.optionalFieldOf("species", "any").forGetter(PokemonCriterion::species),
@@ -35,4 +36,4 @@ class PokemonCriterion(
        var speciesCheck = (species.equals(context.species.resourceIdentifier.path) || species.equals(context.species.resourceIdentifier.toString())) || species.equals("any")
        return speciesCheck && properties.matches(context)
    }
-}
+}
@@ -25,6 +25,7 @@ class PokemonInteractCriterion(
    val item: String
 ): SimpleCriterionCondition<PokemonInteractContext>(playerCtx) {
    companion object {
+        @JvmField
        val CODEC: Codec<PokemonInteractCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(PokemonInteractCriterion::playerCtx),
            Codec.STRING.optionalFieldOf("species", "any").forGetter(PokemonInteractCriterion::species),
@@ -35,4 +36,4 @@ class PokemonInteractCriterion(
    override fun matches(player: ServerPlayer, context: PokemonInteractContext): Boolean {
        return (context.species == this.species.asIdentifierDefaultingNamespace() || this.species == "any") && (context.item == this.item.asIdentifierDefaultingNamespace() || this.item == "any")
    }
-}
+}
@@ -26,6 +26,7 @@ class ReelInPokemonCriterionCondition(
 ) : SimpleCriterionCondition<ReelInPokemonContext>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<ReelInPokemonCriterionCondition> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter { it.playerCtx },
            Codec.STRING.optionalFieldOf("species", "any").forGetter { it.species },
@@ -37,4 +38,4 @@ class ReelInPokemonCriterionCondition(
        return (context.species == this.species.asIdentifierDefaultingNamespace() || this.species == "any")
                && (context.baitId == this.baitId.asIdentifierDefaultingNamespace() || this.baitId == "any" || this.baitId == "empty_bait")
    }
-}
+}
@@ -28,6 +28,7 @@ class TradePokemonCriterion(
 ): SimpleCriterionCondition<TradePokemonContext>(playerCtx) {

    companion object {
+        @JvmField
        val CODEC: Codec<TradePokemonCriterion> = RecordCodecBuilder.create { it.group(
            EntityPredicate.ADVANCEMENT_CODEC.optionalFieldOf("player").forGetter(TradePokemonCriterion::playerCtx),
            Codec.STRING.optionalFieldOf("traded", "any").forGetter(TradePokemonCriterion::traded),
@@ -18,7 +18,7 @@ import net.minecraft.resources.ResourceKey

 object CobblemonEntitySubPredicates : PlatformRegistry<Registry<MapCodec<out EntitySubPredicate>>, ResourceKey<Registry<MapCodec<out EntitySubPredicate>>>, MapCodec<out EntitySubPredicate>>() {

-    @JvmStatic
+    @JvmField
    val POKE_POBBER = this.create("poke_bobber", FishingBobberPredicate.CODEC)

    override val registry: Registry<MapCodec<out EntitySubPredicate>> = BuiltInRegistries.ENTITY_SUB_PREDICATE_TYPE
@@ -24,7 +24,7 @@ class FishingBobberPredicate(val inOpenWater: Boolean) : EntitySubPredicate {
        return (entity as? PokeRodFishingBobberEntity)?.inOpenWater == this.inOpenWater
    }
    companion object {
-        @JvmStatic
+        @JvmField
        val CODEC: MapCodec<FishingBobberPredicate> = RecordCodecBuilder.mapCodec { instance ->
            instance.group(
                Codec.BOOL.fieldOf("in_open_water").forGetter(FishingBobberPredicate::inOpenWater)
@@ -22,7 +22,7 @@ enum class Priority : StringRepresentable {

    companion object {

-        @JvmStatic
+        @JvmField
        val CODEC: Codec<Priority> = StringRepresentable.fromEnum(Priority::values)

    }
@@ -104,7 +104,7 @@ open class Ability internal constructor(var template: AbilityTemplate, forced: B

    companion object {

-        @JvmStatic
+        @JvmField
        val CODEC: Codec<Ability> = RecordCodecBuilder.create {
            it.group(
                AbilityTemplate.CODEC.fieldOf(DataKeys.POKEMON_ABILITY_NAME).forGetter(Ability::template),
@@ -47,7 +47,7 @@ class AbilityTemplate(

    companion object {

-        @JvmStatic
+        @JvmField
        val CODEC: Codec<AbilityTemplate> = CodecUtils.createByStringCodec(
            Abilities::getOrDummy,
            AbilityTemplate::name
@@ -29,6 +29,7 @@ interface PotentialAbility {
    val type: PotentialAbilityType<*>
    fun isSatisfiedBy(aspects: Set<String>): Boolean
    companion object {
+        @JvmField
        val types = mutableListOf<PotentialAbilityType<*>>()
    }
 }
@@ -51,5 +52,4 @@ open class CommonAbility(override val template: AbilityTemplate) : PotentialAbil
    override val priority = Priority.LOWEST
    override val type = CommonAbilityType
    override fun isSatisfiedBy(aspects: Set<String>) = true
-}
-
+}
@@ -26,8 +26,9 @@ class AttackHostileMobsTaskConfig : SingleTaskConfig {
    ): BehaviorControl<in LivingEntity>? {
        return AttackHostileMobsTask.create()
    }
-    
+
    companion object {
+        @JvmField
        val CODEC: Codec<AttackHostileMobsTaskConfig> = Codec.unit(AttackHostileMobsTaskConfig())
    }
 }
@@ -17,7 +17,6 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangV
 import com.cobblemon.mod.common.entity.OmniPathingEntity
 import com.cobblemon.mod.common.entity.ai.CobblemonRandomSurfacePos
 import com.cobblemon.mod.common.entity.ai.CobblemonWalkTarget
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.mainThreadRuntime
 import com.cobblemon.mod.common.util.resolveFloat
@@ -185,12 +184,6 @@ class WanderTaskConfig : SingleTaskConfig {

                        if (targetVec == null) continue

-                        // Ignore pathing targets outside of the pasture zone if the pokemon is pastured.
-                        val tethering = (entity as? PokemonEntity)?.tethering
-                        if (tethering?.canRoamTo(BlockPos.containing(targetVec)) == false) {
-                            continue
-                        }
-
                        pos = applyHeightConstraints(
                            pos = BlockPos.containing(targetVec),
                            minimumHeight = minimumHeight,
@@ -99,6 +99,7 @@ enum class Apricorn : StringRepresentable {
    override fun getSerializedName() = this.name.lowercase()

    companion object {
+        @JvmField
        val CODEC: Codec<Apricorn> = StringRepresentable.fromValues(::values)
    }
 }
@@ -22,21 +22,18 @@ import com.cobblemon.mod.common.api.battles.model.actor.EntityBackedBattleActor
 import com.cobblemon.mod.common.api.battles.model.actor.FleeableBattleActor
 import com.cobblemon.mod.common.api.events.CobblemonEvents
 import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
-import com.cobblemon.mod.common.api.events.battles.BattleFleeAttemptEvent
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.api.pokemon.stats.BattleEvSource
 import com.cobblemon.mod.common.api.storage.party.PlayerPartyStore
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.api.text.red
-import com.cobblemon.mod.common.api.text.white
 import com.cobblemon.mod.common.api.text.yellow
 import com.cobblemon.mod.common.battles.ActiveBattlePokemon
 import com.cobblemon.mod.common.battles.BattleCaptureAction
 import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.battles.BattleRegistry
 import com.cobblemon.mod.common.battles.BattleSide
-import com.cobblemon.mod.common.battles.FleeAttemptActionResponse
 import com.cobblemon.mod.common.battles.ForfeitActionResponse
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.battles.dispatch.BattleDispatch
@@ -51,9 +48,7 @@ import com.cobblemon.mod.common.entity.npc.NPCBattleActor
 import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.battle.BattleEndPacket
-import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMessagePacket
-import com.cobblemon.mod.common.net.messages.client.battle.BattleQueueRequestPacket
 import com.cobblemon.mod.common.pokemon.evolution.progress.DefeatEvolutionProgress
 import com.cobblemon.mod.common.pokemon.evolution.progress.LastBattleCriticalHitsEvolutionProgress
 import com.cobblemon.mod.common.pokemon.requirements.DefeatRequirement
@@ -85,9 +80,7 @@ open class PokemonBattle(
    /** Whether logging will be silenced for this battle. */
    var mute = !CobblemonBuildDetails.SNAPSHOT
    val struct = this.asMoLangValue()
-    val runtime = MoLangRuntime().also {
-        it.environment.query = struct
-    }
+    val runtime = MoLangRuntime().also { it.environment.query = struct }

    val onEndHandlers: MutableList<(PokemonBattle) -> Unit> = mutableListOf()

@@ -144,9 +137,6 @@ open class PokemonBattle(
    val captureActions = mutableListOf<BattleCaptureAction>()

    val majorBattleActions = hashMapOf<UUID, BattleMessage>()
-
-    /** Monotonically increasing counter to track faint ordering within this battle. */
-    var faintCounter = 0
    val minorBattleActions = hashMapOf<UUID, BattleMessage>()
    val contextManager = ContextManager()

@@ -254,23 +244,12 @@ open class PokemonBattle(

    fun end() {
        ended = true
-        val awardToFainted = Cobblemon.config.awardExperienceToFaintedPokemon
-        val awardOnLoss = Cobblemon.config.awardExperienceOnBattleLoss
        this.actors.forEach { actor ->
            val faintedPokemons = actor.pokemonList.filter { it.health <= 0 }
            actor.getSide().getOppositeSide().actors.forEach { opponent ->
-                val opponentPokemons = if (awardToFainted) opponent.pokemonList else opponent.pokemonList.filter { it.health > 0 }
+                val opponentNonFaintedPokemons = opponent.pokemonList.filter { it.health > 0 }
                faintedPokemons.forEach { faintedPokemon ->
-                    for (opponentPokemon in opponentPokemons) {
-                        // Faint-order check: if awarding XP to fainted pokemon, only award for enemies that fainted before this pokemon did
-                        if (awardToFainted) {
-                            val enemyFaintedAt = faintedPokemon.faintedAt ?: continue
-                            val opponentFaintedAt = opponentPokemon.faintedAt
-                            if (opponentFaintedAt != null && opponentFaintedAt <= enemyFaintedAt) {
-                                continue
-                            }
-                        }
-
+                    for (opponentPokemon in opponentNonFaintedPokemons) {
                        val facedFainted = opponentPokemon.facedOpponents.contains(faintedPokemon)
                        val pokemon = opponentPokemon.effectedPokemon
                        if (facedFainted) {
@@ -291,8 +270,7 @@ open class PokemonBattle(
                            else -> continue
                        }
                        val experience = Cobblemon.experienceCalculator.calculate(opponentPokemon, faintedPokemon, multiplier)
-                        val enemyTeamWiped = actor.pokemonList.all { it.health <= 0 }
-                        if (experience > 0 && (enemyTeamWiped || awardOnLoss)) {
+                        if (experience > 0 && actor.pokemonList.all { it.health <= 0 }) {
                            opponent.awardExperience(opponentPokemon, experience)
                        }
                        Cobblemon.evYieldCalculator.calculate(opponentPokemon, faintedPokemon).forEach { (stat, amount) ->
@@ -326,8 +304,7 @@ open class PokemonBattle(
            .forEach{it.pokemon.heal()}
        actors.forEach { actor ->
            actor.pokemonList.forEach { battlePokemon ->
-                battlePokemon.postBattlePokemonOperations.forEach { it(battlePokemon) }
-                battlePokemon.entity?.let { entity -> battlePokemon.postBattleEntityOperations.forEach { it(entity) } }
+                battlePokemon.entity?.let { entity -> battlePokemon.postBattleEntityOperation(entity) }
                if (battlePokemon.effectedPokemon.entity != null
                        && battlePokemon.effectedPokemon.entity?.beamMode == 0
                        && battlePokemon.effectedPokemon.entity?.platform != PlatformType.NONE) {
@@ -521,13 +498,12 @@ open class PokemonBattle(
    }

    fun stop() {
-        writeShowdownAction(">forcetie") // This will terminate the Showdown connection
        end()
+        writeShowdownAction(">forcetie") // This will terminate the Showdown connection
    }

    fun checkForInputDispatch() {
        if (checkForfeit()) return  // ignore actors that are still choosing, their choices don't matter anymore
-        if (checkFleeAttempt()) return
        val readyToInput = (actors.any { !it.mustChoose && it.responses.isNotEmpty() } && actors.none { it.mustChoose })
        if (readyToInput && captureActions.isEmpty()) {
            actors.filter { it.responses.isNotEmpty() }.forEach { it.writeShowdownResponse() }
@@ -535,20 +511,6 @@ open class PokemonBattle(
        }
    }

-    private fun checkFleeAttempt(): Boolean {
-        val runner = actors.find { it.responses.any { it is FleeAttemptActionResponse }  } as? PlayerBattleActor ?: return false
-        CobblemonEvents.BATTLE_FLEE_ATTEMPT.post(BattleFleeAttemptEvent(this, runner))
-        runner.responses.clear()
-
-        runner.mustChoose = true
-        runner.request?.let { runner.sendUpdate(BattleQueueRequestPacket(it)) }
-        runner.sendUpdate(BattleMakeChoicePacket())
-
-        runner.entity?.sendSystemMessage(battleLang("run_prompt").white())
-
-        return true
-    }
-
    /** Forces Showdown to end the battle when a [BattleActor] chooses to forfeit. */
    private fun checkForfeit(): Boolean {
        val forfeit = actors.find { it.responses.any { it is ForfeitActionResponse } }
@@ -26,9 +26,8 @@ import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacke
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMessagePacket
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.phys.Vec3
 import java.util.UUID
+import net.minecraft.server.level.ServerPlayer

 abstract class BattleActor(
    val uuid: UUID,
@@ -55,11 +54,6 @@ abstract class BattleActor(
    var itemsUsed = mutableListOf<BagItem>()
    /** For when battles start, it's the number of Pokémon that are still in the process of being sent out (animation wise) */
    var stillSendingOutCount = 0
-    /**
-     * Optional override for send-out positions. When present the indexes follow the
-     * actor's active slot order (e.g. slot `a` -> index 0).
-     */
-    var stadiumSendOutPositions: List<Vec3>? = null

    abstract val type: ActorType

@@ -24,6 +24,7 @@ class AllBiomeCondition(val minGroveSize: Int, val maxGroveSize: Int) : BerrySpa
    }

    companion object {
+        @JvmField
        val ID = cobblemonResource("all_biome")
    }
-}
+}
@@ -26,6 +26,7 @@ class PreferredBiomeCondition(val minGroveSize: Int, val maxGroveSize: Int) : Be
    }

    companion object {
+        @JvmField
        val ID = cobblemonResource("preferred_biome")
    }
-}
+}
@@ -24,6 +24,7 @@ class SpecificBiomeCondition : BerrySpawnCondition {
    override fun getGroveSize(random: RandomSource) = random.nextIntBetweenInclusive(minGroveSize, maxGroveSize)

    companion object {
+        @JvmField
        val ID = cobblemonResource("specific_biome")
    }
 }
@@ -1,200 +0,0 @@
-/*
- * 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.api.camera
-
-import com.cobblemon.mod.common.Cobblemon
-import net.minecraft.resources.ResourceKey
-import net.minecraft.server.MinecraftServer
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.level.ChunkPos
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.chunk.LevelChunk
-import net.minecraft.world.level.chunk.status.ChunkStatus
-import java.util.ArrayDeque
-import java.util.UUID
-
-/**
- * Handles chunk forceloading for cameras.
- * Chunks are queued and processed in small batches each tick to avoid overwhelming the server.
- */
-object CameraChunkLoader {
-    private const val MAX_CHUNKS_PER_TICK = 16
-
-    private data class CameraState(
-        var dimension: ResourceKey<Level>,
-        val chunks: MutableSet<Long>
-    )
-
-    private data class ChunkRequest(
-        val dimension: ResourceKey<Level>,
-        val chunkPos: ChunkPos,
-        val load: Boolean
-    )
-
-    private val cameraStates = mutableMapOf<UUID, CameraState>()
-    private val chunkOwners = mutableMapOf<ResourceKey<Level>, MutableMap<Long, MutableSet<UUID>>>()
-    private val pendingRequests: ArrayDeque<ChunkRequest> = ArrayDeque()
-    private val pendingAsyncLoads = mutableSetOf<Pair<ResourceKey<Level>, Long>>()
-
-    fun ensureArea(level: ServerLevel, cameraId: UUID, centerChunk: ChunkPos, radius: Int) {
-        val dimension = level.dimension()
-        val state = cameraStates[cameraId]?.takeIf { it.dimension == dimension } ?: run {
-            cameraStates.remove(cameraId)?.let { oldState ->
-                oldState.chunks.forEach { chunkLong ->
-                    removeOwnership(oldState.dimension, chunkLong, cameraId)
-                }
-            }
-
-            CameraState(dimension, mutableSetOf()).also { cameraStates[cameraId] = it }
-        }
-
-        val newChunks = buildChunkSet(centerChunk, radius)
-        val currentChunks = state.chunks
-
-        val toRemove = currentChunks.minus(newChunks)
-        val toAdd = newChunks.minus(currentChunks)
-
-        if (toRemove.isNotEmpty()) {
-            toRemove.forEach { chunkLong ->
-                removeOwnership(dimension, chunkLong, cameraId)
-                currentChunks.remove(chunkLong)
-            }
-        }
-
-        if (toAdd.isNotEmpty()) {
-            toAdd.forEach { chunkLong ->
-                addOwnership(dimension, chunkLong, cameraId)
-                currentChunks.add(chunkLong)
-            }
-        }
-    }
-
-    fun clear(cameraId: UUID) {
-        val state = cameraStates.remove(cameraId) ?: return
-        val dimension = state.dimension
-        state.chunks.forEach { chunkLong ->
-            removeOwnership(dimension, chunkLong, cameraId)
-        }
-    }
-
-    fun tick(server: MinecraftServer) {
-        if (pendingRequests.isEmpty()) {
-            return
-        }
-
-        var processed = 0
-        while (processed < MAX_CHUNKS_PER_TICK && pendingRequests.isNotEmpty()) {
-            val request = pendingRequests.removeFirst()
-            val level = server.getLevel(request.dimension) ?: continue
-
-            level.setChunkForced(request.chunkPos.x, request.chunkPos.z, request.load)
-
-            if (request.load) {
-                scheduleAsyncLoad(level, request.dimension, request.chunkPos)
-            }
-
-            processed++
-        }
-    }
-
-    private fun addOwnership(dimension: ResourceKey<Level>, chunkLong: Long, cameraId: UUID) {
-        val ownersForDimension = chunkOwners.computeIfAbsent(dimension) { mutableMapOf() }
-        val owners = ownersForDimension.computeIfAbsent(chunkLong) { mutableSetOf() }
-
-        if (owners.add(cameraId) && owners.size == 1) {
-            pendingRequests.add(
-                ChunkRequest(
-                    dimension,
-                    ChunkPos(chunkLong),
-                    true
-                )
-            )
-        }
-    }
-
-    private fun removeOwnership(dimension: ResourceKey<Level>, chunkLong: Long, cameraId: UUID) {
-        val ownersForDimension = chunkOwners[dimension] ?: return
-        val owners = ownersForDimension[chunkLong] ?: return
-
-        if (!owners.remove(cameraId)) {
-            return
-        }
-
-        if (owners.isEmpty()) {
-            ownersForDimension.remove(chunkLong)
-            if (ownersForDimension.isEmpty()) {
-                chunkOwners.remove(dimension)
-            }
-
-            pendingRequests.add(
-                ChunkRequest(
-                    dimension,
-                    ChunkPos(chunkLong),
-                    false
-                )
-            )
-        }
-    }
-
-    private fun scheduleAsyncLoad(level: ServerLevel, dimension: ResourceKey<Level>, chunkPos: ChunkPos) {
-        val key = dimension to chunkPos.toLong()
-
-        if (!pendingAsyncLoads.add(key)) {
-            return
-        }
-
-        if (Cobblemon.LOGGER.isDebugEnabled) {
-            Cobblemon.LOGGER.debug(
-                "[CobblemonCamera] Scheduling async load for chunk {} in {}",
-                chunkPos,
-                dimension.location()
-            )
-        }
-
-        level.chunkSource
-            .getChunkFuture(chunkPos.x, chunkPos.z, ChunkStatus.FULL, true)
-            .thenAcceptAsync({ result ->
-                result.ifSuccess { chunkAccess ->
-                    if (chunkAccess is LevelChunk && Cobblemon.LOGGER.isDebugEnabled) {
-                        Cobblemon.LOGGER.debug(
-                            "[CobblemonCamera] Async loaded chunk {} (light={}, entities={})",
-                            chunkPos,
-                            chunkAccess.isLightCorrect,
-                            chunkAccess.blockEntities.size
-                        )
-                    }
-                }
-
-                pendingAsyncLoads.remove(key)
-            }, level.server)
-            .exceptionally { throwable ->
-                level.server.execute {
-                    pendingAsyncLoads.remove(key)
-                    Cobblemon.LOGGER.warn(
-                        "[CobblemonCamera] Exception while async loading chunk {}: {}",
-                        chunkPos,
-                        throwable.message
-                    )
-                }
-                null
-            }
-    }
-
-    private fun buildChunkSet(centerChunk: ChunkPos, radius: Int): MutableSet<Long> {
-        val chunks = mutableSetOf<Long>()
-
-        for (x in centerChunk.x - radius..centerChunk.x + radius) {
-            for (z in centerChunk.z - radius..centerChunk.z + radius) {
-                chunks.add(ChunkPos.asLong(x, z))
-            }
-        }
-
-        return chunks
-    }
-}
@@ -1,203 +0,0 @@
-/*
- * 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.api.camera
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.MoParams
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.integration.server.CameraExecutor
-import com.cobblemon.mod.common.api.camera.integration.server.CameraInstance
-import com.cobblemon.mod.common.api.camera.integration.server.CameraNetworkSync
-import com.cobblemon.mod.common.api.camera.registry.TimelineRegistry
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
-import net.minecraft.core.SectionPos
-import net.minecraft.server.level.ChunkTrackingView
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.util.Mth
-import net.minecraft.world.level.ChunkPos
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-
-/**
- * Server-side camera controller.
- *
- * Orchestrates camera instance, executor, network sync, and chunk/viewer management.
- * Delegates responsibilities to focused components.
- */
-class CameraController(
-    override val id: UUID = UUID.randomUUID(),
-    val context: Map<String, MoValue> = emptyMap(),
-    override val origin: Vec3 = Vec3.ZERO,
-    val queryFunctions: Map<String, java.util.function.Function<MoParams, Any>> = emptyMap()
-) : ICameraController {
-    private val instance: CameraInstance
-    private val runtime: MoLangRuntime
-    private lateinit var executor: CameraExecutor
-    private lateinit var networkSync: CameraNetworkSync
-
-    private val viewers = mutableSetOf<UUID>()
-    private val viewerChunkStates = mutableMapOf<UUID, ViewerChunkState>()
-    private var level: ServerLevel? = null
-
-    init {
-        runtime = MoLangRuntime().setup()
-        runtime.environment.query.functions.putAll(queryFunctions)
-        instance = CameraInstance(id, origin, context, queryFunctions)
-        executor = CameraExecutor(instance, runtime, context)
-        networkSync = CameraNetworkSync(id, viewers)
-        Cobblemon.LOGGER.debug("[CameraController] Initialized $id")
-    }
-
-    private data class ViewerChunkState(
-        val viewDistance: Int,
-        var centerChunk: ChunkPos,
-        var chunkView: ChunkTrackingView
-    )
-
-    override fun startTimeline(timelineId: String): Boolean {
-        val timeline = TimelineRegistry.getTimeline(timelineId)
-        if (timeline == null) {
-            Cobblemon.LOGGER.error("[CameraController] Timeline '$timelineId' not found")
-            return false
-        }
-
-        return if (instance.startTimeline(timeline)) {
-            Cobblemon.LOGGER.info("[CameraController] Started '$timelineId'")
-            true
-        } else {
-            Cobblemon.LOGGER.error("[CameraController] Engine start failed for '$timelineId'")
-            false
-        }
-    }
-
-    override fun tick() {
-        val currentLevel = level ?: return
-        val stillActive = executor.tick(currentLevel, networkSync) { chunkPos ->
-            updateViewerChunkViews(chunkPos)
-        }
-
-        // If timeline ended, stop the camera and notify all viewers
-        if (!stillActive && viewers.isNotEmpty()) {
-            Cobblemon.LOGGER.info("[CameraController] Timeline ended naturally, stopping camera")
-            stop()
-        }
-    }
-
-    private fun updateViewerChunkViews(chunkPos: ChunkPos) {
-        viewerChunkStates.forEach { (viewerId, state) ->
-            if (state.centerChunk == chunkPos) return@forEach
-
-            state.centerChunk = chunkPos
-            val newView = ChunkTrackingView.of(chunkPos, state.viewDistance)
-            state.chunkView = newView
-            CameraManager.registerViewerChunkView(viewerId, newView)
-        }
-
-        val serverLevel = level
-        if (serverLevel != null && viewerChunkStates.isNotEmpty()) {
-            val maxDistance = viewerChunkStates.values.maxOf { it.viewDistance }
-            CameraChunkLoader.ensureArea(serverLevel, id, chunkPos, maxDistance)
-        }
-    }
-
-    override fun addViewer(player: ServerPlayer) {
-        viewers.add(player.uuid)
-        registerViewerChunkView(player, origin)
-        networkSync.sendStart(origin)
-    }
-
-    /**
-     * Adds a player as a feed viewer without sending CameraStartPacket.
-     *
-     * The player receives transform/focus updates like a normal viewer, but
-     * the camera will NOT become the primary camera on the client. This is
-     * used for secondary cameras (e.g. Camera B in split-screen) that render
-     * to an off-screen RenderTarget via CameraFeedHandler.
-     */
-    fun addFeedViewer(player: ServerPlayer) {
-        viewers.add(player.uuid)
-        registerViewerChunkView(player, origin)
-        // No sendStart() — intentionally skipped so the client doesn't set this as primary
-    }
-
-    private fun registerViewerChunkView(player: ServerPlayer, centerPosition: Vec3) {
-        val playerLevel = player.serverLevel()
-        if (level == null || level != playerLevel) {
-            level?.let { CameraChunkLoader.clear(id) }
-            level = playerLevel
-        }
-
-        val maxViewDistance = player.server.playerList.viewDistance
-        val viewDistance = Mth.clamp(player.requestedViewDistance(), 2, maxViewDistance)
-        val chunkPos = chunkPosFrom(centerPosition)
-        val chunkView = ChunkTrackingView.of(chunkPos, viewDistance)
-
-        viewerChunkStates[player.uuid] = ViewerChunkState(viewDistance, chunkPos, chunkView)
-        CameraManager.registerViewerChunkView(player.uuid, chunkView)
-
-        val maxDistance = viewerChunkStates.values.maxOfOrNull { it.viewDistance } ?: viewDistance
-        CameraChunkLoader.ensureArea(playerLevel, id, chunkPos, maxDistance)
-    }
-
-    override fun removeViewer(player: ServerPlayer) {
-        // Send end packet to THIS player specifically
-        networkSync.sendEndToPlayer(player)
-
-        viewers.remove(player.uuid)
-        viewerChunkStates.remove(player.uuid)
-        CameraManager.clearViewerChunkView(player.uuid)
-
-        if (viewers.isEmpty()) {
-            CameraChunkLoader.clear(id)
-            level = null
-        } else {
-            val serverLevel = level
-            if (serverLevel != null && viewerChunkStates.isNotEmpty()) {
-                val state = viewerChunkStates.values.first()
-                val maxDistance = viewerChunkStates.values.maxOf { it.viewDistance }
-                CameraChunkLoader.ensureArea(serverLevel, id, state.centerChunk, maxDistance)
-            }
-        }
-    }
-
-    override fun stop() {
-        instance.stop()
-        networkSync.sendEnd()
-        viewerChunkStates.keys.toList().forEach { CameraManager.clearViewerChunkView(it) }
-        viewerChunkStates.clear()
-        CameraChunkLoader.clear(id)
-        level = null
-        viewers.clear()
-    }
-
-    override fun isActive() = instance.isActive()
-
-    fun setFlag(name: String, value: Boolean) = setVariable(name, if (value) 1.0 else 0.0)
-
-    override fun setVariable(name: String, value: Double) = instance.setVariable(name, value)
-
-    override fun setFocusOverride(position: Vec3?) {
-        instance.focusOverride = position
-    }
-    
-    override fun triggerInstantTransition() = instance.triggerInstantTransition()
-
-    override fun addQueryFunctions(functions: Map<String, java.util.function.Function<MoParams, Any>>) {
-        runtime.environment.query.functions.putAll(functions)
-        instance.addQueryFunctions(functions)
-    }
-
-    private fun chunkPosFrom(position: Vec3): ChunkPos {
-        val chunkX = SectionPos.blockToSectionCoord(Mth.floor(position.x))
-        val chunkZ = SectionPos.blockToSectionCoord(Mth.floor(position.z))
-        return ChunkPos(chunkX, chunkZ)
-    }
-}
@@ -1,164 +0,0 @@
-/*
- * 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.api.camera
-
-import com.bedrockk.molang.runtime.MoParams
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.components.CameraChunkManager
-import com.cobblemon.mod.common.api.camera.components.CameraLifecycleManager
-import com.cobblemon.mod.common.api.camera.components.CameraViewerManager
-import com.cobblemon.mod.common.api.events.CobblemonEvents
-import com.cobblemon.mod.common.api.events.camera.CameraStartedEvent
-import com.cobblemon.mod.common.api.events.camera.CameraStoppedEvent
-import com.cobblemon.mod.common.api.events.camera.CameraViewerAddedEvent
-import com.cobblemon.mod.common.api.events.camera.CameraViewerRemovedEvent
-import com.cobblemon.mod.common.battles.stadium.StadiumBattleCameraCoordinator
-import net.minecraft.server.level.ChunkTrackingView
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-import java.util.function.Function
-
-object CameraManager : ICameraManager {
-
-    private val lifecycleManager = CameraLifecycleManager()
-    private val viewerManager = CameraViewerManager()
-    private val chunkManager = CameraChunkManager()
-
-    override fun startCamera(
-        timelineId: String,
-        context: Map<String, MoValue>,
-        viewers: List<ServerPlayer>,
-        origin: Vec3,
-        queryFunctions: Map<String, Function<MoParams, Any>>
-    ): UUID? {
-        val camera = CameraController(
-            context = context,
-            origin = origin,
-            queryFunctions = queryFunctions
-        )
-
-        val preEvent = CameraStartedEvent.Pre(camera.id, camera, timelineId, viewers)
-        CobblemonEvents.CAMERA_STARTED_PRE.emit(preEvent)
-        if (preEvent.isCanceled) {
-            Cobblemon.LOGGER.info("[CobblemonCamera] Camera start canceled by event listener")
-            return null
-        }
-
-        if (!camera.startTimeline(timelineId)) {
-            Cobblemon.LOGGER.warn("[CobblemonCamera] Failed to start timeline '$timelineId'")
-            return null
-        }
-
-        lifecycleManager.registerCamera(camera)
-
-        viewers.forEach { player ->
-            camera.addViewer(player)
-            viewerManager.assignViewerToCamera(player.uuid, camera.id)
-
-            CobblemonEvents.CAMERA_VIEWER_ADDED.emit(
-                CameraViewerAddedEvent(camera.id, camera, player)
-            )
-        }
-
-        CobblemonEvents.CAMERA_STARTED_POST.emit(
-            CameraStartedEvent.Post(camera.id, camera, timelineId, viewers)
-        )
-
-        Cobblemon.LOGGER.info("[CobblemonCamera] Started camera ${camera.id} with timeline '$timelineId' for ${viewers.size} viewers")
-        return camera.id
-    }
-
-    override fun addViewerToCamera(player: ServerPlayer, cameraId: UUID): Boolean {
-        val camera = lifecycleManager.getCamera(cameraId) ?: return false
-
-        camera.addViewer(player)
-        viewerManager.assignViewerToCamera(player.uuid, camera.id)
-
-        CobblemonEvents.CAMERA_VIEWER_ADDED.emit(
-            CameraViewerAddedEvent(camera.id, camera, player)
-        )
-
-        return true
-    }
-
-    override fun stopCamera(cameraId: UUID) {
-        lifecycleManager.getCamera(cameraId)?.let { camera ->
-            CobblemonEvents.CAMERA_STOPPED_PRE.emit(
-                CameraStoppedEvent.Pre(cameraId, camera, CameraStoppedEvent.StopReason.MANUAL)
-            )
-
-            camera.stop()
-            lifecycleManager.unregisterCamera(cameraId)
-            viewerManager.removeViewersForCamera(cameraId)
-
-            CobblemonEvents.CAMERA_STOPPED_POST.emit(
-                CameraStoppedEvent.Post(cameraId, camera, CameraStoppedEvent.StopReason.MANUAL)
-            )
-
-            Cobblemon.LOGGER.info("[CobblemonCamera] Stopped camera $cameraId")
-        }
-    }
-
-    override fun stopCameraForPlayer(player: ServerPlayer) {
-        viewerManager.getCameraForPlayer(player.uuid)?.let { cameraId ->
-            lifecycleManager.getCamera(cameraId)?.let { camera ->
-                camera.removeViewer(player)
-                viewerManager.removeViewer(player.uuid)
-
-                CobblemonEvents.CAMERA_VIEWER_REMOVED.emit(
-                    CameraViewerRemovedEvent(cameraId, camera, player)
-                )
-            }
-        }
-    }
-
-    override fun getPlayerCamera(player: ServerPlayer): ICameraController? {
-        val cameraId = viewerManager.getCameraForPlayer(player.uuid) ?: return null
-        return lifecycleManager.getCamera(cameraId)
-    }
-
-    override fun getCamera(cameraId: UUID): ICameraController? {
-        return lifecycleManager.getCamera(cameraId)
-    }
-
-    override fun tick() {
-        lifecycleManager.tick()
-        StadiumBattleCameraCoordinator.tickSecondaryCameras()
-    }
-
-    override fun clear() {
-        lifecycleManager.clear()
-        viewerManager.clear()
-        chunkManager.clear()
-    }
-
-    internal fun registerViewerChunkView(playerId: UUID, newView: ChunkTrackingView) {
-        chunkManager.registerViewerChunkView(playerId, newView)
-    }
-
-    internal fun clearViewerChunkView(playerId: UUID) {
-        chunkManager.clearViewerChunkView(playerId)
-    }
-
-    @JvmStatic
-    fun getPlayerChunkView(player: ServerPlayer): ChunkTrackingView? {
-        return chunkManager.getPlayerChunkView(player.uuid)
-    }
-
-    @JvmStatic
-    fun consumeChunkViewUpdate(player: ServerPlayer): ChunkViewUpdate? {
-        return chunkManager.consumeChunkViewUpdate(player.uuid)?.let {
-            ChunkViewUpdate(it.previous, it.current)
-        }
-    }
-
-    data class ChunkViewUpdate(val previous: ChunkTrackingView?, val current: ChunkTrackingView?)
-}
@@ -1,20 +0,0 @@
-/*
- * 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.api.camera
-
-/**
- * Represents a camera rotation in 3D space.
- *
- * @property yaw Horizontal rotation (left/right) in degrees
- * @property pitch Vertical rotation (up/down) in degrees
- */
-data class CameraRotation(
-    val yaw: Float,
-    val pitch: Float
-)
@@ -1,43 +0,0 @@
-/*
- * 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.api.camera
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.model.CameraTrack
-import com.google.gson.JsonObject
-
-object CameraTrackRegistry {
-    private val trackDeserializers = mutableMapOf<String, (JsonObject) -> CameraTrack>()
-
-    fun registerTrackType(trackType: String, deserializer: (JsonObject) -> CameraTrack) {
-        if (trackDeserializers.containsKey(trackType)) {
-            Cobblemon.LOGGER.warn("[CameraTrackRegistry] Track type '$trackType' is already registered, overwriting")
-        }
-        trackDeserializers[trackType] = deserializer
-        Cobblemon.LOGGER.debug("[CameraTrackRegistry] Registered camera track type: $trackType")
-    }
-
-    fun deserializeTrack(trackType: String, json: JsonObject): CameraTrack? {
-        val deserializer = trackDeserializers[trackType]
-        if (deserializer == null) {
-            Cobblemon.LOGGER.warn("[CameraTrackRegistry] Unknown track type: $trackType")
-            return null
-        }
-        return try {
-            deserializer(json)
-        } catch (e: Exception) {
-            Cobblemon.LOGGER.error("[CameraTrackRegistry] Failed to deserialize track type '$trackType': ${e.message}", e)
-            null
-        }
-    }
-
-    fun getRegisteredTrackTypes(): Set<String> = trackDeserializers.keys.toSet()
-
-    fun isTrackTypeRegistered(trackType: String): Boolean = trackDeserializers.containsKey(trackType)
-}
@@ -1,32 +0,0 @@
-/*
- * 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.api.camera
-
-import com.bedrockk.molang.runtime.MoParams
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-import java.util.function.Function
-
-interface ICameraController {
-    val id: UUID
-    val origin: Vec3
-    fun startTimeline(timelineId: String): Boolean
-    fun tick()
-    fun stop()
-    fun isActive(): Boolean
-    fun addViewer(player: ServerPlayer)
-    fun removeViewer(player: ServerPlayer)
-    fun setVariable(name: String, value: Double)
-    fun setFocusOverride(position: Vec3?)
-    /** Triggers an instant camera transition (no client-side interpolation) on the next tick. */
-    fun triggerInstantTransition()
-    /** Injects additional MoLang query functions into the camera's runtime after creation. */
-    fun addQueryFunctions(functions: Map<String, Function<MoParams, Any>>)
-}
@@ -1,17 +0,0 @@
-/*
- * 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.api.camera
-
-import java.util.UUID
-
-interface ICameraCoordinator {
-    fun bind(cameraId: UUID)
-    fun release()
-    fun getCameraId(): UUID?
-}
@@ -1,34 +0,0 @@
-/*
- * 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.api.camera
-
-import com.bedrockk.molang.runtime.MoParams
-import com.bedrockk.molang.runtime.value.MoValue
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-import java.util.function.Function
-
-interface ICameraManager {
-    fun startCamera(
-        timelineId: String,
-        context: Map<String, MoValue> = emptyMap(),
-        viewers: List<ServerPlayer> = emptyList(),
-        origin: Vec3 = Vec3.ZERO,
-        queryFunctions: Map<String, Function<MoParams, Any>> = emptyMap()
-    ): UUID?
-
-    fun addViewerToCamera(player: ServerPlayer, cameraId: UUID): Boolean
-    fun stopCamera(cameraId: UUID)
-    fun stopCameraForPlayer(player: ServerPlayer)
-    fun getPlayerCamera(player: ServerPlayer): ICameraController?
-    fun getCamera(cameraId: UUID): ICameraController?
-    fun tick()
-    fun clear()
-}
@@ -1,45 +0,0 @@
-/*
- * 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.api.camera.components
-
-import net.minecraft.server.level.ChunkTrackingView
-import java.util.UUID
-import java.util.concurrent.ConcurrentHashMap
-
-class CameraChunkManager {
-    private val playerChunkViews = ConcurrentHashMap<UUID, ChunkTrackingView>()
-    private val chunkViewUpdates = ConcurrentHashMap<UUID, ChunkViewUpdate>()
-
-    data class ChunkViewUpdate(val previous: ChunkTrackingView?, val current: ChunkTrackingView?)
-
-    fun registerViewerChunkView(playerId: UUID, newView: ChunkTrackingView) {
-        val previous = playerChunkViews.put(playerId, newView)
-
-        if (previous == null || previous != newView) {
-            chunkViewUpdates[playerId] = ChunkViewUpdate(previous, newView)
-        }
-    }
-
-    fun clearViewerChunkView(playerId: UUID) {
-        val previous = playerChunkViews.remove(playerId)
-
-        if (previous != null) {
-            chunkViewUpdates[playerId] = ChunkViewUpdate(previous, null)
-        }
-    }
-
-    fun getPlayerChunkView(playerId: UUID): ChunkTrackingView? = playerChunkViews[playerId]
-
-    fun consumeChunkViewUpdate(playerId: UUID): ChunkViewUpdate? = chunkViewUpdates.remove(playerId)
-
-    fun clear() {
-        playerChunkViews.clear()
-        chunkViewUpdates.clear()
-    }
-}
@@ -1,58 +0,0 @@
-/*
- * 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.api.camera.components
-
-import com.cobblemon.mod.common.api.camera.ICameraController
-import com.cobblemon.mod.common.api.events.CobblemonEvents
-import com.cobblemon.mod.common.api.events.camera.CameraStoppedEvent
-import java.util.UUID
-import java.util.concurrent.ConcurrentHashMap
-
-class CameraLifecycleManager {
-    private val cameras = ConcurrentHashMap<UUID, ICameraController>()
-
-    fun registerCamera(camera: ICameraController) {
-        cameras[camera.id] = camera
-    }
-
-    fun unregisterCamera(cameraId: UUID): ICameraController? {
-        return cameras.remove(cameraId)
-    }
-
-    fun getCamera(cameraId: UUID): ICameraController? = cameras[cameraId]
-
-    fun getAllCameras(): Collection<ICameraController> = cameras.values
-
-    fun tick() {
-        cameras.values.forEach { it.tick() }
-
-        cameras.entries.removeIf { (id, camera) ->
-            if (!camera.isActive()) {
-                CobblemonEvents.CAMERA_STOPPED_POST.emit(
-                    CameraStoppedEvent.Post(id, camera, CameraStoppedEvent.StopReason.COMPLETED)
-                )
-                true
-            } else {
-                false
-            }
-        }
-    }
-
-    fun clear() {
-        cameras.values.forEach {
-            it.stop()
-            CobblemonEvents.CAMERA_STOPPED_POST.emit(
-                CameraStoppedEvent.Post(it.id, it, CameraStoppedEvent.StopReason.MANUAL)
-            )
-        }
-        cameras.clear()
-    }
-
-    fun size(): Int = cameras.size
-}
@@ -1,36 +0,0 @@
-/*
- * 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.api.camera.components
-
-import java.util.UUID
-import java.util.concurrent.ConcurrentHashMap
-
-class CameraViewerManager {
-    private val playerCameras = ConcurrentHashMap<UUID, UUID>()
-
-    fun assignViewerToCamera(playerId: UUID, cameraId: UUID) {
-        playerCameras[playerId] = cameraId
-    }
-
-    fun removeViewer(playerId: UUID): UUID? {
-        return playerCameras.remove(playerId)
-    }
-
-    fun getCameraForPlayer(playerId: UUID): UUID? {
-        return playerCameras[playerId]
-    }
-
-    fun removeViewersForCamera(cameraId: UUID) {
-        playerCameras.entries.removeIf { it.value == cameraId }
-    }
-
-    fun clear() {
-        playerCameras.clear()
-    }
-}
@@ -1,591 +0,0 @@
-/*
- * 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.api.camera.engine
-
-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.Cobblemon
-import com.cobblemon.mod.common.api.camera.CameraRotation
-import com.cobblemon.mod.common.api.camera.model.*
-import com.cobblemon.mod.common.api.camera.result.ValidationError
-import com.cobblemon.mod.common.api.camera.track.EventTrack
-import com.cobblemon.mod.common.api.camera.track.FiredGuiAction
-import com.cobblemon.mod.common.api.camera.track.GuiTrack
-import com.cobblemon.mod.common.api.tween.EasingRegistry
-import com.cobblemon.mod.common.client.camera.CameraInterpolationUtils
-import com.cobblemon.mod.common.util.resolve
-import com.cobblemon.mod.common.util.resolveBoolean
-import net.minecraft.world.phys.Vec3
-import java.util.*
-import java.util.concurrent.ConcurrentHashMap
-
-/**
- * Thread-safe timeline execution engine.
- *
- * Uses immutable state snapshots for thread safety. MoLang evaluation is NOT
- * thread-safe - callers must ensure tick() is called from the same thread.
- *
- * @param id Unique identifier for this engine instance
- * @param timeline The timeline to execute
- * @param origin The world position origin for relative coordinates
- * @param runtime The MoLang runtime for expression evaluation
- * @param providedContext Initial context values (parameter values) to inject into MoLang
- */
-class TimelineEngine(
-    val id: UUID,
-    private val timeline: Timeline,
-    val origin: Vec3,
-    private val runtime: MoLangRuntime,
-    private val providedContext: Map<String, MoValue> = emptyMap()
-) {
-    @Volatile
-    private var state: ExecutionState = ExecutionState.Stopped
-
-    private var previousExecutionState: ExecutionState.Playing? = null
-
-    private var instantTransitionOccurred = false
-
-    private val customVariables = ConcurrentHashMap<String, Double>()
-
-    /** GUI actions fired during the current tick, consumed by the executor. */
-    private val pendingGuiActions = mutableListOf<FiredGuiAction>()
-
-    private val timeOnCurrentPathValue = DoubleValue(0.0)
-    private val totalTimeValue = DoubleValue(0.0)
-    private val runnerIdValue = StringValue(id.toString())
-
-    fun start(): Boolean {
-        if (state !is ExecutionState.Stopped) {
-            Cobblemon.LOGGER.warn("[TimelineEngine] Cannot start: already active (id=$id)")
-            return false
-        }
-
-        val errors = timeline.validate()
-        if (errors.any { it.severity == ValidationError.Severity.ERROR }) {
-            Cobblemon.LOGGER.error("[TimelineEngine] Timeline '${timeline.id}' validation failed: ${errors.joinToString { it.toString() }}")
-            return false
-        }
-
-        if (!validateAndInjectParameters()) {
-            return false
-        }
-
-        val startState = timeline.getState(timeline.startStateId)
-        if (startState == null) {
-            Cobblemon.LOGGER.error("[TimelineEngine] Start state '${timeline.startStateId}' not found in timeline '${timeline.id}'")
-            return false
-        }
-
-        state = ExecutionState.Playing(
-            currentState = startState,
-            stateTime = 0f,
-            totalTime = 0f,
-            lastTickNanos = System.nanoTime(),
-            transitionState = TransitionState.None,
-            progressMemory = emptyMap(),
-            executedEvents = emptySet()
-        )
-
-        Cobblemon.LOGGER.info("[TimelineEngine] Started timeline '${timeline.id}' in state '${startState.id}'")
-        return true
-    }
-
-    /**
-     * Validates that all required parameters are provided and injects parameters
-     * (including defaults) into the MoLang runtime.
-     */
-    private fun validateAndInjectParameters(): Boolean {
-        if (timeline.parameters.isEmpty()) return true
-
-        val providedVarNames = providedContext.keys
-        val missingParams = timeline.validateParameters(providedVarNames)
-        if (missingParams.isNotEmpty()) {
-            Cobblemon.LOGGER.error("[TimelineEngine] Timeline '${timeline.id}' missing required parameters: ${missingParams.joinToString(", ")}")
-            return false
-        }
-
-        providedContext.forEach { (name, value) ->
-            runtime.environment.variable.map[name] = value
-        }
-
-        for ((paramName, definition) in timeline.parameters) {
-            val default = definition.default ?: continue
-
-            when (default) {
-                is ParameterDefault.NumberDefault -> {
-                    if (paramName !in providedVarNames) {
-                        runtime.environment.variable.map[paramName] = DoubleValue(default.value)
-                        Cobblemon.LOGGER.debug("[TimelineEngine] Using default for parameter '$paramName': ${default.value}")
-                    }
-                }
-                is ParameterDefault.Vec3Default -> {
-                    val varNames = definition.getVariableNames(paramName)
-                    val xVar = varNames[0]
-                    val yVar = varNames[1]
-                    val zVar = varNames[2]
-
-                    if (xVar !in providedVarNames) {
-                        runtime.environment.variable.map[xVar] = DoubleValue(default.x)
-                    }
-                    if (yVar !in providedVarNames) {
-                        runtime.environment.variable.map[yVar] = DoubleValue(default.y)
-                    }
-                    if (zVar !in providedVarNames) {
-                        runtime.environment.variable.map[zVar] = DoubleValue(default.z)
-                    }
-
-                    if (xVar !in providedVarNames || yVar !in providedVarNames || zVar !in providedVarNames) {
-                        Cobblemon.LOGGER.debug("[TimelineEngine] Using default for parameter '$paramName': (${default.x}, ${default.y}, ${default.z})")
-                    }
-                }
-            }
-        }
-
-        return true
-    }
-
-    fun tick(): CameraTransform? {
-        val current = state
-        if (current !is ExecutionState.Playing) {
-            return null
-        }
-
-        previousExecutionState = current
-        instantTransitionOccurred = false
-
-        val nowNanos = System.nanoTime()
-        val deltaNanos = nowNanos - current.lastTickNanos
-        val deltaSeconds = (deltaNanos / 1_000_000_000.0).toFloat()
-            .coerceIn(0f, 0.5f)
-
-        val newStateTime = current.stateTime + deltaSeconds * current.currentState.speed
-        val newTotalTime = current.totalTime + deltaSeconds
-
-        val transitionResult = checkTransitions(current, newStateTime, newTotalTime)
-        if (transitionResult is TransitionCheckResult.TransitionNow) {
-            val targetState = timeline.getState(transitionResult.targetStateId)
-                ?: run {
-                    Cobblemon.LOGGER.error("[TimelineEngine] Transition target state '${transitionResult.targetStateId}' not found")
-                    return null
-                }
-
-            state = when (transitionResult.type) {
-                TransitionType.INSTANT -> {
-                    instantTransitionOccurred = true
-
-                    val savedSnapshot = if (targetState.rememberProgress) {
-                        current.progressMemory[targetState.id]
-                    } else null
-
-                    val restoredTime = savedSnapshot?.normalizedProgress?.let {
-                        it * targetState.getEffectiveDuration()
-                    } ?: 0f
-
-                    val restoredFocus = savedSnapshot?.lastFocus
-
-                    val currentSnapshot = StateSnapshot(
-                        normalizedProgress = normalizeProgress(current.stateTime, current.currentState),
-                        lastFocus = current.lastEvaluatedFocus
-                    )
-
-                    ExecutionState.Playing(
-                        currentState = targetState,
-                        stateTime = restoredTime,
-                        totalTime = newTotalTime,
-                        lastTickNanos = nowNanos,
-                        transitionState = TransitionState.None,
-                        progressMemory = current.progressMemory + (current.currentState.id to currentSnapshot),
-                        executedEvents = if (targetState.rememberProgress) current.executedEvents else emptySet(),
-                        lastEvaluatedFocus = restoredFocus
-                    )
-                }
-                TransitionType.BLEND -> {
-                    val currentTransform = evaluateState(current.currentState, current.stateTime)
-                    ExecutionState.Playing(
-                        currentState = current.currentState,
-                        stateTime = newStateTime,
-                        totalTime = newTotalTime,
-                        lastTickNanos = nowNanos,
-                        transitionState = TransitionState.Blending(
-                            targetState = targetState,
-                            startTime = newTotalTime,
-                            duration = transitionResult.blendDuration,
-                            startTransform = currentTransform
-                        ),
-                        progressMemory = current.progressMemory,
-                        executedEvents = current.executedEvents
-                    )
-                }
-            }
-        } else {
-            val effectiveDuration = current.currentState.getEffectiveDuration()
-            val (finalStateTime, finalEvents) = if (current.currentState.isLooping && effectiveDuration > 0f && newStateTime >= effectiveDuration) {
-                newStateTime % effectiveDuration to emptySet<EventKey>()
-            } else {
-                val clampedTime = if (!current.currentState.isLooping && effectiveDuration > 0f) {
-                    newStateTime.coerceAtMost(effectiveDuration)
-                } else {
-                    newStateTime
-                }
-                clampedTime to current.executedEvents
-            }
-
-            state = current.copy(
-                stateTime = finalStateTime,
-                totalTime = newTotalTime,
-                lastTickNanos = nowNanos,
-                executedEvents = finalEvents
-            )
-        }
-
-        val updatedState = state
-        if (updatedState is ExecutionState.Playing && updatedState.transitionState is TransitionState.Blending) {
-            val blend = updatedState.transitionState
-            val blendProgress = if (blend.duration > 0f) {
-                ((updatedState.totalTime - blend.startTime) / blend.duration).coerceIn(0f, 1f)
-            } else 1f
-
-            if (blendProgress >= 1f) {
-                val savedSnapshot = updatedState.progressMemory[blend.targetState.id]
-                val restoredTime = if (blend.targetState.rememberProgress && savedSnapshot != null) {
-                    savedSnapshot.normalizedProgress * blend.targetState.getEffectiveDuration()
-                } else 0f
-
-                val currentSnapshot = StateSnapshot(
-                    normalizedProgress = normalizeProgress(updatedState.stateTime, updatedState.currentState),
-                    lastFocus = null
-                )
-
-                state = ExecutionState.Playing(
-                    currentState = blend.targetState,
-                    stateTime = restoredTime,
-                    totalTime = updatedState.totalTime,
-                    lastTickNanos = nowNanos,
-                    transitionState = TransitionState.None,
-                    progressMemory = updatedState.progressMemory + (updatedState.currentState.id to currentSnapshot),
-                    executedEvents = if (blend.targetState.rememberProgress) updatedState.executedEvents else emptySet()
-                )
-            }
-        }
-
-        executeEvents()
-        executeGuiActions()
-        return calculateTransform()
-    }
-
-    fun stop() {
-        state = ExecutionState.Stopped
-        customVariables.clear()
-
-        // Clear MoLang runtime to prevent memory leaks
-        runtime.environment.variable.map.clear()
-        runtime.environment.query.functions.clear()
-    }
-
-    fun setVariable(name: String, value: Double) {
-        customVariables[name] = value
-    }
-    
-    /** Triggers an instant transition on the next update (no client-side interpolation). */
-    fun triggerInstantTransition() {
-        instantTransitionOccurred = true
-    }
-
-    fun isActive(): Boolean = state is ExecutionState.Playing
-
-    fun getCurrentStateId(): String? = (state as? ExecutionState.Playing)?.currentState?.id
-
-    fun getCurrentRenderPlayerBody(): Boolean = (state as? ExecutionState.Playing)?.currentState?.renderPlayerBody ?: true
-
-    fun getCurrentHiddenHudElements(): Set<HudElement> = (state as? ExecutionState.Playing)?.currentState?.hiddenHudElements ?: emptySet()
-
-    fun consumeInstantTransitionFlag(): Boolean {
-        val result = instantTransitionOccurred
-        instantTransitionOccurred = false
-        return result
-    }
-
-    private fun checkTransitions(
-        current: ExecutionState.Playing,
-        newStateTime: Float,
-        newTotalTime: Float
-    ): TransitionCheckResult {
-        if (current.transitionState !is TransitionState.None) {
-            return TransitionCheckResult.NoTransition
-        }
-
-        val context = createMoLangContext(current.currentState, newStateTime, newTotalTime)
-
-        for (transition in timeline.getTransitionsFrom(current.currentState.id)) {
-            try {
-                val shouldTransition = runtime.resolveBoolean(transition.condition, context)
-                if (shouldTransition) {
-                    return TransitionCheckResult.TransitionNow(
-                        targetStateId = transition.targetStateId,
-                        type = transition.type,
-                        blendDuration = transition.blendDuration
-                    )
-                }
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[TimelineEngine] Error evaluating transition condition: ${e.message}", e)
-            }
-        }
-
-        return TransitionCheckResult.NoTransition
-    }
-
-    private fun executeEvents() {
-        val current = state as? ExecutionState.Playing ?: return
-        val previousState = previousExecutionState ?: return
-
-        val context = createMoLangContext(current.currentState, current.stateTime, current.totalTime)
-        val previousTime = previousState.stateTime
-        val currentTime = current.stateTime
-
-        current.currentState.tracks.filterIsInstance<EventTrack>().forEach { track ->
-            track.events.forEach { timedEvent ->
-                val eventKey = EventKey(current.currentState.id, timedEvent.eventId, timedEvent.time.toInt())
-
-                if (eventKey in current.executedEvents) return@forEach
-
-                val crossedEvent = if (previousTime <= currentTime) {
-                    timedEvent.time in previousTime..currentTime
-                } else {
-                    timedEvent.time <= currentTime
-                }
-
-                if (crossedEvent) {
-                    try {
-                        runtime.resolve(timedEvent.expression, context)
-
-                        state = current.copy(
-                            executedEvents = current.executedEvents + eventKey
-                        )
-
-                        if (timedEvent.eventId != null) {
-                            Cobblemon.LOGGER.debug("[TimelineEngine] Executed event '${timedEvent.eventId}' at time ${timedEvent.time}s")
-                        }
-                    } catch (e: Exception) {
-                        Cobblemon.LOGGER.error("[TimelineEngine] Failed to execute event: ${e.message}", e)
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Checks GUI tracks for actions whose time has been crossed and queues them.
-     * Follows the same pattern as [executeEvents].
-     */
-    private fun executeGuiActions() {
-        val current = state as? ExecutionState.Playing ?: return
-        val previousState = previousExecutionState ?: return
-
-        val previousTime = previousState.stateTime
-        val currentTime = current.stateTime
-
-        current.currentState.tracks.filterIsInstance<GuiTrack>().forEach { track ->
-            track.actions.forEach { guiAction ->
-                val actionKey = EventKey(current.currentState.id, "gui_${guiAction.guiId}_${guiAction.action}", guiAction.time.toInt())
-
-                if (actionKey in current.executedEvents) return@forEach
-
-                val crossedAction = if (previousTime <= currentTime) {
-                    guiAction.time in previousTime..currentTime
-                } else {
-                    guiAction.time <= currentTime
-                }
-
-                if (crossedAction) {
-                    pendingGuiActions.add(FiredGuiAction(
-                        action = guiAction.action,
-                        guiId = guiAction.guiId,
-                        args = guiAction.args,
-                        argsExpressions = guiAction.argsExpressions
-                    ))
-
-                    state = current.copy(
-                        executedEvents = current.executedEvents + actionKey
-                    )
-
-                    Cobblemon.LOGGER.debug("[TimelineEngine] Fired GUI action ${guiAction.action} for '${guiAction.guiId}' at time ${guiAction.time}s")
-                }
-            }
-        }
-    }
-
-    /**
-     * Consumes and returns all pending GUI actions since the last tick.
-     * Called by the CameraExecutor after tick().
-     */
-    fun consumeGuiActions(): List<FiredGuiAction> {
-        if (pendingGuiActions.isEmpty()) return emptyList()
-        val actions = pendingGuiActions.toList()
-        pendingGuiActions.clear()
-        return actions
-    }
-
-    private fun calculateTransform(): CameraTransform {
-        val current = state as? ExecutionState.Playing ?: return CameraTransform(origin, null, null)
-
-        return when (val transition = current.transitionState) {
-            is TransitionState.None -> {
-                evaluateState(current.currentState, current.stateTime)
-            }
-            is TransitionState.Blending -> {
-                val targetTransform = evaluateState(transition.targetState, 0f)
-                val progress = if (transition.duration > 0f) {
-                    ((current.totalTime - transition.startTime) / transition.duration).coerceIn(0f, 1f)
-                } else 1f
-
-                val easedProgress = EasingRegistry.easeOutQuad(progress)
-
-                blendTransforms(transition.startTransform, targetTransform, easedProgress)
-            }
-        }
-    }
-
-    private fun evaluateState(state: State, time: Float): CameraTransform {
-        val context = createMoLangContext(state, time, (this.state as? ExecutionState.Playing)?.totalTime ?: 0f)
-
-        var position: Vec3? = null
-        var focus: CameraFocus? = null
-        var rotation: CameraRotation? = null
-
-        for (track in state.tracks) {
-            val outputs = track.evaluate(time, context, runtime, origin)
-
-            for (output in outputs) {
-                when (output) {
-                    is TrackOutput.Position -> {
-                        if (position == null) position = output.position
-                    }
-                    is TrackOutput.Focus -> {
-                        if (focus == null) focus = output.target
-                    }
-                    is TrackOutput.Rotation -> {
-                        if (rotation == null) rotation = output.rotation
-                    }
-                    is TrackOutput.Event -> {
-                        // Events handled separately
-                    }
-                }
-            }
-        }
-
-        return CameraTransform(
-            position = position ?: origin,
-            focus = focus,
-            rotation = rotation
-        )
-    }
-
-    private fun blendTransforms(
-        from: CameraTransform,
-        to: CameraTransform,
-        progress: Float
-    ): CameraTransform {
-        val blendedPosition = CameraInterpolationUtils.lerpPosition(from.position, to.position, progress)
-
-        val blendedRotation = if (from.rotation != null && to.rotation != null) {
-            CameraInterpolationUtils.slerpRotation(from.rotation, to.rotation, progress)
-        } else {
-            to.rotation ?: from.rotation
-        }
-
-        return CameraTransform(
-            position = blendedPosition,
-            focus = to.focus ?: from.focus,
-            rotation = blendedRotation
-        )
-    }
-
-    private fun createMoLangContext(
-        state: State,
-        stateTime: Float,
-        totalTime: Float
-    ): Map<String, MoValue> {
-        timeOnCurrentPathValue.value = stateTime.toDouble()
-        totalTimeValue.value = totalTime.toDouble()
-
-        runtime.environment.variable.apply {
-            map["time_on_current_path"] = timeOnCurrentPathValue
-            map["total_time"] = totalTimeValue
-            map["runner_id"] = runnerIdValue
-
-            customVariables.forEach { (name, value) ->
-                map[name] = DoubleValue(value)
-            }
-        }
-
-        return emptyMap()  // Context passed via runtime.environment
-    }
-
-    private fun normalizeProgress(time: Float, state: State): Float {
-        val duration = state.getEffectiveDuration()
-        return if (duration > 0f) {
-            (time / duration).coerceIn(0f, 1f)
-        } else 0f
-    }
-}
-
-data class CameraTransform(
-    val position: Vec3,
-    val focus: CameraFocus?,
-    val rotation: CameraRotation?
-)
-
-private sealed class ExecutionState {
-    object Stopped : ExecutionState()
-
-    data class Playing(
-        val currentState: State,
-        val stateTime: Float,
-        val totalTime: Float,
-        val lastTickNanos: Long,
-        val transitionState: TransitionState,
-        val progressMemory: Map<String, StateSnapshot>,
-        val executedEvents: Set<EventKey>,
-        val lastEvaluatedFocus: CameraFocus? = null
-    ) : ExecutionState()
-}
-
-private sealed class TransitionState {
-    object None : TransitionState()
-
-    data class Blending(
-        val targetState: State,
-        val startTime: Float,
-        val duration: Float,
-        val startTransform: CameraTransform
-    ) : TransitionState()
-}
-
-private sealed class TransitionCheckResult {
-    object NoTransition : TransitionCheckResult()
-
-    data class TransitionNow(
-        val targetStateId: String,
-        val type: TransitionType,
-        val blendDuration: Float
-    ) : TransitionCheckResult()
-}
-
-private data class EventKey(
-    val stateId: String,
-    val eventId: String?,
-    val timeMillis: Int
-)
-
-private data class StateSnapshot(
-    val normalizedProgress: Float,
-    val lastFocus: CameraFocus?
-)
@@ -1,129 +0,0 @@
-/*
- * 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.api.camera.integration.server
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.model.CameraFocus
-import com.cobblemon.mod.common.api.camera.track.FiredGuiAction
-import com.cobblemon.mod.common.api.camera.track.GuiActionType
-import net.minecraft.core.SectionPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.Mth
-import net.minecraft.world.level.ChunkPos
-import net.minecraft.world.phys.Vec3
-
-/**
- * Executes camera timeline and manages focus resolution.
- *
- * Coordinates between CameraInstance, viewer/chunk managers, and network sync.
- */
-class CameraExecutor(
-    private val instance: CameraInstance,
-    private val runtime: MoLangRuntime,
-    private val context: Map<String, MoValue>,
-    private val guiActionHandler: ((FiredGuiAction) -> Unit)? = null
-) {
-    companion object {
-        private const val CHUNK_UPDATE_DISTANCE_SQ = (16 * 16).toDouble()
-    }
-
-    private var lastCenterChunkUpdate: Vec3? = null
-
-    fun tick(
-        level: ServerLevel,
-        networkSync: CameraNetworkSync,
-        onChunkUpdate: (ChunkPos) -> Unit
-    ): Boolean {
-        if (!instance.isActive()) return false
-
-        val transform = instance.tick() ?: run {
-            if (!instance.isActive()) instance.stop()
-            return false
-        }
-
-        val shouldUpdateCenter = lastCenterChunkUpdate?.let { last ->
-            transform.position.distanceToSqr(last) > CHUNK_UPDATE_DISTANCE_SQ
-        } ?: true
-
-        if (shouldUpdateCenter) {
-            val chunkPos = chunkPosFrom(transform.position)
-            onChunkUpdate(chunkPos)
-            lastCenterChunkUpdate = transform.position
-        }
-
-        val instantTransition = instance.consumeInstantTransitionFlag()
-
-        networkSync.sendTransform(transform, shouldUpdateCenter)
-
-        when (val focus = transform.focus) {
-            null -> networkSync.sendFocusNone()
-            is CameraFocus.Bone -> networkSync.sendFocusBone(focus, context, runtime)
-            else -> {
-                val resolvedFocus = resolveFocusPosition(focus)
-                val finalFocusPos = instance.focusOverride ?: resolvedFocus
-                networkSync.sendFocusPoint(finalFocusPos)
-            }
-        }
-
-        networkSync.sendState(
-            instantTransition = instantTransition,
-            renderPlayerBody = instance.getCurrentRenderPlayerBody(),
-            hiddenHudElements = instance.getCurrentHiddenHudElements()
-        )
-
-        if (guiActionHandler != null) {
-            val guiActions = instance.consumeGuiActions()
-            for (action in guiActions) {
-                guiActionHandler.invoke(action)
-            }
-        }
-
-        return true
-    }
-
-    fun resolveFocusPosition(focus: CameraFocus): Vec3? {
-        return when (focus) {
-            is CameraFocus.Entity -> {
-                val entity = CameraFocus.resolveEntity(focus.selector, context, runtime)
-                if (entity != null) {
-                    val position = entity.position()
-                    instance.updateLastValidFocusPosition(position)
-                    position
-                } else {
-                    val cached = instance.lastValidFocusPosition
-                    if (cached != null) {
-                        Cobblemon.LOGGER.debug("[CameraExecutor] Entity focus invalid, using last valid position")
-                        cached
-                    } else {
-                        Cobblemon.LOGGER.warn("[CameraExecutor] Entity focus invalid and no cached position, using origin")
-                        instance.origin
-                    }
-                }
-            }
-            is CameraFocus.Point -> {
-                val position = focus.position.toVec3(context, runtime, instance.origin, false)
-                instance.updateLastValidFocusPosition(position)
-                position
-            }
-            is CameraFocus.Bone -> {
-                // Bone focus is resolved client-side, so return entity position as fallback
-                CameraFocus.resolveEntity(focus.selector, context, runtime)?.position()
-                    ?: instance.lastValidFocusPosition
-            }
-        }
-    }
-
-    private fun chunkPosFrom(position: Vec3): ChunkPos {
-        val chunkX = SectionPos.blockToSectionCoord(Mth.floor(position.x))
-        val chunkZ = SectionPos.blockToSectionCoord(Mth.floor(position.z))
-        return ChunkPos(chunkX, chunkZ)
-    }
-}
@@ -1,95 +0,0 @@
-/*
- * 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.api.camera.integration.server
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.MoParams
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.camera.engine.TimelineEngine
-import com.cobblemon.mod.common.api.camera.model.State
-import com.cobblemon.mod.common.api.camera.model.Timeline
-import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-
-/**
- * Server-side camera instance - pure state and identity.
- *
- * Represents a single camera with its configuration and execution engine.
- * Does NOT handle networking, chunk loading, or viewer management.
- *
- * @param id Unique identifier for this camera instance
- * @param origin The world position origin for relative coordinates
- * @param initialContext Initial context values (parameter values) to inject into MoLang.
- *                       These are validated against the timeline's declared parameters when starting.
- * @param queryFunctions Custom MoLang query functions to register
- */
-class CameraInstance(
-    val id: UUID = UUID.randomUUID(),
-    val origin: Vec3,
-    private val initialContext: Map<String, MoValue> = emptyMap(),
-    queryFunctions: Map<String, java.util.function.Function<MoParams, Any>> = emptyMap()
-) {
-    private val runtime: MoLangRuntime = MoLangRuntime().setup().apply {
-        environment.query.functions.putAll(queryFunctions)
-    }
-
-    private var engine: TimelineEngine = TimelineEngine(id, createStubTimeline(), origin, runtime, initialContext)
-
-    @Volatile
-    var focusOverride: Vec3? = null
-
-    var lastValidFocusPosition: Vec3? = null
-        private set
-
-    fun startTimeline(timeline: Timeline): Boolean {
-        engine = TimelineEngine(id, timeline, origin, runtime, initialContext)
-        return engine.start()
-    }
-
-    fun tick() = engine.tick()
-
-    fun stop() = engine.stop()
-
-    fun isActive() = engine.isActive()
-
-    fun getCurrentRenderPlayerBody() = engine.getCurrentRenderPlayerBody()
-
-    fun getCurrentHiddenHudElements() = engine.getCurrentHiddenHudElements()
-
-    fun setVariable(name: String, value: Double) = engine.setVariable(name, value)
-    
-    fun triggerInstantTransition() = engine.triggerInstantTransition()
-
-    fun addQueryFunctions(functions: Map<String, java.util.function.Function<MoParams, Any>>) {
-        runtime.environment.query.functions.putAll(functions)
-    }
-
-    fun consumeInstantTransitionFlag() = engine.consumeInstantTransitionFlag()
-
-    fun consumeGuiActions() = engine.consumeGuiActions()
-
-    fun updateLastValidFocusPosition(position: Vec3) {
-        lastValidFocusPosition = position
-    }
-
-    private fun createStubTimeline(): Timeline {
-        return Timeline(
-            id = "stub",
-            startStateId = "stub",
-            states = mapOf(
-                "stub" to State(
-                    id = "stub",
-                    tracks = emptyList()
-                )
-            ),
-            transitions = emptyList()
-        )
-    }
-}
@@ -1,184 +0,0 @@
-/*
- * 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.api.camera.integration.server
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
-import com.cobblemon.mod.common.api.camera.engine.CameraTransform
-import com.cobblemon.mod.common.api.camera.model.CameraFocus
-import com.cobblemon.mod.common.api.camera.model.HudElement
-import com.cobblemon.mod.common.net.messages.client.camera.CameraEndPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraFocusPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraStartPacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraStatePacket
-import com.cobblemon.mod.common.net.messages.client.camera.CameraTransformPacket
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.phys.Vec3
-import java.util.UUID
-
-/**
- * Handles camera packet transmission to clients.
- *
- * Manages synchronization of camera state with connected viewers.
- * Uses modular packets with change tracking to minimize network traffic.
- */
-class CameraNetworkSync(
-    private val cameraId: UUID,
-    private val viewers: Set<UUID>
-) {
-    private var lastFocusPosition: Vec3? = null
-    private var lastRenderPlayerBody: Boolean = true
-    private var lastHiddenHudElements: Set<HudElement> = emptySet()
-    private var lastInstantTransition: Boolean = false
-
-    fun sendStart(startPosition: Vec3) {
-        getPlayers().forEach { player ->
-            player.sendPacket(CameraStartPacket(cameraId, startPosition))
-        }
-
-        sendFocusNone(force = true)
-        sendState(
-            instantTransition = false,
-            renderPlayerBody = true,
-            hiddenHudElements = emptySet(),
-            force = true
-        )
-    }
-
-    fun sendTransform(
-        transform: CameraTransform,
-        updateCenterChunk: Boolean
-    ) {
-        val packet = CameraTransformPacket(
-            cameraId = cameraId,
-            position = transform.position,
-            rotation = transform.rotation,
-            updateCenterChunk = updateCenterChunk
-        )
-
-        getPlayers().forEach { it.sendPacket(packet) }
-    }
-
-    fun sendFocusNone(force: Boolean = false) {
-        if (!force && lastFocusPosition == null) {
-            return
-        }
-
-        val packet = CameraFocusPacket(
-            cameraId = cameraId,
-            focus = CameraFocusPacket.FocusData.None
-        )
-
-        getPlayers().forEach { it.sendPacket(packet) }
-        lastFocusPosition = null
-    }
-
-    fun sendFocusPoint(focusPosition: Vec3?, force: Boolean = false) {
-        if (!force && focusPosition == lastFocusPosition) {
-            return
-        }
-
-        val focusData = when (focusPosition) {
-            null -> CameraFocusPacket.FocusData.None
-            else -> CameraFocusPacket.FocusData.Point(focusPosition)
-        }
-
-        val packet = CameraFocusPacket(
-            cameraId = cameraId,
-            focus = focusData
-        )
-
-        getPlayers().forEach { it.sendPacket(packet) }
-        lastFocusPosition = focusPosition
-    }
-
-    fun sendFocusBone(
-        boneFocus: CameraFocus.Bone,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        force: Boolean = false
-    ) {
-        val entity = CameraFocus.resolveEntity(boneFocus.selector, context, runtime)
-
-        if (entity == null) {
-            Cobblemon.LOGGER.debug("[CameraNetworkSync] Bone focus entity invalid")
-            sendFocusNone(force)
-            return
-        }
-
-        val offset = boneFocus.offset.toVec3(context, runtime)
-
-        Cobblemon.LOGGER.debug("[CameraNetworkSync] Sending bone focus: entityId=${entity.id}, bone=${boneFocus.boneName}, offset=$offset, smooth=${boneFocus.smooth}")
-
-        val focusData = CameraFocusPacket.FocusData.Bone(
-            entityId = entity.id,
-            boneName = boneFocus.boneName,
-            offset = offset,
-            smooth = boneFocus.smooth
-        )
-
-        val packet = CameraFocusPacket(
-            cameraId = cameraId,
-            focus = focusData
-        )
-
-        getPlayers().forEach { it.sendPacket(packet) }
-
-        // Invalidate lastFocusPosition when switching to bone focus.
-        // This ensures that when transitioning back to a point focus,
-        // the packet will always be sent (not incorrectly deduplicated).
-        lastFocusPosition = null
-    }
-
-    fun sendState(
-        instantTransition: Boolean,
-        renderPlayerBody: Boolean,
-        hiddenHudElements: Set<HudElement>,
-        force: Boolean = false
-    ) {
-        if (!force &&
-            instantTransition == lastInstantTransition &&
-            renderPlayerBody == lastRenderPlayerBody &&
-            hiddenHudElements == lastHiddenHudElements) {
-            return
-        }
-
-        val packet = CameraStatePacket(
-            cameraId = cameraId,
-            instantTransition = instantTransition,
-            renderPlayerBody = renderPlayerBody,
-            hiddenHudElements = hiddenHudElements
-        )
-
-        getPlayers().forEach { it.sendPacket(packet) }
-        lastInstantTransition = instantTransition
-        lastRenderPlayerBody = renderPlayerBody
-        lastHiddenHudElements = hiddenHudElements
-    }
-
-    fun sendEnd() {
-        val packet = CameraEndPacket(cameraId)
-        getPlayers().forEach { it.sendPacket(packet) }
-    }
-
-    /**
-     * Send end packet to a specific player.
-     * Used when removing a single viewer without stopping the entire camera.
-     */
-    fun sendEndToPlayer(player: ServerPlayer) {
-        player.sendPacket(CameraEndPacket(cameraId))
-    }
-
-    private fun getPlayers(): List<ServerPlayer> {
-        val server = Cobblemon.implementation.server() ?: return emptyList()
-        return viewers.mapNotNull { server.playerList.getPlayer(it) }
-    }
-}
@@ -1,38 +0,0 @@
-/*
- * 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.api.camera.integration.server
-
-import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
-import com.cobblemon.mod.common.client.render.camera.compositor.CompositorLayout
-import com.cobblemon.mod.common.net.messages.client.camera.CompositorPacket
-import net.minecraft.server.level.ServerPlayer
-import java.util.UUID
-
-class CompositorSession(
-    val compositorId: UUID = UUID.randomUUID(),
-    private val viewers: () -> Collection<ServerPlayer>,
-    val fullscreen: Boolean = true,
-    val width: Int = 1920,
-    val height: Int = 1080
-) {
-    fun sendCreate(layout: CompositorLayout) {
-        val packet = CompositorPacket.create(compositorId, layout, fullscreen, width, height)
-        viewers().forEach { it.sendPacket(packet) }
-    }
-
-    fun sendLayoutUpdate(layout: CompositorLayout) {
-        val packet = CompositorPacket.updateLayout(compositorId, layout)
-        viewers().forEach { it.sendPacket(packet) }
-    }
-
-    fun sendDestroy() {
-        val packet = CompositorPacket.destroy(compositorId)
-        viewers().forEach { it.sendPacket(packet) }
-    }
-}
@@ -1,252 +0,0 @@
-/*
- * 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.api.camera.model
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-import com.cobblemon.mod.common.api.molang.ObjectValue
-import com.cobblemon.mod.common.util.asExpressionLike
-import com.cobblemon.mod.common.util.resolve
-import com.google.gson.JsonElement
-import com.google.gson.JsonObject
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.phys.Vec3
-
-/**
- * Represents where the camera should look.
- */
-sealed class CameraFocus {
-    abstract fun resolve(
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        fallback: Vec3?
-    ): Vec3?
-
-    data class Point(val position: PositionExpression) : CameraFocus() {
-        override fun resolve(
-            context: Map<String, MoValue>,
-            runtime: MoLangRuntime,
-            fallback: Vec3?
-        ): Vec3 {
-            return position.toVec3(context, runtime)
-        }
-    }
-
-    data class Entity(val selector: ExpressionLike) : CameraFocus() {
-        override fun resolve(
-            context: Map<String, MoValue>,
-            runtime: MoLangRuntime,
-            fallback: Vec3?
-        ): Vec3? {
-            return resolveEntity(selector, context, runtime)?.position() ?: fallback
-        }
-    }
-
-    data class Bone(
-        val selector: ExpressionLike,
-        val boneName: String,
-        val offset: PositionExpression = PositionExpression(
-            CoordinateValue.Static(0.0),
-            CoordinateValue.Static(0.0),
-            CoordinateValue.Static(0.0)
-        ),
-        val smooth: Boolean = true
-    ) : CameraFocus() {
-        override fun resolve(
-            context: Map<String, MoValue>,
-            runtime: MoLangRuntime,
-            fallback: Vec3?
-        ): Vec3? {
-            // Server-side: just resolve the entity position as fallback
-            // Client-side bone resolution happens in BoneFocusResolver
-            return resolveEntity(selector, context, runtime)?.position() ?: fallback
-        }
-    }
-
-    companion object {
-        /**
-         * Resolves a MoLang entity selector to a live Entity, or null if the selector
-         * doesn't resolve, the entity is removed, or the entity is dead.
-         */
-        fun resolveEntity(
-            selector: ExpressionLike,
-            context: Map<String, MoValue>,
-            runtime: MoLangRuntime
-        ): net.minecraft.world.entity.Entity? {
-            return try {
-                val result = runtime.resolve(selector, context)
-                if (result is ObjectValue<*>) {
-                    val entity = result.obj as? net.minecraft.world.entity.Entity
-                    if (entity != null && !entity.isRemoved && entity.isAlive) entity else null
-                } else null
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[CameraFocus] Failed to resolve entity from selector", e)
-                null
-            }
-        }
-
-        fun fromJson(obj: JsonObject): CameraFocus {
-            val type = obj.get("type")?.asString
-                ?: throw IllegalArgumentException("CameraFocus missing 'type' field")
-
-            return when (type) {
-                "entity" -> {
-                    val selector = obj.get("selector")?.asString
-                        ?: throw IllegalArgumentException("Entity focus missing 'selector' field")
-                    Entity(selector.asExpressionLike())
-                }
-                "position", "point" -> {
-                    val posElement = obj.get("position")
-                        ?: obj // If no nested position, use the object itself
-                    Point(PositionExpression.fromJson(posElement))
-                }
-                "bone" -> {
-                    val selector = obj.get("selector")?.asString
-                        ?: throw IllegalArgumentException("Bone focus missing 'selector' field")
-                    val boneName = obj.get("bone")?.asString
-                        ?: obj.get("boneName")?.asString
-                        ?: throw IllegalArgumentException("Bone focus missing 'bone' field")
-                    val offset = if (obj.has("offset")) {
-                        PositionExpression.fromJson(obj.get("offset"))
-                    } else {
-                        PositionExpression(
-                            CoordinateValue.Static(0.0),
-                            CoordinateValue.Static(0.0),
-                            CoordinateValue.Static(0.0)
-                        )
-                    }
-                    val smooth = obj.get("smooth")?.asBoolean ?: true
-
-                    Bone(selector.asExpressionLike(), boneName, offset, smooth)
-                }
-                else -> {
-                    throw IllegalArgumentException("Unknown CameraFocus type: $type")
-                }
-            }
-        }
-    }
-}
-
-/**
- * Position defined by three coordinates (x, y, z), each either static or dynamic.
- */
-data class PositionExpression(
-    val x: CoordinateValue,
-    val y: CoordinateValue,
-    val z: CoordinateValue
-) {
-    fun toVec3(
-        context: Map<String, MoValue> = emptyMap(),
-        runtime: MoLangRuntime,
-        origin: Vec3 = Vec3.ZERO,
-        isRelative: Boolean = false
-    ): Vec3 {
-        val base = Vec3(
-            x.evaluate(context, runtime),
-            y.evaluate(context, runtime),
-            z.evaluate(context, runtime)
-        )
-
-        return if (isRelative) base.add(origin) else base
-    }
-
-    fun isFinite(context: Map<String, MoValue>, runtime: MoLangRuntime): Boolean {
-        val vec = toVec3(context, runtime)
-        return vec.x.isFinite() && vec.y.isFinite() && vec.z.isFinite()
-    }
-
-    companion object {
-        fun fromJson(element: JsonElement): PositionExpression {
-            return when {
-                element.isJsonObject -> {
-                    val obj = element.asJsonObject
-                    PositionExpression(
-                        x = deserializeCoordinate(obj.get("x")),
-                        y = deserializeCoordinate(obj.get("y")),
-                        z = deserializeCoordinate(obj.get("z"))
-                    )
-                }
-                element.isJsonArray -> {
-                    val arr = element.asJsonArray
-                    if (arr.size() != 3) {
-                        throw IllegalArgumentException("Position array must have exactly 3 elements [x, y, z], got ${arr.size()}")
-                    }
-                    PositionExpression(
-                        x = deserializeCoordinate(arr[0]),
-                        y = deserializeCoordinate(arr[1]),
-                        z = deserializeCoordinate(arr[2])
-                    )
-                }
-                else -> {
-                    throw IllegalArgumentException("Position must be either an object {x, y, z} or array [x, y, z]")
-                }
-            }
-        }
-
-        private fun deserializeCoordinate(element: JsonElement?): CoordinateValue {
-            if (element == null) {
-                return CoordinateValue.Static(0.0)
-            }
-
-            return when {
-                element.isJsonPrimitive && element.asJsonPrimitive.isNumber -> {
-                    CoordinateValue.Static(element.asDouble)
-                }
-                element.isJsonPrimitive && element.asJsonPrimitive.isString -> {
-                    // String is treated as expression
-                    CoordinateValue.Dynamic(element.asString.asExpressionLike())
-                }
-                element.isJsonObject -> {
-                    val obj = element.asJsonObject
-                    val type = obj.get("type")?.asString
-                    val expression = obj.get("expression")?.asString
-
-                    when (type) {
-                        "expression" -> {
-                            if (expression == null) {
-                                throw IllegalArgumentException("Expression coordinate missing 'expression' field")
-                            }
-                            CoordinateValue.Dynamic(expression.asExpressionLike())
-                        }
-                        else -> {
-                            throw IllegalArgumentException("Unknown coordinate type: $type")
-                        }
-                    }
-                }
-                else -> {
-                    throw IllegalArgumentException("Invalid coordinate value: $element")
-                }
-            }
-        }
-    }
-}
-
-sealed class CoordinateValue {
-    data class Static(val value: Double) : CoordinateValue()
-    data class Dynamic(val expression: ExpressionLike) : CoordinateValue()
-
-    fun evaluate(
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime
-    ): Double {
-        return when (this) {
-            is Static -> value
-            is Dynamic -> {
-                try {
-                    runtime.resolve(expression, context).asDouble()
-                } catch (e: Exception) {
-                    // Log error but don't crash - coordinate expressions shouldn't break cameras
-                    0.0
-                }
-            }
-        }
-    }
-}
@@ -1,34 +0,0 @@
-/*
- * 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.api.camera.model
-
-enum class HudElement(val id: String) {
-    CROSSHAIR("crosshair"),
-    HOTBAR("hotbar"),
-    EXPERIENCE_BAR("experience_bar"),
-    PLAYER_HEALTH("player_health"),
-    ARMOR("armor"),
-    FOOD("food"),
-    AIR("air"),
-    EFFECTS("effects"),
-    BOSS_BAR("boss_bar"),
-    SCOREBOARD("scoreboard"),
-    CHAT("chat"),
-    PLAYER_LIST("player_list"),
-    SELECTED_ITEM_NAME("selected_item_name"),
-    COBBLEMON_OVERLAY("cobblemon_overlay");
-
-    companion object {
-        val ALL: Set<HudElement> = entries.toSet()
-
-        private val BY_ID = entries.associateBy { it.id }
-
-        fun fromId(id: String): HudElement? = BY_ID[id]
-    }
-}
@@ -1,79 +0,0 @@
-/*
- * 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.api.camera.model
-
-/**
- * Defines a parameter that can be passed to a camera timeline.
- *
- * Parameters allow timelines to be reusable with different values.
- * For example, an arena camera can accept `arena_center` as a Vec3 parameter
- * to position the camera relative to any arena location.
- *
- * @property type The type of the parameter (NUMBER or VEC3)
- * @property description Optional description for documentation
- * @property default Optional default value. If null, the parameter is required.
- */
-data class ParameterDefinition(
-    val type: ParameterType,
-    val description: String? = null,
-    val default: ParameterDefault? = null
-) {
-    /**
-     * Whether this parameter must be provided when starting the timeline.
-     * Parameters with defaults are optional.
-     */
-    val isRequired: Boolean get() = default == null
-
-    /**
-     * Gets the variable names this parameter will inject into the MoLang runtime.
-     * - NUMBER type: returns just the parameter name
-     * - VEC3 type: returns name_x, name_y, name_z
-     */
-    fun getVariableNames(paramName: String): List<String> {
-        return when (type) {
-            ParameterType.NUMBER -> listOf(paramName)
-            ParameterType.VEC3 -> listOf("${paramName}_x", "${paramName}_y", "${paramName}_z")
-        }
-    }
-}
-
-/**
- * Types of parameters supported by camera timelines.
- */
-enum class ParameterType {
-    /**
-     * A single numeric value (Double).
-     * Accessible in MoLang as `variable.param_name`
-     */
-    NUMBER,
-
-    /**
-     * A 3D vector value.
-     * Expands to three variables in MoLang:
-     * - `variable.param_name_x`
-     * - `variable.param_name_y`
-     * - `variable.param_name_z`
-     */
-    VEC3
-}
-
-/**
- * Default value for a parameter.
- */
-sealed class ParameterDefault {
-    /**
-     * Default value for a NUMBER parameter.
-     */
-    data class NumberDefault(val value: Double) : ParameterDefault()
-
-    /**
-     * Default value for a VEC3 parameter.
-     */
-    data class Vec3Default(val x: Double, val y: Double, val z: Double) : ParameterDefault()
-}
@@ -1,243 +0,0 @@
-/*
- * 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.api.camera.model
-
-import com.cobblemon.mod.common.api.camera.result.ValidationError
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-
-/**
- * Immutable timeline definition - a state machine of camera animations with transitions.
- *
- * Timelines can declare required and optional parameters that must be provided when
- * starting the camera. Parameters are injected into the MoLang runtime as variables,
- * allowing tracks to use dynamic values like `variable.arena_center_x`.
- *
- * @property id Unique identifier for this timeline
- * @property startStateId The ID of the initial state when the timeline starts
- * @property parameters Map of parameter names to their definitions. Parameters without
- *                      defaults are required and must be provided when starting the camera.
- * @property states Map of state IDs to state definitions
- * @property transitions List of transitions between states
- */
-data class Timeline(
-    val id: String,
-    val startStateId: String,
-    val parameters: Map<String, ParameterDefinition> = emptyMap(),
-    val states: Map<String, State>,
-    val transitions: List<Transition>
-) {
-    fun getState(stateId: String): State? = states[stateId]
-
-    fun getTransitionsFrom(stateId: String): List<Transition> =
-        transitions.filter { it.sourceStateId == stateId }
-
-    /**
-     * Gets the names of all required parameters (those without defaults).
-     */
-    fun getRequiredParameterNames(): Set<String> =
-        parameters.filter { it.value.isRequired }.keys
-
-    /**
-     * Gets all variable names that this timeline's parameters will inject.
-     * For NUMBER parameters, returns the parameter name.
-     * For VEC3 parameters, returns name_x, name_y, name_z.
-     */
-    fun getAllParameterVariableNames(): Set<String> =
-        parameters.flatMap { (name, def) -> def.getVariableNames(name) }.toSet()
-
-    /**
-     * Validates that all required parameters are provided in the given context.
-     *
-     * @param providedVariables Set of variable names provided in the context
-     * @return List of missing parameter names, empty if all required params are present
-     */
-    fun validateParameters(providedVariables: Set<String>): List<String> {
-        val missingParams = mutableListOf<String>()
-
-        for ((paramName, definition) in parameters) {
-            if (!definition.isRequired) continue
-
-            val requiredVars = definition.getVariableNames(paramName)
-            val allProvided = requiredVars.all { it in providedVariables }
-
-            if (!allProvided) {
-                missingParams.add(paramName)
-            }
-        }
-
-        return missingParams
-    }
-
-    fun validate(): List<ValidationError> {
-        val errors = mutableListOf<ValidationError>()
-
-        // Check start state exists
-        if (startStateId !in states) {
-            errors.add(ValidationError(
-                path = "startStateId",
-                message = "Start state '$startStateId' not found in states map"
-            ))
-        }
-
-        // Check all transition states exist
-        transitions.forEachIndexed { index, transition ->
-            if (transition.sourceStateId !in states) {
-                errors.add(ValidationError(
-                    path = "transitions[$index].sourceStateId",
-                    message = "Source state '${transition.sourceStateId}' not found"
-                ))
-            }
-            if (transition.targetStateId !in states) {
-                errors.add(ValidationError(
-                    path = "transitions[$index].targetStateId",
-                    message = "Target state '${transition.targetStateId}' not found"
-                ))
-            }
-        }
-
-        states.forEach { (stateId, state) ->
-            if (state.tracks.isEmpty()) {
-                errors.add(ValidationError(
-                    path = "states[$stateId].tracks",
-                    message = "State has no tracks defined",
-                    severity = ValidationError.Severity.WARNING
-                ))
-            }
-        }
-
-        val reachableStates = findReachableStates()
-        states.keys.forEach { stateId ->
-            if (stateId !in reachableStates) {
-                errors.add(ValidationError(
-                    path = "states[$stateId]",
-                    message = "State is unreachable from start state '$startStateId'",
-                    severity = ValidationError.Severity.WARNING
-                ))
-            }
-        }
-
-        val cycles = detectCycles()
-        if (cycles.isNotEmpty()) {
-            errors.add(ValidationError(
-                path = "transitions",
-                message = "Detected transition cycles: ${cycles.joinToString(", ") { it.joinToString(" -> ") }}",
-                severity = ValidationError.Severity.WARNING
-            ))
-        }
-
-        return errors
-    }
-
-    private fun findReachableStates(): Set<String> {
-        val reachable = mutableSetOf<String>()
-        val queue = ArrayDeque<String>()
-
-        if (startStateId in states) {
-            queue.add(startStateId)
-            reachable.add(startStateId)
-        }
-
-        while (queue.isNotEmpty()) {
-            val current = queue.removeFirst()
-            transitions
-                .filter { it.sourceStateId == current }
-                .forEach { transition ->
-                    if (transition.targetStateId !in reachable && transition.targetStateId in states) {
-                        reachable.add(transition.targetStateId)
-                        queue.add(transition.targetStateId)
-                    }
-                }
-        }
-
-        return reachable
-    }
-
-    private fun detectCycles(): List<List<String>> {
-        val cycles = mutableListOf<List<String>>()
-        val visited = mutableSetOf<String>()
-        val recStack = mutableSetOf<String>()
-
-        fun dfs(node: String, path: MutableList<String>): Boolean {
-            if (node !in states) return false
-
-            visited.add(node)
-            recStack.add(node)
-            path.add(node)
-
-            for (transition in getTransitionsFrom(node)) {
-                val target = transition.targetStateId
-                if (target !in visited) {
-                    if (dfs(target, path)) return true
-                } else if (target in recStack) {
-                    val cycleStart = path.indexOf(target)
-                    if (cycleStart >= 0) {
-                        cycles.add(path.subList(cycleStart, path.size) + target)
-                    }
-                }
-            }
-
-            path.removeAt(path.size - 1)
-            recStack.remove(node)
-            return false
-        }
-
-        states.keys.forEach { stateId ->
-            if (stateId !in visited) {
-                dfs(stateId, mutableListOf())
-            }
-        }
-
-        return cycles
-    }
-}
-
-/**
- * Immutable camera state definition - a collection of tracks that play together.
- */
-data class State(
-    val id: String,
-    val tracks: List<CameraTrack>,
-    val duration: Float? = null,
-    val isLooping: Boolean = false,
-    val speed: Float = 1.0f,
-    val rememberProgress: Boolean = false,
-    val renderPlayerBody: Boolean = true,
-    val hiddenHudElements: Set<HudElement> = emptySet()
-) {
-    init {
-        require(speed > 0f) { "State speed must be positive, got $speed" }
-        duration?.let { d ->
-            require(d >= 0f) { "State duration must be non-negative, got $d" }
-        }
-    }
-
-    fun getEffectiveDuration(): Float {
-        return duration ?: tracks.maxOfOrNull { it.duration } ?: 0f
-    }
-}
-
-/**
- * Immutable transition definition - defines when and how to move from one state to another.
- */
-data class Transition(
-    val sourceStateId: String,
-    val targetStateId: String,
-    val condition: ExpressionLike,
-    val type: TransitionType = TransitionType.BLEND,
-    val blendDuration: Float = 0.4f
-) {
-    init {
-        require(blendDuration >= 0f) { "Blend duration must be non-negative, got $blendDuration" }
-    }
-}
-
-enum class TransitionType {
-    INSTANT,
-    BLEND
-}
@@ -1,59 +0,0 @@
-/*
- * 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.api.camera.model
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.camera.CameraRotation
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-import net.minecraft.world.phys.Vec3
-
-/**
- * Type-safe track evaluation result.
- */
-sealed class TrackOutput {
-    data class Position(val position: Vec3) : TrackOutput()
-    data class Focus(val target: CameraFocus) : TrackOutput()
-    data class Rotation(val rotation: CameraRotation) : TrackOutput()
-    data class Event(val expression: ExpressionLike, val eventId: String?) : TrackOutput()
-}
-
-/**
- * Camera track interface - produces outputs over time.
- */
-interface CameraTrack {
-    val trackType: String
-    val duration: Float
-
-    fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput>
-}
-
-enum class TrackCapability {
-    POSITION,
-    FOCUS,
-    ROTATION,
-    EVENTS
-}
-
-fun CameraTrack.capabilities(): Set<TrackCapability> {
-    val outputs = evaluate(0f, emptyMap(), MoLangRuntime(), Vec3.ZERO)
-    return outputs.mapTo(mutableSetOf()) { output ->
-        when (output) {
-            is TrackOutput.Position -> TrackCapability.POSITION
-            is TrackOutput.Focus -> TrackCapability.FOCUS
-            is TrackOutput.Rotation -> TrackCapability.ROTATION
-            is TrackOutput.Event -> TrackCapability.EVENTS
-        }
-    }
-}
@@ -1,222 +0,0 @@
-/*
- * 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.api.camera.registry
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.CameraTrackRegistry
-import com.cobblemon.mod.common.api.camera.model.*
-import com.cobblemon.mod.common.util.asExpressionLike
-import com.google.gson.*
-import java.lang.reflect.Type
-
-/**
- * JSON deserializer for Timeline (V2 format).
- *
- * Deserializes directly into the immutable Timeline model without legacy conversion.
- */
-object TimelineDeserializer : JsonDeserializer<Timeline> {
-
-    override fun deserialize(json: JsonElement, typeOfT: Type, ctx: JsonDeserializationContext): Timeline {
-        val obj = json.asJsonObject
-
-        val id = obj.get("timelineId")?.asString
-            ?: throw JsonParseException("Timeline missing 'timelineId' field")
-
-        val startStateId = obj.get("startStateId")?.asString
-            ?: throw JsonParseException("Timeline '$id' missing 'startStateId' field")
-
-        val statesObj = obj.get("states")?.asJsonObject
-            ?: throw JsonParseException("Timeline '$id' missing 'states' object")
-
-        val transitionsArray = obj.get("transitions")?.asJsonArray ?: JsonArray()
-
-        // Parse parameters (optional)
-        val parametersObj = obj.get("parameters")?.asJsonObject
-        val parameters = parametersObj?.entrySet()?.associate { (paramName, paramValue) ->
-            try {
-                paramName to deserializeParameter(paramValue.asJsonObject, paramName, id)
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[Timeline] Error parsing parameter '$paramName' in timeline '$id': ${e.message}")
-                throw JsonParseException("Invalid parameter '$paramName' in timeline '$id'", e)
-            }
-        } ?: emptyMap()
-
-        val states = statesObj.entrySet().associate { (key, value) ->
-            try {
-                key to deserializeState(value.asJsonObject, id)
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[Timeline] Error parsing state '$key' in timeline '$id': ${e.message}")
-                throw JsonParseException("Invalid state '$key' in timeline '$id'", e)
-            }
-        }
-
-        val transitions = transitionsArray.mapIndexed { index, element ->
-            try {
-                deserializeTransition(element.asJsonObject, id)
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[Timeline] Error parsing transition $index in timeline '$id': ${e.message}")
-                throw JsonParseException("Invalid transition $index in timeline '$id'", e)
-            }
-        }
-
-        return Timeline(
-            id = id,
-            startStateId = startStateId,
-            parameters = parameters,
-            states = states,
-            transitions = transitions
-        )
-    }
-
-    private fun deserializeParameter(obj: JsonObject, paramName: String, timelineId: String): ParameterDefinition {
-        val typeStr = obj.get("type")?.asString
-            ?: throw JsonParseException("Parameter '$paramName' missing 'type' field")
-
-        val type = when (typeStr.lowercase()) {
-            "number" -> ParameterType.NUMBER
-            "vec3" -> ParameterType.VEC3
-            else -> throw JsonParseException("Parameter '$paramName' has unknown type '$typeStr'. Valid types: number, vec3")
-        }
-
-        val description = obj.get("description")?.asString
-
-        val default: ParameterDefault? = when {
-            !obj.has("default") -> null
-            type == ParameterType.NUMBER -> {
-                val defaultValue = obj.get("default")
-                if (defaultValue.isJsonPrimitive && defaultValue.asJsonPrimitive.isNumber) {
-                    ParameterDefault.NumberDefault(defaultValue.asDouble)
-                } else {
-                    throw JsonParseException("Parameter '$paramName' default must be a number")
-                }
-            }
-            type == ParameterType.VEC3 -> {
-                val defaultObj = obj.get("default")
-                if (defaultObj.isJsonObject) {
-                    val vec = defaultObj.asJsonObject
-                    val x = vec.get("x")?.asDouble
-                        ?: throw JsonParseException("Parameter '$paramName' vec3 default missing 'x' field")
-                    val y = vec.get("y")?.asDouble
-                        ?: throw JsonParseException("Parameter '$paramName' vec3 default missing 'y' field")
-                    val z = vec.get("z")?.asDouble
-                        ?: throw JsonParseException("Parameter '$paramName' vec3 default missing 'z' field")
-                    ParameterDefault.Vec3Default(x, y, z)
-                } else {
-                    throw JsonParseException("Parameter '$paramName' vec3 default must be an object with x, y, z fields")
-                }
-            }
-            else -> null
-        }
-
-        return ParameterDefinition(
-            type = type,
-            description = description,
-            default = default
-        )
-    }
-
-    private fun deserializeState(obj: JsonObject, timelineId: String): State {
-        val stateId = obj.get("stateId")?.asString
-            ?: throw JsonParseException("State missing 'stateId' field")
-
-        val tracksArray = obj.get("tracks")?.asJsonArray
-            ?: throw JsonParseException("State '$stateId' missing 'tracks' array")
-
-        val tracks = tracksArray.mapIndexedNotNull { index, element ->
-            try {
-                deserializeTrack(element.asJsonObject)
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[Timeline] Error parsing track $index in state '$stateId': ${e.message}", e)
-                null
-            }
-        }
-
-        val duration = obj.get("duration")?.asFloat
-        val isLooping = obj.get("isLooping")?.asBoolean ?: false
-        val speed = obj.get("speed")?.asFloat ?: 1.0f
-        val rememberProgress = obj.get("rememberProgress")?.asBoolean ?: false
-        val renderPlayerBody = obj.get("renderPlayerBody")?.asBoolean ?: true
-
-        val hiddenHudElements = when (val hideHudElement = obj.get("hideHud")) {
-            null -> emptySet()
-            is JsonPrimitive -> {
-                if (hideHudElement.isBoolean) {
-                    if (hideHudElement.asBoolean) HudElement.ALL else emptySet()
-                } else {
-                    Cobblemon.LOGGER.warn("[Timeline] Invalid hideHud value in state '$stateId', expected boolean or array")
-                    emptySet()
-                }
-            }
-            is JsonArray -> {
-                hideHudElement.mapNotNull { element ->
-                    val id = element.asString
-                    HudElement.fromId(id) ?: run {
-                        Cobblemon.LOGGER.warn("[Timeline] Unknown HUD element '$id' in state '$stateId'")
-                        null
-                    }
-                }.toSet()
-            }
-            else -> {
-                Cobblemon.LOGGER.warn("[Timeline] Invalid hideHud value in state '$stateId', expected boolean or array")
-                emptySet()
-            }
-        }
-
-        return State(
-            id = stateId,
-            tracks = tracks,
-            duration = duration,
-            isLooping = isLooping,
-            speed = speed,
-            rememberProgress = rememberProgress,
-            renderPlayerBody = renderPlayerBody,
-            hiddenHudElements = hiddenHudElements
-        )
-    }
-
-    private fun deserializeTrack(obj: JsonObject): CameraTrack {
-        val trackType = obj.get("trackType")?.asString
-            ?: throw JsonParseException("Track missing 'trackType' field")
-
-        return CameraTrackRegistry.deserializeTrack(trackType, obj)
-            ?: throw JsonParseException("Unknown track type: $trackType")
-    }
-
-    private fun deserializeTransition(obj: JsonObject, timelineId: String): Transition {
-        val sourceStateId = obj.get("sourceStateId")?.asString
-            ?: throw JsonParseException("Transition missing 'sourceStateId' field")
-
-        val targetStateId = obj.get("targetStateId")?.asString
-            ?: throw JsonParseException("Transition missing 'targetStateId' field")
-
-        val conditionStr = obj.get("condition")?.asString
-            ?: throw JsonParseException("Transition from '$sourceStateId' to '$targetStateId' missing 'condition' field")
-
-        val blendDuration = obj.get("blendDuration")?.asFloat ?: 0.4f
-
-        val transitionType = obj.get("transitionType")?.asString?.let { typeStr ->
-            when (typeStr.lowercase()) {
-                "blend" -> TransitionType.BLEND
-                "instant" -> TransitionType.INSTANT
-                else -> {
-                    Cobblemon.LOGGER.warn("[Timeline] Unknown transition type '$typeStr' in timeline '$timelineId', using BLEND")
-                    TransitionType.BLEND
-                }
-            }
-        } ?: TransitionType.BLEND
-
-        return Transition(
-            sourceStateId = sourceStateId,
-            targetStateId = targetStateId,
-            condition = conditionStr.asExpressionLike(),
-            type = transitionType,
-            blendDuration = blendDuration
-        )
-    }
-}
@@ -1,117 +0,0 @@
-/*
- * 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.api.camera.registry
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.model.Timeline
-import com.cobblemon.mod.common.api.camera.result.ValidationError
-import com.cobblemon.mod.common.api.data.DataRegistry
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.GsonBuilder
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-import net.minecraft.server.packs.resources.ResourceManager
-import java.io.InputStreamReader
-
-/**
- * Registry for loading Timeline (V2 format) from JSON files.
- *
- * Loads timelines directly into the new immutable Timeline model
- * without legacy conversion.
- */
-object TimelineRegistry : DataRegistry {
-    override val id = cobblemonResource("camera_timelines")
-    override val type = PackType.SERVER_DATA
-    override val observable = SimpleObservable<TimelineRegistry>()
-
-    private val gson = GsonBuilder()
-        .registerTypeAdapter(Timeline::class.java, TimelineDeserializer)
-        .create()
-
-    private val timelines = mutableMapOf<String, Timeline>()
-
-    override fun reload(manager: ResourceManager) {
-        timelines.clear()
-
-        val resources = manager.listResources("camera_timelines") { path ->
-            path.path.endsWith(".json")
-        }
-
-        for ((identifier, resource) in resources) {
-            try {
-                resource.open().use { stream ->
-                    val reader = InputStreamReader(stream)
-                    val timeline = gson.fromJson(reader, Timeline::class.java)
-
-                    val errors = timeline.validate()
-                    val hasErrors = errors.any { it.severity == ValidationError.Severity.ERROR }
-
-                    if (hasErrors) {
-                        Cobblemon.LOGGER.error("[TimelineRegistry] Validation failed for '$identifier':")
-                        errors.forEach { error ->
-                            val level = if (error.severity == ValidationError.Severity.ERROR) "ERROR" else "WARN"
-                            Cobblemon.LOGGER.error("  [$level] ${error.path}: ${error.message}")
-                        }
-                        continue
-                    }
-
-                    if (errors.isNotEmpty()) {
-                        Cobblemon.LOGGER.warn("[TimelineRegistry] Warnings for timeline '${timeline.id}':")
-                        errors.forEach { Cobblemon.LOGGER.warn("  ${it.path}: ${it.message}") }
-                    }
-
-                    if (timelines.containsKey(timeline.id)) {
-                        Cobblemon.LOGGER.warn("[TimelineRegistry] Duplicate timeline ID '${timeline.id}' in $identifier, overwriting")
-                    }
-
-                    timelines[timeline.id] = timeline
-                    Cobblemon.LOGGER.debug("[TimelineRegistry] Loaded timeline '${timeline.id}' from $identifier")
-                }
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("[TimelineRegistry] Error loading timeline from $identifier", e)
-            }
-        }
-
-        Cobblemon.LOGGER.info("[TimelineRegistry] Loaded ${timelines.size} timelines")
-        observable.emit(this)
-    }
-
-    override fun sync(player: ServerPlayer) {
-        // Timelines are server-driven, no sync needed
-    }
-
-    fun getTimeline(id: String): Timeline? {
-        val timeline = timelines[id]
-        if (timeline == null) {
-            Cobblemon.LOGGER.error("[TimelineRegistry] Timeline '$id' not found")
-        }
-        return timeline
-    }
-
-    fun hasTimeline(id: String): Boolean = timelines.containsKey(id)
-
-    fun registerTimeline(timeline: Timeline) {
-        val errors = timeline.validate()
-        if (errors.any { it.severity == ValidationError.Severity.ERROR }) {
-            Cobblemon.LOGGER.error("[TimelineRegistry] Cannot register invalid timeline '${timeline.id}':")
-            errors.forEach { Cobblemon.LOGGER.error("  ${it.path}: ${it.message}") }
-            return
-        }
-
-        if (timelines.containsKey(timeline.id)) {
-            Cobblemon.LOGGER.warn("[TimelineRegistry] Timeline '${timeline.id}' already registered, overwriting")
-        }
-
-        timelines[timeline.id] = timeline
-        Cobblemon.LOGGER.debug("[TimelineRegistry] Registered timeline '${timeline.id}' programmatically")
-    }
-
-    fun getAllTimelines(): Collection<Timeline> = timelines.values
-}
@@ -1,22 +0,0 @@
-/*
- * 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.api.camera.result
-
-/**
- * Validation error with location context.
- */
-data class ValidationError(
-    val path: String,
-    val message: String,
-    val severity: Severity = Severity.ERROR
-) {
-    enum class Severity { WARNING, ERROR }
-
-    override fun toString(): String = "[$severity] $path: $message"
-}
@@ -1,243 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.CameraTrackRegistry
-import com.cobblemon.mod.common.api.tween.InterpolationMethod
-import com.cobblemon.mod.common.api.camera.model.CameraFocus
-import com.cobblemon.mod.common.api.camera.model.PositionExpression
-import com.cobblemon.mod.common.util.asExpressionLike
-import com.google.gson.JsonObject
-
-object CameraTrackDeserializers {
-
-    /** Should be called during mod initialization. */
-    fun registerBuiltinTracks() {
-        CameraTrackRegistry.registerTrackType("position", ::deserializePositionTrack)
-        CameraTrackRegistry.registerTrackType("focus", ::deserializeFocusTrack)
-        CameraTrackRegistry.registerTrackType("event", ::deserializeEventTrack)
-        CameraTrackRegistry.registerTrackType("reference", ::deserializeReferenceTrack)
-        CameraTrackRegistry.registerTrackType("gui", ::deserializeGuiTrack)
-
-        Cobblemon.LOGGER.debug("[CameraTrackDeserializers] Registered built-in track types: position, focus, event, reference, gui")
-    }
-
-    /**
-     * Deserializes a position track from JSON.
-     *
-     * Expected JSON format:
-     * ```json
-     * {
-     *   "trackType": "position",
-     *   "keyframes": [
-     *     {
-     *       "time": 0.0,
-     *       "position": { "x": 10.0, "y": 64.0, "z": 10.0 },
-     *       "easing": "ease_in_out_quad"
-     *     }
-     *   ],
-     *   "interpolationType": "bezier",
-     *   "easing": "linear",
-     *   "isRelative": false
-     * }
-     * ```
-     */
-    private fun deserializePositionTrack(json: JsonObject): PositionTrack {
-        val keyframesArray = json.getAsJsonArray("keyframes")
-            ?: throw IllegalArgumentException("Position track missing 'keyframes' array")
-
-        val keyframes = keyframesArray.map { element ->
-            val kfObj = element.asJsonObject
-            val time = kfObj.get("time")?.asFloat
-                ?: throw IllegalArgumentException("Position keyframe missing 'time' field")
-
-            val positionElement = kfObj.get("position")
-                ?: throw IllegalArgumentException("Position keyframe missing 'position' field")
-
-            val position = PositionExpression.fromJson(positionElement)
-            val easing = kfObj.get("easing")?.asString
-
-            PositionKeyframe(time, position, easing)
-        }
-
-        val interpolationTypeStr = json.get("interpolationType")?.asString ?: "linear"
-        val interpolationType = when (interpolationTypeStr.lowercase()) {
-            "linear" -> InterpolationMethod.LINEAR
-            "bezier", "cubic_bezier" -> InterpolationMethod.BEZIER
-            "hermite", "catmull_rom" -> InterpolationMethod.BEZIER // Map legacy types to available ones
-            else -> {
-                Cobblemon.LOGGER.warn("[CameraTrackDeserializers] Unknown interpolation type '$interpolationTypeStr', using LINEAR")
-                InterpolationMethod.LINEAR
-            }
-        }
-
-        val defaultEasing = json.get("easing")?.asString ?: "linear"
-        val isRelative = json.get("isRelative")?.asBoolean ?: false
-
-        return PositionTrack(keyframes, interpolationType, defaultEasing, isRelative)
-    }
-
-    /**
-     * Deserializes a focus track from JSON.
-     *
-     * Expected JSON format:
-     * ```json
-     * {
-     *   "trackType": "focus",
-     *   "keyframes": [
-     *     {
-     *       "time": 0.0,
-     *       "target": { "type": "position", "x": 20.0, "y": 60.0, "z": 20.0 },
-     *       "easing": "linear"
-     *     }
-     *   ],
-     *   "easing": "linear"
-     * }
-     * ```
-     */
-    private fun deserializeFocusTrack(json: JsonObject): FocusTrack {
-        val keyframesArray = json.getAsJsonArray("keyframes")
-            ?: throw IllegalArgumentException("Focus track missing 'keyframes' array")
-
-        val keyframes = keyframesArray.map { element ->
-            val kfObj = element.asJsonObject
-            val time = kfObj.get("time")?.asFloat
-                ?: throw IllegalArgumentException("Focus keyframe missing 'time' field")
-
-            val targetObj = kfObj.getAsJsonObject("target")
-                ?: throw IllegalArgumentException("Focus keyframe missing 'target' field")
-
-            val target = CameraFocus.fromJson(targetObj)
-            val easing = kfObj.get("easing")?.asString
-
-            FocusKeyframe(time, target, easing)
-        }
-
-        val defaultEasing = json.get("easing")?.asString ?: "linear"
-
-        return FocusTrack(keyframes, defaultEasing)
-    }
-
-    /**
-     * Deserializes an event track from JSON.
-     *
-     * Expected JSON format:
-     * ```json
-     * {
-     *   "trackType": "event",
-     *   "events": [
-     *     {
-     *       "time": 0.5,
-     *       "expression": "q.play_sound('cobblemon:poke_ball.open')",
-     *       "eventId": "ball_open"
-     *     }
-     *   ]
-     * }
-     * ```
-     */
-    private fun deserializeEventTrack(json: JsonObject): EventTrack {
-        val eventsArray = json.getAsJsonArray("events")
-            ?: throw IllegalArgumentException("Event track missing 'events' array")
-
-        val events = eventsArray.map { element ->
-            val eventObj = element.asJsonObject
-            val time = eventObj.get("time")?.asFloat
-                ?: throw IllegalArgumentException("Event missing 'time' field")
-
-            val expressionStr = eventObj.get("expression")?.asString
-                ?: throw IllegalArgumentException("Event missing 'expression' field")
-
-            val eventId = eventObj.get("eventId")?.asString
-
-            TimedEvent(time, expressionStr.asExpressionLike(), eventId)
-        }
-
-        return EventTrack(events)
-    }
-
-    /**
-     * Deserializes a reference track from JSON.
-     *
-     * Expected JSON format:
-     * ```json
-     * {
-     *   "trackType": "reference",
-     *   "trackId": "intro_camera_movement"
-     * }
-     * ```
-     */
-    private fun deserializeReferenceTrack(json: JsonObject): ReferenceTrack {
-        val trackId = json.get("trackId")?.asString
-            ?: throw IllegalArgumentException("Reference track missing 'trackId' field")
-
-        return ReferenceTrack(trackId)
-    }
-
-    /**
-     * Deserializes a GUI track from JSON.
-     *
-     * Expected JSON format:
-     * ```json
-     * {
-     *   "trackType": "gui",
-     *   "actions": [
-     *     {
-     *       "time": 0.0,
-     *       "action": "OPEN",
-     *       "guiId": "cobblemon:battle_intro",
-     *       "args": { "title": "Stadium Battle" },
-     *       "argsExpressions": {
-     *         "player_party_count": "variable.player_party_count"
-     *       }
-     *     },
-     *     {
-     *       "time": 5.0,
-     *       "action": "CLOSE",
-     *       "guiId": "cobblemon:battle_intro"
-     *     }
-     *   ]
-     * }
-     * ```
-     */
-    private fun deserializeGuiTrack(json: JsonObject): GuiTrack {
-        val actionsArray = json.getAsJsonArray("actions")
-            ?: throw IllegalArgumentException("GUI track missing 'actions' array")
-
-        val actions = actionsArray.map { element ->
-            val actionObj = element.asJsonObject
-            val time = actionObj.get("time")?.asFloat
-                ?: throw IllegalArgumentException("GUI action missing 'time' field")
-            val actionType = actionObj.get("action")?.asString
-                ?: throw IllegalArgumentException("GUI action missing 'action' field")
-            val guiId = actionObj.get("guiId")?.asString
-                ?: throw IllegalArgumentException("GUI action missing 'guiId' field")
-
-            val args = mutableMapOf<String, String>()
-            actionObj.getAsJsonObject("args")?.entrySet()?.forEach { (key, value) ->
-                args[key] = value.asString
-            }
-
-            val argsExpressions = mutableMapOf<String, String>()
-            actionObj.getAsJsonObject("argsExpressions")?.entrySet()?.forEach { (key, value) ->
-                argsExpressions[key] = value.asString
-            }
-
-            TimedGuiAction(
-                time = time,
-                action = GuiActionType.valueOf(actionType.uppercase()),
-                guiId = guiId,
-                args = args,
-                argsExpressions = argsExpressions
-            )
-        }
-
-        return GuiTrack(actions)
-    }
-}
@@ -1,56 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.camera.model.CameraTrack
-import com.cobblemon.mod.common.api.camera.model.TrackOutput
-import com.cobblemon.mod.common.api.molang.ExpressionLike
-import net.minecraft.world.phys.Vec3
-
-/**
- * Track that executes MoLang expressions at specific times.
- */
-data class EventTrack(
-    val events: List<TimedEvent>
-) : CameraTrack {
-    override val trackType = "event"
-
-    override val duration: Float
-        get() = events.maxOfOrNull { it.time } ?: 0f
-
-    override fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput> {
-        return emptyList()
-    }
-
-    init {
-        require(events.zipWithNext().all { (a, b) -> a.time <= b.time }) {
-            "EventTrack events must be sorted by time"
-        }
-    }
-}
-
-/**
- * Timed event - execute expression at specific time.
- */
-data class TimedEvent(
-    val time: Float,
-    val expression: ExpressionLike,
-    val eventId: String? = null
-) {
-    init {
-        require(time >= 0f) { "Event time must be non-negative, got $time" }
-    }
-}
@@ -1,126 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.tween.EasingRegistry
-import com.cobblemon.mod.common.api.tween.Interpolator
-import com.cobblemon.mod.common.api.tween.Keyframe
-import com.cobblemon.mod.common.api.camera.model.*
-import net.minecraft.util.Mth
-import net.minecraft.world.phys.Vec3
-
-/**
- * Track that animates camera look-at target over time.
- * Point targets interpolate smoothly; entity targets switch instantly.
- */
-data class FocusTrack(
-    val keyframes: List<FocusKeyframe>,
-    val defaultEasing: String = "linear"
-) : CameraTrack {
-    override val trackType = "focus"
-
-    override val duration: Float
-        get() = keyframes.maxOfOrNull { it.time } ?: 0f
-
-    override fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput> {
-        if (keyframes.isEmpty()) return emptyList()
-
-        val segment = findFocusSegment(time) ?: return emptyList()
-
-        val focus = when {
-            // Both are Point targets - interpolate
-            segment.start is CameraFocus.Point && segment.end is CameraFocus.Point -> {
-                val startPos = segment.start.position.toVec3(context, runtime)
-                val endPos = segment.end.position.toVec3(context, runtime)
-
-                // Interpolate positions
-                val easedProgress = EasingRegistry.getEasingFunction(segment.easing)(segment.progress)
-                val interpolatedPos = Vec3(
-                    Mth.lerp(easedProgress.toDouble(), startPos.x, endPos.x),
-                    Mth.lerp(easedProgress.toDouble(), startPos.y, endPos.y),
-                    Mth.lerp(easedProgress.toDouble(), startPos.z, endPos.z)
-                )
-
-                CameraFocus.Point(
-                    PositionExpression(
-                        CoordinateValue.Static(interpolatedPos.x),
-                        CoordinateValue.Static(interpolatedPos.y),
-                        CoordinateValue.Static(interpolatedPos.z)
-                    )
-                )
-            }
-            // Entity targets or mixed - use instant switching
-            else -> {
-                if (segment.progress < 0.5f) segment.start else segment.end
-            }
-        }
-
-        return listOf(TrackOutput.Focus(focus))
-    }
-
-    private fun findFocusSegment(time: Float): FocusSegment? {
-        if (keyframes.isEmpty()) return null
-        if (keyframes.size == 1) {
-            val kf = keyframes[0]
-            return FocusSegment(kf.target, kf.target, kf.time, kf.time, 1f, defaultEasing)
-        }
-
-        for (i in 0 until keyframes.size - 1) {
-            val start = keyframes[i]
-            val end = keyframes[i + 1]
-
-            if (time <= end.time) {
-                val duration = end.time - start.time
-                val progress = if (duration > 0f) {
-                    ((time - start.time) / duration).coerceIn(0f, 1f)
-                } else 1f
-
-                val easing = end.easing ?: defaultEasing
-
-                return FocusSegment(start.target, end.target, start.time, end.time, progress, easing)
-            }
-        }
-
-        val last = keyframes.last()
-        return FocusSegment(last.target, last.target, last.time, last.time, 1f, defaultEasing)
-    }
-
-    init {
-        require(keyframes.isNotEmpty()) { "FocusTrack must have at least one keyframe" }
-        require(keyframes.zipWithNext().all { (a, b) -> a.time <= b.time }) {
-            "FocusTrack keyframes must be sorted by time"
-        }
-    }
-
-    private data class FocusSegment(
-        val start: CameraFocus,
-        val end: CameraFocus,
-        val startTime: Float,
-        val endTime: Float,
-        val progress: Float,
-        val easing: String
-    )
-}
-
-data class FocusKeyframe(
-    val time: Float,
-    val target: CameraFocus,
-    val easing: String? = null
-) {
-    init {
-        require(time >= 0f) { "Keyframe time must be non-negative, got $time" }
-    }
-}
@@ -1,86 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.camera.model.CameraTrack
-import com.cobblemon.mod.common.api.camera.model.TrackOutput
-import net.minecraft.world.phys.Vec3
-
-/**
- * Track that fires timed GUI actions (open, close, update) during camera timelines.
- *
- * This track produces no camera outputs itself (no position/focus/rotation).
- * The actions are executed by the CameraExecutor when their time is crossed.
- */
-data class GuiTrack(
-    val actions: List<TimedGuiAction>
-) : CameraTrack {
-    override val trackType = "gui"
-
-    override val duration: Float
-        get() = actions.maxOfOrNull { it.time } ?: 0f
-
-    override fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput> {
-        // GUI actions are handled by the engine/executor, not via TrackOutput
-        return emptyList()
-    }
-
-    init {
-        require(actions.zipWithNext().all { (a, b) -> a.time <= b.time }) {
-            "GuiTrack actions must be sorted by time"
-        }
-    }
-}
-
-/**
- * Determines the type of GUI action to fire.
- */
-enum class GuiActionType {
-    OPEN,
-    CLOSE,
-    UPDATE_ARGS
-}
-
-/**
- * A timed GUI action within a timeline.
- *
- * @param time The time in seconds when this action should fire
- * @param action The type of action
- * @param guiId The scripted GUI resource location (e.g., "cobblemon:battle_intro")
- * @param args Static argument values
- * @param argsExpressions MoLang expressions to evaluate at fire time, merged with static args
- */
-data class TimedGuiAction(
-    val time: Float,
-    val action: GuiActionType,
-    val guiId: String,
-    val args: Map<String, String> = emptyMap(),
-    val argsExpressions: Map<String, String> = emptyMap()
-) {
-    init {
-        require(time >= 0f) { "GUI action time must be non-negative, got $time" }
-    }
-}
-
-/**
- * Represents a GUI action that has fired (time crossed).
- */
-data class FiredGuiAction(
-    val action: GuiActionType,
-    val guiId: String,
-    val args: Map<String, String>,
-    val argsExpressions: Map<String, String>
-)
@@ -1,79 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.api.tween.*
-import com.cobblemon.mod.common.api.camera.model.*
-import net.minecraft.world.phys.Vec3
-
-/**
- * Track that animates camera position over time using keyframes.
- */
-data class PositionTrack(
-    val keyframes: List<PositionKeyframe>,
-    val interpolation: InterpolationMethod = InterpolationMethod.LINEAR,
-    val defaultEasing: String = "linear",
-    val isRelative: Boolean = false
-) : CameraTrack {
-    override val trackType = "position"
-
-    override val duration: Float
-        get() = keyframes.maxOfOrNull { it.time } ?: 0f
-
-    override fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput> {
-        if (keyframes.isEmpty()) return emptyList()
-
-        val interpolatableKeyframes = keyframes.map { kf ->
-            val vec = kf.position.toVec3(context, runtime, origin, isRelative)
-            Keyframe(kf.time, vec.asInterpolatable())
-        }
-
-        val interpolated = Interpolator.interpolate(
-            keyframes = interpolatableKeyframes,
-            time = time,
-            method = interpolation,
-            defaultEasing = defaultEasing,
-            getEasing = { value ->
-                // Find original keyframe to get easing
-                val index = interpolatableKeyframes.indexOfFirst { it.value == value }
-                keyframes.getOrNull(index)?.easing
-            }
-        )
-
-        return if (interpolated != null) {
-            listOf(TrackOutput.Position(interpolated.vec))
-        } else {
-            emptyList()
-        }
-    }
-
-    init {
-        require(keyframes.isNotEmpty()) { "PositionTrack must have at least one keyframe" }
-        require(keyframes.zipWithNext().all { (a, b) -> a.time <= b.time }) {
-            "PositionTrack keyframes must be sorted by time"
-        }
-    }
-}
-
-data class PositionKeyframe(
-    val time: Float,
-    val position: PositionExpression,
-    val easing: String? = null
-) {
-    init {
-        require(time >= 0f) { "Keyframe time must be non-negative, got $time" }
-    }
-}
@@ -1,50 +0,0 @@
-/*
- * 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.api.camera.track
-
-import com.bedrockk.molang.runtime.MoLangRuntime
-import com.bedrockk.molang.runtime.value.MoValue
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.camera.model.CameraTrack
-import com.cobblemon.mod.common.api.camera.model.TrackOutput
-import com.cobblemon.mod.common.client.camera.tracks.CameraTrackDefinitionRegistry
-import net.minecraft.world.phys.Vec3
-
-/**
- * Track that references another track definition by ID.
- */
-data class ReferenceTrack(
-    val trackId: String
-) : CameraTrack {
-    override val trackType = "reference"
-
-    override val duration: Float
-        get() {
-            val referencedTrack = CameraTrackDefinitionRegistry.getTrack(trackId)
-            return referencedTrack?.duration ?: 0f
-        }
-
-    override fun evaluate(
-        time: Float,
-        context: Map<String, MoValue>,
-        runtime: MoLangRuntime,
-        origin: Vec3
-    ): List<TrackOutput> {
-        val referencedTrack = CameraTrackDefinitionRegistry.getTrack(trackId)
-
-        if (referencedTrack == null) {
-            // Log warning but don't crash
-            Cobblemon.LOGGER.warn("[ReferenceTrack] Track '$trackId' not found in registry")
-            return emptyList()
-        }
-
-        // Delegate to referenced track
-        return referencedTrack.evaluate(time, context, runtime, origin)
-    }
-}
@@ -27,6 +27,7 @@ enum class Flavour(val colour: Int): StringRepresentable {

    override fun getSerializedName() = name
    companion object {
+        @JvmField
        val CODEC = StringRepresentable.fromEnum<Flavour> { Flavour.entries.toTypedArray() }
    }
-}
+}
@@ -17,6 +17,7 @@ data class Food(
        val saturation: Float = 0f,
 ) {
    companion object {
+        @JvmField
        val CODEC: Codec<Food> = RecordCodecBuilder.create { builder ->
            builder.group(
                    Codec.INT.optionalFieldOf("hunger", 0).forGetter { it.hunger },
@@ -38,6 +38,7 @@ data class Seasoning(
    val mobEffects: List<SerializableMobEffectInstance>? = null
 ) {
    companion object {
+        @JvmField
        val CODEC: Codec<Seasoning> = RecordCodecBuilder.create { builder ->
            builder.group(
                ITEM_REGISTRY_LIKE_CODEC.fieldOf("ingredient").forGetter { it.ingredient },
@@ -58,6 +59,7 @@ data class Seasoning(
            }
        }

+        @JvmField
        val STREAM_CODEC: StreamCodec<ByteBuf, Seasoning> = ByteBufCodecs.fromCodec(CODEC)
    }
-}
+}
@@ -31,6 +31,7 @@ data class SerializableMobEffectInstance(
    }

    companion object {
+        @JvmField
        val CODEC: Codec<SerializableMobEffectInstance> = RecordCodecBuilder.create { builder ->
            builder.group(
                    ResourceLocation.CODEC.fieldOf("effect").forGetter { it.effect },
@@ -42,4 +43,4 @@ data class SerializableMobEffectInstance(
            ).apply(builder, ::SerializableMobEffectInstance)
        }
    }
-}
+}
@@ -26,9 +26,11 @@ class Dialogue(
    val initializationAction: DialogueAction = FunctionDialogueAction { _, _ -> }
 ) {
    companion object {
+        @JvmField
        val DEFAULT_BACKGROUND = cobblemonResource("textures/gui/dialogue/dialogue_box.png")

        @JvmOverloads
+        @JvmStatic
        fun of(
            pages: Iterable<DialoguePage>,
            background: ResourceLocation = DEFAULT_BACKGROUND,
@@ -44,6 +46,7 @@ class Dialogue(
        }

        @JvmOverloads
+        @JvmStatic
        fun of(
            pages: Iterable<DialoguePage>,
            background: ResourceLocation = DEFAULT_BACKGROUND,
@@ -23,7 +23,7 @@ import com.cobblemon.mod.common.util.resolve
 */
 interface DialogueAction {
    companion object {
-        @JvmStatic
+        @JvmField
        val types = mutableMapOf<String, Class<out DialogueAction>>()
    }

@@ -23,6 +23,7 @@ sealed interface DialogueFaceProvider {
    val isLeftSide: Boolean

    companion object {
+        @JvmField
        val types = mutableMapOf(
            "artificial" to ArtificialDialogueFaceProvider::class.java,
            "player" to PlayerDialogueFaceProvider::class.java,
@@ -58,4 +58,9 @@ object DialogueManager {
        DialogueClosedPacket(activeDialogue.dialogueId).sendToPlayer(playerEntity)
        activeDialogues.remove(playerEntity.uuid)
    }
+
+    @JvmStatic
+    fun getDialogue(playerEntity: ServerPlayer): ActiveDialogue? {
+        return activeDialogues[playerEntity.uuid]
+    }
 }
@@ -38,6 +38,7 @@ class DialoguePage(
 ) {
    companion object {
        @JvmOverloads
+        @JvmStatic
        fun of(
            /** The ID is optional, but if you want to be able to jump to this page from other pages then you probably want to set this. */
            id: String = "",
@@ -78,4 +79,4 @@ class DialoguePage(
            )
        )
    }
-}
+}
@@ -20,6 +20,7 @@ import com.cobblemon.mod.common.util.resolveBoolean
 */
 interface DialoguePredicate {
    companion object {
+        @JvmField
        val types = mutableMapOf<String, Class<out DialoguePredicate>>()
    }

@@ -24,6 +24,7 @@ import net.minecraft.network.chat.MutableComponent
 */
 interface DialogueText {
    companion object {
+        @JvmField
        val types = mutableMapOf<String, Class<out DialogueText>>(
            "expression" to ExpressionLikeDialogueText::class.java,
        )
@@ -26,7 +26,10 @@ interface DropEntry {
    companion object {
        val entryTypes = mutableMapOf<String, Class<out DropEntry>>()
        var defaultType: Class<out DropEntry>? = null
+        @JvmStatic
        fun getByName(name: String) = entryTypes[name]
+        @JvmOverloads
+        @JvmStatic
        fun <T : DropEntry> register(name: String, clazz: Class<T>, isDefault: Boolean = false) {
            entryTypes[name] = clazz
            if (isDefault) {
Author	SHA1	Message	Date
Deltric	94978bff20	The great java annotation	2026-01-17 06:20:57 -06:00
Deltric	cccc71a64b	Add register method for types	2026-01-17 04:19:07 -06:00
Deltric	23ce272813	Expose PNX to FormeChangeEvent and MoLang	2026-01-17 04:02:44 -06:00
Deltric	e271613257	Add methods for registering custom showdown instructions.	2026-01-17 03:57:38 -06:00