Added TODO:

CHANGELOG.md

@@ -1,28 +1,25 @@
 # Changelog
-## [1.7.4 (MONTH Xth, 2026)](#1-7-4)
+## [1.7.2 (MONTH Xth, YEAR)](#1-7-2)
 
 ### Additions
-- 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??!
-
-### New rideable Pokémon
-
-### Pokémon Added
-
-### Model updates for the following Pokémon
-
-### Animation updates for the following Pokémon
 
 ### Changes
 
 ### 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 orientation not getting reset after crashing while flying and getting back on the Pokémon.
+- Fixed Furfrou not being trimmable on NeoForge.
+- 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 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
 
 ### Developer
 
 ### Molang & Datapacks
 
+### Particles
+
 ### Localization
-- Updated translations for:
+- Updated translations for:

changelogs/CHANGELOG-1.7.2.md

@@ -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

changelogs/CHANGELOG-1.7.3.md

@@ -1,23 +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

common/build.gradle.kts

@@ -54,6 +54,8 @@ dependencies {
     // Flywheel has no common dep so just pick one and don't use any platform specific code in common
     // modCompileOnly(libs.flywheelFabric)
 
+    modCompileOnly(files("temp/vivecraft-1.21.1-1.3.4.jar")) // TODO: Switch this to a proper dependency when Vivecraft gets a maven repo
+
     // Showdown
     modCompileOnly(libs.graal)
 

common/src/main/java/com/cobblemon/mod/common/mixin/BeeOccupantMixin.java

@@ -11,9 +11,7 @@ package com.cobblemon.mod.common.mixin;
 
 import com.cobblemon.mod.common.CobblemonMemories;
 import com.cobblemon.mod.common.api.ai.config.task.PathToBeeHiveTaskConfig;
-import com.cobblemon.mod.common.api.pokemon.PokemonProperties;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
-import com.cobblemon.mod.common.world.feature.SaccharineTreeFeature;
 import net.minecraft.core.BlockPos;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.tags.BlockTags;
@@ -44,21 +42,7 @@ public abstract class BeeOccupantMixin {
         if (cir.getReturnValue() == null) {
             final BeehiveBlockEntity.Occupant occupant = (BeehiveBlockEntity.Occupant) (Object) this;
             CompoundTag compoundTag = occupant.entityData().copyTag();
-            String id = compoundTag.getString("id");
-            Entity entity = null;
-            if (id.equals(SaccharineTreeFeature.Companion.getPOKEMON_PLACEHOLD_ID())) {
-                // Special case for Pokemon stuffed into a beenest upon world gen.
-                // For technical reasons we cannot create them as full entities during world gen.
-                // So we look for this special id tag and complete the entity when it attempts to exit a hive.
-                if (compoundTag.contains("pokemonProperties")) {
-                    String properties = compoundTag.getString("pokemonProperties");
-                    PokemonProperties pokemon = PokemonProperties.Companion.parse(properties);
-                    entity = pokemon.createEntity(level);
-                }
-            } else {
-                entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
-            }
-
+            Entity entity = EntityType.loadEntityRecursive(compoundTag, level, (entityx) -> entityx);
             if (entity instanceof PokemonEntity pokemonEntity) {
                 var state = level.getBlockState(pos);
                 var newPos = Vec3.ZERO;

common/src/main/java/com/cobblemon/mod/common/mixin/ServerPlayerMixin.java

@@ -11,15 +11,11 @@ package com.cobblemon.mod.common.mixin;
 import com.cobblemon.mod.common.Cobblemon;
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.PlayerSpawnerAccessor;
-import com.cobblemon.mod.common.api.riding.RidingStyle;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawner;
 import com.cobblemon.mod.common.api.spawning.spawner.PlayerSpawnerFactory;
-import com.cobblemon.mod.common.api.stats.CobblemonStats;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
-import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
-import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import com.llamalad7.mixinextras.sugar.Local;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
@@ -93,32 +89,4 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
     private boolean cobblemon$cancelSavingPokemonMounts(boolean original, @Local(ordinal=0) Entity entity) {
         return original && !(entity instanceof PokemonEntity);
     }
-
-    @WrapOperation(method = "checkRidingStatistics", at = @At(value = "INVOKE", target = "Lnet/minecraft/server/level/ServerPlayer;getVehicle()Lnet/minecraft/world/entity/Entity;"))
-    public Entity cobblemon$checkRidingStatistics(ServerPlayer player, Operation<Entity> original, @Local int distance) {
-        var entity = original.call(player);
-        if (!(entity instanceof PokemonEntity pokemonEntity)) {
-            return entity;
-        }
-
-        var ridingController = pokemonEntity.getRidingController();
-        if (ridingController == null) return entity;
-
-        var activeContext = ridingController.getContext();
-        if (activeContext == null) return entity;
-
-        var ridingStyle = activeContext.getStyle();
-        CobblemonStats.CobblemonStat stat = switch (ridingStyle) {
-            case RidingStyle.LAND -> CobblemonStats.RIDING_LAND;
-            case RidingStyle.AIR -> CobblemonStats.RIDING_AIR;
-            case RidingStyle.LIQUID -> CobblemonStats.RIDING_LIQUID;
-            default -> null;
-        };
-
-        if (stat != null) {
-            player.awardStat(CobblemonStats.getStat(stat), distance);
-        }
-
-        return entity;
-    }
 }

common/src/main/java/com/cobblemon/mod/common/mixin/accessor/DispenserBlockAccessor.java

@@ -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();
-	}
-}

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

@@ -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();
             }
         }
     }

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

@@ -65,14 +65,10 @@ 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.block.dispenser.DispenserBehaviorRegistry
+import com.cobblemon.mod.common.block.DispenserBehaviorRegistry
 import com.cobblemon.mod.common.client.CobblemonPack
 import com.cobblemon.mod.common.command.argument.*
 import com.cobblemon.mod.common.config.CobblemonConfig
@@ -80,12 +76,8 @@ 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.integration.vivecraft.CobblemonVR
 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
@@ -99,23 +91,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.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.properties.*
+import com.cobblemon.mod.common.pokemon.properties.tags.PokemonFlagProperty
 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
@@ -123,17 +103,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
@@ -146,15 +115,28 @@ 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
     const val VERSION = CobblemonBuildDetails.VERSION
     const val CONFIG_PATH = "config/$MODID/main.json"
+
     @JvmField
     val LOGGER: Logger = LogManager.getLogger()
 
     lateinit var implementation: CobblemonImplementation
+
     @Deprecated("This field is now a config value", ReplaceWith("Cobblemon.config.captureCalculator"))
     var captureCalculator: CaptureCalculator
         get() = this.config.captureCalculator
@@ -184,21 +166,49 @@ object Cobblemon {
     val serverPlayerStructs = mutableMapOf<UUID, ObjectValue<Player>>()
 
     val statistics: CobblemonStats = CobblemonStats
+    var cobblemonVR: CobblemonVR? = null
 
     @JvmStatic
-    val builtinPacks = listOf(
-        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),
-        CobblemonPack(id = "uniqueshinyforms", name = "Shinies for Magikarp Jump", packType = PackType.CLIENT_RESOURCES, activationBehaviour = ResourcePackActivationBehaviour.NORMAL),
+    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
+        ),
+        CobblemonPack(
+            id = "uniqueshinyforms",
+            name = "Shinies for Magikarp Jump",
+            packType = PackType.CLIENT_RESOURCES,
+            activationBehaviour = ResourcePackActivationBehaviour.NORMAL
+        ),
 
-        CobblemonPack(id = "repurposedstructurescobblemon", name = "Repurposed Structures Cobblemon", packType = PackType.SERVER_DATA, activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED, neededMods = setOf("repurposed_structures")),
+        CobblemonPack(
+            id = "repurposedstructurescobblemon",
+            name = "Repurposed Structures Cobblemon",
+            packType = PackType.SERVER_DATA,
+            activationBehaviour = ResourcePackActivationBehaviour.DEFAULT_ENABLED,
+            neededMods = setOf("repurposed_structures")
+        ),
     )
 
     fun preInitialize(implementation: CobblemonImplementation) {
         this.implementation = implementation
 
-        this.LOGGER.info("Launching Cobblemon ${CobblemonBuildDetails.VERSION}${if(CobblemonBuildDetails.SNAPSHOT) "-SNAPSHOT" else ""} ")
+        this.LOGGER.info("Launching Cobblemon ${CobblemonBuildDetails.VERSION}${if (CobblemonBuildDetails.SNAPSHOT) "-SNAPSHOT" else ""} ")
         if (CobblemonBuildDetails.SNAPSHOT) {
             this.LOGGER.info("  - Git Commit: ${smallCommitHash()} (https://gitlab.com/cable-mc/cobblemon/-/commit/${CobblemonBuildDetails.GIT_COMMIT})")
             this.LOGGER.info("  - Branch: ${CobblemonBuildDetails.BRANCH}")
@@ -222,7 +232,6 @@ object Cobblemon {
         implementation.registerEntityDataSerializers()
         implementation.registerCriteria()
         implementation.registerEntitySubPredicates()
-        implementation.registerMobEffects()
         DispenserBehaviorRegistry.registerDispenserBehaviors()
 
         DropEntry.register("command", CommandDropEntry::class.java)
@@ -263,7 +272,10 @@ object Cobblemon {
         }
 
         PlatformEvents.RIGHT_CLICK_ENTITY.subscribe { event ->
-            if (event.player.getItemInHand(event.hand).item is NameTagItem && event.entity.type.`is`(CobblemonEntityTypeTags.CANNOT_HAVE_NAME_TAG)) {
+            if (event.player.getItemInHand(event.hand).item is NameTagItem && event.entity.type.`is`(
+                    CobblemonEntityTypeTags.CANNOT_HAVE_NAME_TAG
+                )
+            ) {
                 event.cancel()
             }
         }
@@ -274,7 +286,10 @@ object Cobblemon {
                 pokemon.lockedEvolutions
                     .filterIsInstance<BlockClickEvolution>()
                     .forEach { evolution ->
-                        evolution.attemptEvolution(pokemon, BlockClickEvolution.BlockInteractionContext(block, player.level()))
+                        evolution.attemptEvolution(
+                            pokemon,
+                            BlockClickEvolution.BlockInteractionContext(block, player.level())
+                        )
                     }
             }
         }
@@ -334,9 +349,14 @@ object Cobblemon {
             SlowpokeTailRegrowthSpeciesFeatureProvider
         )
 
+        if (implementation.isModInstalled("vivecraft")) {  // VR integration
+            cobblemonVR = CobblemonVR()
+            cobblemonVR?.init()
+        }
+
         CustomPokemonProperty.register(UncatchableProperty)
         CustomPokemonProperty.register(BattleCloneProperty)
-        CustomPokemonProperty.register(LabelProperty)
+        CustomPokemonProperty.register(PokemonFlagProperty)
         CustomPokemonProperty.register(HiddenAbilityPropertyType)
         CustomPokemonProperty.register(AspectPropertyType)
         CustomPokemonProperty.register(UnaspectPropertyType)
@@ -353,7 +373,7 @@ object Cobblemon {
         }
 
         PlatformEvents.SERVER_TICK_POST.subscribe {
-            ServerTaskTracker.update(1/20F)
+            ServerTaskTracker.update(1 / 20F)
             ServerRealTimeTaskTracker.update()
         }
         PlatformEvents.SERVER_TICK_PRE.subscribe {
@@ -397,10 +417,22 @@ object Cobblemon {
                             .applyConnectionString(ConnectionString(config.mongoDBConnectionString))
                             .build()
                         mongoClient = MongoClients.create(mongoClientSettings)
-                        val generalMongoFactory = CachedPlayerDataStoreFactory(PlayerDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PlayerDataCollection"))
+                        val generalMongoFactory = CachedPlayerDataStoreFactory(
+                            PlayerDataMongoBackend(
+                                mongoClient,
+                                config.mongoDBDatabaseName,
+                                "PlayerDataCollection"
+                            )
+                        )
                         generalMongoFactory.setup(server)
 
-                        val pokedexMongoFactory = CachedPlayerDataStoreFactory(DexDataMongoBackend(mongoClient, config.mongoDBDatabaseName, "PokeDexCollection"))
+                        val pokedexMongoFactory = CachedPlayerDataStoreFactory(
+                            DexDataMongoBackend(
+                                mongoClient,
+                                config.mongoDBDatabaseName,
+                                "PokeDexCollection"
+                            )
+                        )
                         pokedexMongoFactory.setup(server)
 
                         playerDataManager.setFactory(generalMongoFactory, PlayerInstancedDataStoreTypes.GENERAL)
@@ -472,7 +504,7 @@ object Cobblemon {
             server()?.getLevel(dimension)
         } else {
             val mc = Minecraft.getInstance()
-            mc.singleplayerServer?.getLevel(dimension) ?: mc.level
+            return mc.singleplayerServer?.getLevel(dimension) ?: mc.level
         }
     }
 
@@ -522,6 +554,7 @@ object Cobblemon {
                                 field.set(config, field.get(defaultConfig))
                             }
                         }
+
                         is IntConstraint -> {
                             var value = field.get(config)
                             if (value is Int) {
@@ -574,20 +607,76 @@ object Cobblemon {
     }
 
     private fun registerArgumentTypes() {
-        this.implementation.registerCommandArgument(cobblemonResource("pokemon"), SpeciesArgumentType::class, SingletonArgumentInfo.contextFree(SpeciesArgumentType::species))
-        this.implementation.registerCommandArgument(cobblemonResource("pokemon_properties"), PokemonPropertiesArgumentType::class, SingletonArgumentInfo.contextFree(PokemonPropertiesArgumentType::properties))
-        this.implementation.registerCommandArgument(cobblemonResource("spawn_bucket"), SpawnBucketArgumentType::class, SingletonArgumentInfo.contextFree(SpawnBucketArgumentType::spawnBucket))
-        this.implementation.registerCommandArgument(cobblemonResource("move"), MoveArgumentType::class, SingletonArgumentInfo.contextFree(MoveArgumentType::move))
-        this.implementation.registerCommandArgument(cobblemonResource("party_slot"), PartySlotArgumentType::class, SingletonArgumentInfo.contextFree(PartySlotArgumentType::partySlot))
-        this.implementation.registerCommandArgument(cobblemonResource("pokemon_store"), PokemonStoreArgumentType::class, SingletonArgumentInfo.contextFree(PokemonStoreArgumentType::pokemonStore))
-        this.implementation.registerCommandArgument(cobblemonResource("dialogue"), DialogueArgumentType::class, SingletonArgumentInfo.contextFree(DialogueArgumentType::dialogue))
-        this.implementation.registerCommandArgument(cobblemonResource("form"), FormArgumentType::class, SingletonArgumentInfo.contextFree(FormArgumentType::form))
-        this.implementation.registerCommandArgument(cobblemonResource("dex"), DexArgumentType::class, SingletonArgumentInfo.contextFree (DexArgumentType::dex))
-        this.implementation.registerCommandArgument(cobblemonResource("npc_class"), NPCClassArgumentType::class, SingletonArgumentInfo.contextFree(NPCClassArgumentType::npcClass))
-        this.implementation.registerCommandArgument(cobblemonResource("wallpaper"), UnlockablePCBoxWallpaperArgumentType::class, SingletonArgumentInfo.contextFree(UnlockablePCBoxWallpaperArgumentType::wallpaper))
-        this.implementation.registerCommandArgument(cobblemonResource("mark"), MarkArgumentType::class, SingletonArgumentInfo.contextFree(MarkArgumentType::mark))
-        this.implementation.registerCommandArgument(cobblemonResource("transform_type"), TransformTypeArgumentType::class, SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType))
-        this.implementation.registerCommandArgument(cobblemonResource("model_part"), ModelPartArgumentType::class, SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart))
+        this.implementation.registerCommandArgument(
+            cobblemonResource("pokemon"),
+            SpeciesArgumentType::class,
+            SingletonArgumentInfo.contextFree(SpeciesArgumentType::species)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("pokemon_properties"),
+            PokemonPropertiesArgumentType::class,
+            SingletonArgumentInfo.contextFree(PokemonPropertiesArgumentType::properties)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("spawn_bucket"),
+            SpawnBucketArgumentType::class,
+            SingletonArgumentInfo.contextFree(SpawnBucketArgumentType::spawnBucket)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("move"),
+            MoveArgumentType::class,
+            SingletonArgumentInfo.contextFree(MoveArgumentType::move)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("party_slot"),
+            PartySlotArgumentType::class,
+            SingletonArgumentInfo.contextFree(PartySlotArgumentType::partySlot)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("pokemon_store"),
+            PokemonStoreArgumentType::class,
+            SingletonArgumentInfo.contextFree(PokemonStoreArgumentType::pokemonStore)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("dialogue"),
+            DialogueArgumentType::class,
+            SingletonArgumentInfo.contextFree(DialogueArgumentType::dialogue)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("form"),
+            FormArgumentType::class,
+            SingletonArgumentInfo.contextFree(FormArgumentType::form)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("dex"),
+            DexArgumentType::class,
+            SingletonArgumentInfo.contextFree(DexArgumentType::dex)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("npc_class"),
+            NPCClassArgumentType::class,
+            SingletonArgumentInfo.contextFree(NPCClassArgumentType::npcClass)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("wallpaper"),
+            UnlockablePCBoxWallpaperArgumentType::class,
+            SingletonArgumentInfo.contextFree(UnlockablePCBoxWallpaperArgumentType::wallpaper)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("mark"),
+            MarkArgumentType::class,
+            SingletonArgumentInfo.contextFree(MarkArgumentType::mark)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("transform_type"),
+            TransformTypeArgumentType::class,
+            SingletonArgumentInfo.contextFree(TransformTypeArgumentType::transformType)
+        )
+        this.implementation.registerCommandArgument(
+            cobblemonResource("model_part"),
+            ModelPartArgumentType::class,
+            SingletonArgumentInfo.contextFree(ModelPartArgumentType::modelPart)
+        )
     }
 
 }

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

@@ -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

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

@@ -117,11 +117,6 @@ interface CobblemonImplementation {
 
     fun registerEntitySubPredicates()
 
-    /**
-     * TODO
-     */
-    fun registerMobEffects()
-
 
     /**
      * Add a feature to the current platform implementation.

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

@@ -507,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))
@@ -716,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())
@@ -809,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", 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))
@@ -938,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
@@ -946,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
@@ -1054,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
@@ -1072,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
@@ -1569,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 {

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

@@ -1,33 +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
-
-import com.cobblemon.mod.common.api.cooking.effects.CleanseAllEffect
-import com.cobblemon.mod.common.api.cooking.effects.CleanseNegativeEffect
-import com.cobblemon.mod.common.api.cooking.effects.MentalRestorationEffect
-import com.cobblemon.mod.common.platform.PlatformRegistry
-import net.minecraft.core.Registry
-import net.minecraft.core.registries.BuiltInRegistries
-import net.minecraft.core.registries.Registries
-import net.minecraft.resources.ResourceKey
-import net.minecraft.world.effect.MobEffect
-
-object CobblemonMobEffects : PlatformRegistry<Registry<MobEffect>, ResourceKey<Registry<MobEffect>>, MobEffect>() {
-    override val registry: Registry<MobEffect> = BuiltInRegistries.MOB_EFFECT
-    override val resourceKey: ResourceKey<Registry<MobEffect>> = Registries.MOB_EFFECT
-
-    @JvmField
-    val CLEANSE_NEGATIVE = create("cleanse_negative", CleanseNegativeEffect())
-
-    @JvmField
-    val MENTAL_RESTORATION = create("mental_restoration", MentalRestorationEffect())
-
-    @JvmField
-    val CLEANSE_ALL = create("cleanse_all", CleanseAllEffect())
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/battles/model/PokemonBattle.kt

@@ -304,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) {
@@ -499,8 +498,8 @@ open class PokemonBattle(
     }
 
     fun stop() {
-        writeShowdownAction(">forcetie") // This will terminate the Showdown connection
         end()
+        writeShowdownAction(">forcetie") // This will terminate the Showdown connection
     }
 
     fun checkForInputDispatch() {

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/CleanseAllEffect.kt

@@ -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.cooking.effects
-
-import net.minecraft.world.effect.MobEffect
-import net.minecraft.world.effect.MobEffectCategory
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.entity.LivingEntity
-
-class CleanseAllEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
-    override fun isInstantenous() = true
-    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
-        target.removeAllEffects()
-    }
-    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/CleanseNegativeEffect.kt

@@ -1,27 +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.cooking.effects
-
-import net.minecraft.world.effect.MobEffect
-import net.minecraft.world.effect.MobEffectCategory
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.entity.LivingEntity
-
-class CleanseNegativeEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xFFFFFF) {
-    override fun isInstantenous() = true
-    override fun applyInstantenousEffect(source: Entity?, indirect: Entity?, target: LivingEntity, amplifier: Int, proximity: Double) {
-        val snapshot = target.activeEffects.toList()
-        for (ei in snapshot) {
-            if (ei.effect.value().category == MobEffectCategory.HARMFUL) {
-                target.removeEffect(ei.effect)
-            }
-        }
-    }
-    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int) = false
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/cooking/effects/MentalRestorationEffect.kt

@@ -1,33 +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.cooking.effects
-
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.stats.Stats
-import net.minecraft.world.effect.MobEffect
-import net.minecraft.world.effect.MobEffectCategory
-import net.minecraft.world.entity.LivingEntity
-
-class MentalRestorationEffect : MobEffect(MobEffectCategory.BENEFICIAL, 0xAA66FF) {
-    override fun applyEffectTick(entity: LivingEntity, amplifier: Int): Boolean {
-        if (entity is ServerPlayer) {
-            val stats = entity.stats
-            val statType = Stats.CUSTOM.get(Stats.TIME_SINCE_REST)
-            val current = stats.getValue(statType)
-            val reduction = 31 * (amplifier + 1)// reduce by half a minute every second per level (30 ticks removed per tick + 1 to account for the tick passing)
-            val newValue = Math.max(current - reduction, 0)
-            stats.setValue(entity, statType, newValue)
-        }
-        return true
-    }
-
-    override fun shouldApplyEffectTickThisTick(duration: Int, amplifier: Int): Boolean {
-        return true
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/BattleFaintedEvent.kt

@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.api.events.battles
 
 import com.bedrockk.molang.runtime.value.MoValue
-import com.bedrockk.molang.runtime.value.StringValue
 import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
@@ -26,8 +25,7 @@ import com.cobblemon.mod.common.util.asArrayValue
 data class BattleFaintedEvent(
     override val battle: PokemonBattle,
     val killed: BattlePokemon,
-    val context: BattleContext,
-    val pnx: String
+    val context: BattleContext
 ) : BattleEvent {
     val structContext = mutableMapOf<String, MoValue>(
         "battle" to battle.struct,
@@ -35,7 +33,6 @@ data class BattleFaintedEvent(
         "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
         "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
         "pokemon" to killed.struct,
-        "context" to context.getStruct(),
-        "pnx" to StringValue(pnx)
+        "context" to context.getStruct()
     )
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/events/battles/instruction/FormeChangeEvent.kt

@@ -25,8 +25,7 @@ import com.cobblemon.mod.common.util.asArrayValue
 data class FormeChangeEvent(
     override val battle: PokemonBattle,
     val pokemon: BattlePokemon,
-    val formeName: String,
-    val pnx: String
+    val formeName: String
 ) : BattleEvent {
     val context = mutableMapOf(
         "battle" to battle.struct,
@@ -34,7 +33,6 @@ data class FormeChangeEvent(
         "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
         "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct },
         "pokemon" to pokemon.struct,
-        "forme" to StringValue(formeName),
-        "pnx" to StringValue(pnx)
+        "forme" to StringValue(formeName)
     )
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/api/interaction/PokemonInteractions.kt

@@ -9,14 +9,13 @@
 package com.cobblemon.mod.common.api.interaction
 
 import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
+import com.cobblemon.mod.common.api.pokemon.requirement.OwnerQueryRequirement
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.net.messages.client.data.PokemonInteractionsSyncPacket
 import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
 import com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter
 import com.cobblemon.mod.common.pokemon.requirements.PokemonPropertiesRequirement
@@ -30,11 +29,6 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
 import net.minecraft.util.LowerCaseEnumTypeAdapterFactory
-import net.minecraft.world.item.Item
-import net.minecraft.world.level.biome.Biome
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.levelgen.structure.Structure
-import net.minecraft.world.level.material.Fluid
 
 object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
     override val id = cobblemonResource("pokemon_interactions")
@@ -49,42 +43,40 @@ object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
         .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
         .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
         .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
-        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
         .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
         .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
         .setPrettyPrinting()
         .create()
 
-    val interactions = mutableListOf<PokemonInteractionSet>()
+    val speciesInteractions = mutableListOf<PokemonInteractionSet>()
+    val generalInteractions = mutableListOf<PokemonInteractionSet>()
 
-    override fun sync(player: ServerPlayer) {
-        PokemonInteractionsSyncPacket(interactions).sendToPlayer(player)
-    }
+    override fun sync(player: ServerPlayer) {}
 
     override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>) {
-        interactions.clear()
-        val split = data.entries
-            .partition {
-                it.value.requirements.any { requirement -> requirement is PokemonPropertiesRequirement && requirement.target.species != null }
-            }
-
-        // Put the species specific interactions first as they take priority
-        interactions.addAll(split.first.map {it.value})
-        interactions.addAll(split.second.map {it.value})
-
-        Cobblemon.LOGGER.info("Loaded {} Pokémon interaction sets", interactions.size)
+        speciesInteractions.clear()
+        generalInteractions.clear()
+        val split = data.entries.partition { it.value.requirements.any { requirement -> requirement is PokemonPropertiesRequirement && requirement.target.species != null } }
+        speciesInteractions.addAll(split.first.map {it.value})
+        generalInteractions.addAll(split.second.map {it.value})
+        Cobblemon.LOGGER.info("Loaded {} Pokémon interaction sets", data.size)
     }
 
     fun findInteraction(pokemon: PokemonEntity): PokemonInteraction? {
         val setCheck: (PokemonInteractionSet) -> Boolean = { it.requirements.all { req -> req.check(pokemon.pokemon) }}
         val interactionCheck: (PokemonInteraction) -> Boolean = { it.requirements.all { req -> req.check(pokemon.pokemon) } && !pokemon.pokemon.isOnInteractionCooldown(it.grouping)  }
-        return interactions
+        // species-specific interactions take priority
+        val validInteractions = speciesInteractions
             .filter(setCheck)
             .flatMap { it.interactions }
-            .firstOrNull(interactionCheck)
+            .filter(interactionCheck)
+            .toMutableList()
+        if (validInteractions.isEmpty()) { // if all species-specific interactions are absent/on cooldown, fallback to more generic ones
+            validInteractions.addAll(generalInteractions.filter(setCheck).flatMap { it.interactions }
+                .filter(interactionCheck)
+            )
+        }
+
+        return validInteractions.randomOrNull()
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/interaction/PokemonInteration.kt

@@ -15,11 +15,11 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.setup
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.sound.UnvalidatedPlaySoundS2CPacket
-import com.cobblemon.mod.common.pokemon.adapters.CobblemonRequirementAdapter
-import com.cobblemon.mod.common.util.*
-import com.google.gson.annotations.SerializedName
+import com.cobblemon.mod.common.util.asExpressionLike
+import com.cobblemon.mod.common.util.giveOrDropItemStack
+import com.cobblemon.mod.common.util.withPlayerValue
+import com.cobblemon.mod.common.util.withQueryValue
 import net.minecraft.core.registries.Registries
-import net.minecraft.network.FriendlyByteBuf
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.sounds.SoundSource
@@ -28,75 +28,30 @@ import net.minecraft.world.entity.EquipmentSlot
 import net.minecraft.world.entity.item.ItemEntity
 import net.minecraft.world.item.ItemStack
 
+/**
+ * A
+ */
 data class PokemonInteractionSet(
     val requirements: List<Requirement> = listOf(),
-    val interactions: List<PokemonInteraction> = listOf(),
-) {
-    fun encode(buffer: FriendlyByteBuf) {
-        buffer.writeCollection(requirements) { it, requirement ->
-            CobblemonRequirementAdapter.encode(requirement, it)
-        }
-        buffer.writeCollection(interactions) { it, interaction ->
-            interaction.encode(it)
-        }
-    }
-
-    companion object {
-        fun decode(buffer: FriendlyByteBuf): PokemonInteractionSet {
-            val requirements = buffer.readList(CobblemonRequirementAdapter::decode)
-            val interactions = buffer.readList(PokemonInteraction::decode)
-            return PokemonInteractionSet(requirements, interactions)
-        }
-    }
-}
-
+    val interactions: List<PokemonInteraction> = listOf()
+)
 data class PokemonInteraction(
     val grouping: ResourceLocation,
     val requirements: List<Requirement> = listOf(),
     val effects: List<InteractionEffect> = listOf(),
     val cooldown: ExpressionLike = "0".asExpressionLike()
-) {
-    fun encode(buffer: FriendlyByteBuf) {
-        buffer.writeResourceLocation(grouping)
-        buffer.writeCollection(requirements) { it, requirement ->
-            CobblemonRequirementAdapter.encode(requirement, it)
-        }
-        buffer.writeExpressionLike(cooldown)
-    }
-
-    companion object {
-        fun decode(buffer: FriendlyByteBuf): PokemonInteraction {
-            val grouping = buffer.readResourceLocation()
-            val requirements = buffer.readList { it ->
-                CobblemonRequirementAdapter.decode(it)
-            }
-
-            // No need to sync these for now
-            val effects = emptyList<InteractionEffect>()
-            val cooldown = buffer.readExpressionLike()
-
-            return PokemonInteraction(
-                grouping,
-                requirements,
-                effects,
-                cooldown,
-            )
-        }
-    }
-}
+)
 
 interface InteractionEffect {
     fun applyEffect(pokemon: PokemonEntity, player: ServerPlayer)
 }
 
-class DropItemEffect(val item: ResourceLocation, val amount: IntRange?) : InteractionEffect {
+class DropItemEffect(val item: ResourceLocation, val amount: IntRange?): InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException(
-            "Cannot load item with id: $item"
-        )
+        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException("Cannot load item with id: $item")
         val stack = ItemStack(item)
         stack.count = amount?.randomOrNull() ?: 1
         if (stack.isEmpty)
@@ -113,14 +68,12 @@ class DropItemEffect(val item: ResourceLocation, val amount: IntRange?) : Intera
     }
 }
 
-class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?) : InteractionEffect {
+class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?): InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException(
-            "Cannot load item with id: $item"
-        )
+        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(item) ?: throw IllegalArgumentException("Cannot load item with id: $item")
         val stack = ItemStack(item)
         stack.count = amount?.randomOrNull() ?: 1
         if (stack.isEmpty)
@@ -133,54 +86,25 @@ class GiveItemEffect(val item: ResourceLocation, val amount: IntRange?) : Intera
     }
 }
 
-class PlaySoundEffect(
-    val sound: ResourceLocation,
-    val soundSource: SoundSource?,
-    @SerializedName("playAround") private val _playAround: Boolean?,
-    @SerializedName("distance") private val _distance: Double?,
-    @SerializedName("volume") private val _volume: Float?,
-    @SerializedName("pitch") private val _pitch: Float?,
-) : InteractionEffect {
-
+class PlaySoundEffect(val sound: ResourceLocation, val soundSource: SoundSource?, val playAround: Boolean = true, val distance: Double = 64.0, val volume: Float = 1.0F, val pitch: Float = 1.0F): InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
     ) {
-        val packet = UnvalidatedPlaySoundS2CPacket(
-            sound,
-            soundSource ?: SoundSource.NEUTRAL,
-            pokemon.x,
-            pokemon.y,
-            pokemon.z,
-            volume,
-            pitch
-        )
-
+        val packet = UnvalidatedPlaySoundS2CPacket(sound, soundSource ?: SoundSource.NEUTRAL, pokemon.x, pokemon.y, pokemon.z, volume, pitch)
         if (playAround) {
-            packet.sendToPlayersAround(pokemon.x, pokemon.y, pokemon.z, distance, pokemon.level().dimension())
+            packet.sendToPlayersAround( pokemon.x, pokemon.y, pokemon.z, distance, pokemon.level().dimension())
         } else {
             packet.sendToPlayer(player)
         }
     }
 
-    val playAround: Boolean
-        get() = _playAround != false
-
-    val distance: Double
-        get() = _distance ?: 64.0
-
-    val volume: Float
-        get() = _volume ?: 1.0F
-
-    val pitch: Float
-        get() = _pitch ?: 1.0F
-
     companion object {
         val ID = "play_sound"
     }
 }
 
-class ShrinkItemEffect(val amount: Int = 1) : InteractionEffect {
+class ShrinkItemEffect(val amount: Int = 1): InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer
@@ -196,7 +120,7 @@ class ShrinkItemEffect(val amount: Int = 1) : InteractionEffect {
     }
 }
 
-class ScriptEffect(val script: ExpressionLike) : InteractionEffect {
+class ScriptEffect(val script: ExpressionLike): InteractionEffect {
     override fun applyEffect(
         pokemon: PokemonEntity,
         player: ServerPlayer

common/src/main/kotlin/com/cobblemon/mod/common/api/molang/MoLangFunctions.kt

@@ -311,7 +311,7 @@ object MoLangFunctions {
             runtime.environment.variable = params.environment.variable
             val args = params.params.subList(1, params.params.size)
             runtime.environment.context = ContextStruct(
-                (params.environment.context?.map ?: emptyMap()) + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
+                params.environment.context.map + args.mapIndexed { index, value -> "arg_${index + 1}" to value }.toMap()
             )
             val script = params.getString(0).asIdentifierDefaultingNamespace()
             // store the args in the
@@ -324,24 +324,13 @@ object MoLangFunctions {
             runtime.environment.context = params.environment.context
             val expression = params.getString(0).asExpressionLike()
             val delayInSeconds = params.getDoubleOrNull(1)?.toFloat() ?: 0.0f
-
-            fun evaluate(): MoValue {
-                return try {
-                    runtime.resolve(expression)
-                } catch (ex: Exception) {
-                    Cobblemon.LOGGER.warn("Failed to evaluate MoLang expression${if (delayInSeconds > 0.0f) " (delayed)" else ""}: $expression", ex)
-                    DoubleValue.ZERO
-                }
-            }
-
             if (delayInSeconds > 0.0f) {
                 val tracker = if (Cobblemon.implementation.environment() == Environment.SERVER) ServerTaskTracker else ClientTaskTracker
                 tracker.after(delayInSeconds) {
-                    evaluate()
+                    runtime.resolve(expression)
                 }
-                DoubleValue.ONE
             } else {
-                evaluate()
+                runtime.resolve(expression)
             }
         },
         "system_time_millis" to java.util.function.Function { _ ->
@@ -351,28 +340,23 @@ object MoLangFunctions {
         "date_local_time" to java.util.function.Function { _ ->
             val time = System.currentTimeMillis()
             val date = java.util.Date(time)
-            val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
+            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
             StringValue(formatted)
         },
         "date_of" to java.util.function.Function { params ->
             val time = params.getDouble(0).toLong()
             val date = java.util.Date(time)
-            val formatted = java.text.SimpleDateFormat("dd/MM/yyyy").format(date)
+            val formatted = java.text.SimpleDateFormat("DD/MM/YYYY").format(date)
             StringValue(formatted)
         },
         "date_is_after" to java.util.function.Function { params ->
             val dateA = params.getString(0)
             val dateB = params.getString(1)
-            val format = java.text.SimpleDateFormat("dd/MM/yyyy")
+            val format = java.text.SimpleDateFormat("DD/MM/YYYY")
             val a = format.parse(dateA)
             val b = format.parse(dateB)
             DoubleValue(a.after(b))
         },
-        "get_move_from_id" to java.util.function.Function { params ->
-            val moveId = params.getString(0)
-            val moveTemplate = Moves.getByName(moveId)
-            return@Function moveTemplate?.struct ?: DoubleValue.ZERO
-        },
         "create_simple_party_provider" to java.util.function.Function { params ->
             val partyProvider = SimplePartyProvider()
             return@Function partyProvider.struct
@@ -383,13 +367,6 @@ object MoLangFunctions {
             val pickupItem = ObtainableItem(item = item, pickupPriority = pickupPriority)
             return@Function pickupItem.struct
         },
-        "create_itemstack" to java.util.function.Function { params ->
-            val itemId = params.getString(0).asIdentifierDefaultingNamespace()
-            val item = BuiltInRegistries.ITEM.get(itemId) ?: return@Function DoubleValue.ZERO
-            val count = params.getIntOrNull(1) ?: 1
-            val itemStack = ItemStack(item, count)
-            return@Function ObjectValue(itemStack)
-        },
         "file" to java.util.function.Function { MoLangLoadedFilesCache.struct }
     )
     val biomeFunctions = mutableListOf<(Holder<Biome>) -> HashMap<String, java.util.function.Function<MoParams, Any>>>()
@@ -595,62 +572,6 @@ object MoLangFunctions {
                 }
                 return@put items
             }
-            map.put("has_inventory_space") { _ ->
-                val inventory = player.inventory
-                return@put if (inventory.getFreeSlot() != -1) DoubleValue.ONE else DoubleValue.ZERO
-            }
-            map.put("set_inventory_slot") { params ->
-                val slot = params.getInt(0)
-                val inventory = player.inventory
-                if (slot !in 0 until inventory.containerSize) return@put DoubleValue.ZERO
-
-                val value = params.getOrNull<MoValue>(1) ?: return@put DoubleValue.ZERO
-
-                val stack: ItemStack? = when (value) {
-                    is ObjectValue<*> -> value.obj as? ItemStack
-                    is StringValue -> {
-                        val id = ResourceLocation.parse(value.value)
-                        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id) ?: return@put DoubleValue.ZERO
-                        ItemStack(item)
-                    }
-                    else -> null
-                }
-
-                if (stack == null) return@put DoubleValue.ZERO
-
-                inventory.setItem(slot, stack)
-                return@put DoubleValue.ONE
-            }
-            map.put("give_item") { params ->
-                val inventory = player.inventory
-                val freeSlot = inventory.getFreeSlot()
-                val value = params.getOrNull<MoValue>(0) ?: return@put DoubleValue.ZERO
-                val dropIfFull = params.getBooleanOrNull(1) ?: false
-
-                val stack: ItemStack? = when (value) {
-                    is ObjectValue<*> -> value.obj as? ItemStack
-                    is StringValue -> {
-                        val id = ResourceLocation.parse(value.value)
-                        val item = player.registryAccess().registryOrThrow(Registries.ITEM).get(id) ?: return@put DoubleValue.ZERO
-                        ItemStack(item)
-                    }
-                    else -> null
-                }
-
-                if (stack == null) return@put DoubleValue.ZERO
-
-                if (freeSlot == -1) {
-                    if (dropIfFull) {
-                        player.drop(stack, false)
-                        return@put DoubleValue.ONE
-                    } else {
-                        return@put DoubleValue.ZERO
-                    }
-                }
-
-                inventory.setItem(freeSlot, stack)
-                return@put DoubleValue.ONE
-            }
             map.put("face") { params -> ObjectValue(PlayerDialogueFaceProvider(player.uuid, params.getBooleanOrNull(0) != false)) }
             map.put("swing_hand") { _ -> player.swing(player.usedItemHand) }
             map.put("food_level") { _ -> DoubleValue(player.foodData.foodLevel) }
@@ -694,7 +615,8 @@ object MoLangFunctions {
                 }
                 map.put("active_dialogue") { _ ->
                     if (player.isInDialogue) {
-                        return@put player.activeDialogue?.toMoLangStruct() ?: DoubleValue.ZERO
+                        player.activeDialogue?.dialogueId.toString()
+                        return@put DoubleValue.ONE
                     } else {
                         DoubleValue.ZERO
                     }
@@ -857,20 +779,6 @@ object MoLangFunctions {
                     battleStartResult.ifSuccessful { returnValue = it.struct }
                     return@put returnValue
                 }
-                map.put("get_custom_stat") { params ->
-                    val statName = params.getString(0)
-
-                    val resourceLocation = ResourceLocation.tryParse(statName) ?: return@put DoubleValue.ZERO
-                    val statResourceLocation = BuiltInRegistries.CUSTOM_STAT.get(resourceLocation) ?: return@put DoubleValue.ZERO
-
-                    val exists = net.minecraft.stats.Stats.CUSTOM.contains(statResourceLocation)
-                    if (!exists) return@put DoubleValue.ZERO
-
-                    val stat = net.minecraft.stats.Stats.CUSTOM.get(statResourceLocation)
-                    val value = player.stats.getValue(stat)
-
-                    DoubleValue(value)
-                }
             }
             map
         }
@@ -1831,35 +1739,22 @@ object MoLangFunctions {
                 pokemon.removeCosmeticItem()
             }
             map.put("add_marks") { params ->
-                var appliedMark = false
                 for (param in params.params) {
                     val identifier = param.asString().asIdentifierDefaultingNamespace()
                     val mark = Marks.getByIdentifier(identifier)
-                    if (mark != null) {
-                        pokemon.exchangeMark(mark, true)
-                        appliedMark = true
-                    }
+                    if (mark != null) pokemon.exchangeMark(mark, true)
                 }
-
-                DoubleValue(appliedMark)
             }
             map.put("add_marks_with_chance") { params ->
-                var appliedMark = false
                 for (param in params.params) {
                     val identifier = param.asString().asIdentifierDefaultingNamespace()
                     val mark = Marks.getByIdentifier(identifier)
-
                     mark?.let {
                         val probability = it.chance.coerceIn(0F, 1F) * 100
                         val randomValue = Random.nextDouble(0.0, 100.0)
-                        if (randomValue < probability) {
-                            pokemon.exchangeMark(it, true)
-                            appliedMark = true
-                        }
+                        if (randomValue < probability) pokemon.exchangeMark(it, true)
                     }
                 }
-
-                DoubleValue(appliedMark)
             }
             map.put("add_potential_marks") { params ->
                 for (param in params.params) {
@@ -2815,8 +2710,8 @@ object MoLangFunctions {
                 }
                 variable
             }
-            else -> VariableStruct()
-        }
+            else -> null
+        } ?: throw IllegalArgumentException("Invalid NBT element type: ${nbt.type}")
     }
 }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/moves/MoveTemplate.kt

@@ -58,15 +58,12 @@ open class MoveTemplate(
     val struct: MoStruct by lazy {
         QueryStruct(hashMapOf())
             .addFunction("name") { StringValue(name) }
-            .addFunction("display_name") { StringValue(displayName.string) }
-            .addFunction("description") { StringValue(description.string) }
             .addFunction("type") { StringValue(elementalType.showdownId) }
             .addFunction("damage_category") { StringValue(damageCategory.name) }
             .addFunction("power") { DoubleValue(power) }
             .addFunction("target") { StringValue(target.name) }
             .addFunction("accuracy") { DoubleValue(accuracy) }
             .addFunction("pp") { DoubleValue(pp) }
-            .addFunction("max_pp") { DoubleValue(maxPp) }
             .addFunction("priority") { DoubleValue(priority) }
             .addFunction("crit_ratio") { DoubleValue(critRatio) }
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/feature/ChoiceSpeciesFeatureProvider.kt

@@ -80,9 +80,7 @@ open class ChoiceSpeciesFeatureProvider(
 
     internal constructor(): this(emptyList())
 
-    override fun get(pokemon: Pokemon): StringSpeciesFeature? {
-        return pokemon.features.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
-    }
+    override fun get(pokemon: Pokemon) = pokemon.getFeature<StringSpeciesFeature>(keys.first())
 
     override fun invoke(pokemon: Pokemon): StringSpeciesFeature? {
         val existing = get(pokemon)
@@ -103,15 +101,15 @@ open class ChoiceSpeciesFeatureProvider(
     }
 
     override fun invoke(nbt: CompoundTag): StringSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return StringSpeciesFeature(key, "").also { it.loadFromNBT(nbt) }
+        return if (nbt.contains(keys.first())) {
+            StringSpeciesFeature(keys.first(), "").also { it.loadFromNBT(nbt) }
+        } else null
     }
 
     override fun invoke(json: JsonObject): StringSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return StringSpeciesFeature(key, "").also { it.loadFromJSON(json) }
+        return if (json.has(keys.first())) {
+            StringSpeciesFeature(keys.first(), "").also { it.loadFromJSON(json) }
+        } else null
     }
 
     override fun fromString(value: String?): StringSpeciesFeature? {
@@ -133,7 +131,7 @@ open class ChoiceSpeciesFeatureProvider(
 
     override fun provide(properties: PokemonProperties): Set<String> {
         return if (isAspect) {
-            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name in keys }
+            val feature = properties.customProperties.filterIsInstance<StringSpeciesFeature>().find { it.name == keys.first() }
             if (feature != null) {
                 setOf(getAspect(feature))
             } else {

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/feature/FlagSpeciesFeature.kt

@@ -132,9 +132,7 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
 
     constructor(vararg keys: String) : this(keys.toList())
 
-    override fun get(pokemon: Pokemon): FlagSpeciesFeature? {
-        return pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-    }
+    override fun get(pokemon: Pokemon) = pokemon.getFeature<FlagSpeciesFeature>(keys.first())
 
     override fun invoke(pokemon: Pokemon): FlagSpeciesFeature? {
         return get(pokemon)
@@ -146,15 +144,15 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
     }
 
     override fun invoke(nbt: CompoundTag): FlagSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return FlagSpeciesFeature(key, false).also { it.loadFromNBT(nbt) }
+        return if (nbt.contains(keys.first())) {
+            FlagSpeciesFeature(keys.first(), false).also { it.loadFromNBT(nbt) }
+        } else null
     }
 
     override fun invoke(json: JsonObject): FlagSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return FlagSpeciesFeature(key, false).also { it.loadFromJSON(json) }
+        return if (json.has(keys.first())) {
+            FlagSpeciesFeature(keys.first(), false).also { it.loadFromJSON(json) }
+        } else null
     }
 
     override fun fromString(value: String?): FlagSpeciesFeature? {
@@ -172,26 +170,16 @@ class FlagSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<FlagSpecie
     }
 
     override fun provide(pokemon: Pokemon): Set<String> {
-        return if (isAspect) {
-            val feature = pokemon.features.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-            if (feature != null && feature.enabled) {
-                setOf(keys.first())
-            } else {
-                emptySet()
-            }
+        return if (isAspect && pokemon.getFeature<FlagSpeciesFeature>(keys.first())?.enabled == true) {
+            setOf(keys.first())
         } else {
             emptySet()
         }
     }
 
     override fun provide(properties: PokemonProperties): Set<String> {
-        return if (isAspect) {
-            val feature = properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name in keys }
-            if (feature != null && feature.enabled) {
-                setOf(keys.first())
-            } else {
-                emptySet()
-            }
+        return if (isAspect && properties.customProperties.filterIsInstance<FlagSpeciesFeature>().find { it.name == keys.first() }?.enabled == true) {
+            setOf(keys.first())
         } else {
             emptySet()
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/feature/IntSpeciesFeature.kt

@@ -142,15 +142,19 @@ class IntSpeciesFeatureProvider : SynchronizedSpeciesFeatureProvider<IntSpeciesF
     }
 
     override fun invoke(nbt: CompoundTag): IntSpeciesFeature? {
-        val key = keys.find { nbt.contains(it) }
-        if (key == null) return null
-        return IntSpeciesFeature(keys.first(), nbt.getInt(key));
+        return if (nbt.contains(keys.first())) {
+            IntSpeciesFeature(keys.first(), nbt.getInt(keys.first()))
+        } else {
+            null
+        }
     }
 
     override fun invoke(json: JsonObject): IntSpeciesFeature? {
-        val key = keys.find { json.has(it) }
-        if (key == null) return null
-        return IntSpeciesFeature(keys.first(), json.get(key).asInt)
+        return if (json.has(keys.first())) {
+            IntSpeciesFeature(keys.first(), json.get(keys.first()).asInt)
+        } else {
+            null
+        }
     }
 
     override fun get(pokemon: Pokemon) = pokemon.features.filterIsInstance<IntSpeciesFeature>().find { it.name in keys }

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/feature/SpeciesFeatures.kt

@@ -102,12 +102,6 @@ object SpeciesFeatures : JsonDataRegistry<SpeciesFeatureProvider<*>> {
 
     @JvmStatic
     fun register(name: String, provider: SpeciesFeatureProvider<*>) = register(name, provider, isCoded = true)
-
-    @JvmStatic
-    fun registerType(key: String, clazz: Class<out SpeciesFeatureProvider<*>>) {
-        types[key] = clazz
-    }
-
     private fun registerFromAssets(identifier: ResourceLocation, provider: SpeciesFeatureProvider<*>) = register(identifier.path, provider, isCoded = false)
 
     @JvmStatic

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/requirement/OwnerQueryRequirement.kt

@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.entity.npc.NPCEntity
 import com.cobblemon.mod.common.pokemon.Pokemon
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.world.entity.LivingEntity
-import net.minecraft.world.entity.player.Player
 
 /**
  * A [Requirement] that expects a [LivingEntity] to be attached to the [Pokemon].
@@ -27,7 +26,7 @@ interface OwnerQueryRequirement : Requirement {
     override fun check(pokemon: Pokemon): Boolean {
         val owner = pokemon.getOwnerEntity() ?: return false
         return when (owner) {
-            is Player -> {
+            is ServerPlayer -> {
                 this.checkPlayer(pokemon, owner)
             }
             is NPCEntity -> {
@@ -38,13 +37,13 @@ interface OwnerQueryRequirement : Requirement {
     }
 
     /**
-     * Checks if the given [Pokemon] & [Player] satisfies the requirement.
+     * Checks if the given [Pokemon] & [ServerPlayer] satisfies the requirement.
      *
      * @param pokemon The [Pokemon] being queried.
-     * @param owner The [Player] that owns this [Pokemon].
+     * @param owner The [ServerPlayer] that owns this [Pokemon].
      * @return If the requirement was satisfied.
      */
-    fun checkPlayer(pokemon: Pokemon, owner: Player): Boolean
+    fun checkPlayer(pokemon: Pokemon, owner: ServerPlayer): Boolean
 
     /**
      * Checks if the given [Pokemon] & [NPCEntity] satisfies the requirement.

common/src/main/kotlin/com/cobblemon/mod/common/api/reactive/EventObservables.kt

@@ -11,7 +11,6 @@ package com.cobblemon.mod.common.api.reactive
 import com.cobblemon.mod.common.api.events.Cancelable
 
 open class EventObservable<T> : SimpleObservable<T>() {
-    @JvmOverloads
     inline fun post(vararg events: T, then: (T) -> Unit = {}) {
         // Issuing generic-typed pass-throughs to varargs doesn't work
         // properly unless the source is a vararg as well, complicated story.

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/composite/strategies/CompositeRidingStrategy.kt

@@ -41,6 +41,10 @@ interface CompositeRidingStrategy<T : CompositeSettings> {
         toState: RidingBehaviourState,
         toSettings: RidingBehaviourSettings
     ) {
+        if (vehicle.level().isClientSide) {
+            val fromSettings = if (settings.defaultBehaviour == toSettings) settings.alternateBehaviour else settings.defaultBehaviour
+
+        }
         toState.stamina.set(fromState.stamina.get())
         toState.rideVelocity.set(fromState.rideVelocity.get())
         fromState.reset()

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/land/HorseBehaviour.kt

@@ -187,16 +187,17 @@ class HorseBehaviour : RidingBehaviour<HorseSettings, HorseState> {
             return
         }
 
-
+        var newStam = stam
         val stamDrainRate = (1.0f / vehicle.runtime.resolveDouble(settings.staminaExpr ?: globalHorse.staminaExpr!!)).toFloat() / 20.0f
 
-        val newStam = if (state.sprinting.get()) {
-            max(0.0f,stam - stamDrainRate)
+        if (state.sprinting.get()) {
+            newStam = max(0.0f,stam - stamDrainRate)
+
         } else {
-            min(1.0f,stam + stamDrainRate * 4)
+            newStam = min(1.0f,stam + stamDrainRate * 4)
         }
 
-        state.stamina.set(newStam.coerceIn(0F, 1F))
+        state.stamina.set(newStam)
     }
 
     override fun updatePassengerRotation(

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/behaviour/types/liquid/DolphinBehaviour.kt

@@ -100,7 +100,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         driver: Player,
         input: Vec3
     ) {
-        if (vehicle.level().isClientSide) {
+        if(vehicle.level().isClientSide) {
             handleBoosting(state, vehicle)
             tickStamina(settings, state, vehicle)
         }
@@ -147,7 +147,7 @@ class DolphinBehaviour : RidingBehaviour<DolphinSettings, DolphinState> {
         val stamDrainRate = (1.0f / boostTime).toFloat()
 
         val newStam = if (state.boosting.get()) max(0.0f,stam - stamDrainRate)
-            else (stam + stamDrainRate).coerceIn(0F, 1F)
+            else min(1.0f,stam + stamDrainRate)
 
         state.stamina.set(newStam)
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/sound/RideLoopSound.kt

@@ -12,7 +12,6 @@ package com.cobblemon.mod.common.api.riding.sound
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeState
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.getIsSubmerged
 import com.cobblemon.mod.common.util.resolveDouble
 import net.minecraft.client.Minecraft
 import net.minecraft.client.resources.sounds.AbstractTickableSoundInstance
@@ -66,21 +65,6 @@ class RideLoopSound(val ride: PokemonEntity, val soundSettings: RideSoundSetting
             return
         }
 
-        // Mute the sound if it's not meant to play for the passenger
-        if (this.isPassenger && !this.soundSettings.playForPassengers) {
-            this.volume = 0.0f
-            return
-        }
-
-        // Mute sounds when submerged unless they support underwater sounds, underwater sounds don't play above water
-        if (this.ride.getIsSubmerged() && !this.soundSettings.submerged) {
-            this.volume = 0.0f
-            return
-        } else if (!this.ride.getIsSubmerged() && this.soundSettings.submerged) {
-            this.volume = 0.0f
-            return
-        }
-
         // Perform data driven pitch and volume calculation
         this.volume = ((soundSettings.volumeExpr.let { ride.runtime.resolveDouble(it) })).toFloat()
         this.volume *= this.fade

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/sound/RidingSoundSettings.kt

@@ -27,9 +27,7 @@ data class RideSoundSettings(
     val soundLocation: ResourceLocation,
     @SerializedName("volumeExpr") private val _volumeExpr: Expression? = "1.0".asExpression(),
     @SerializedName("pitchExpr") private val _pitchExpr: Expression? = "1.0".asExpression(),
-    val playForPassengers: Boolean = true,
     val playForNonPassengers: Boolean = false,
-    val submerged: Boolean = false,
     val muffleEnabled: Boolean = false,
     @SerializedName("attenuationModel") private val _attenuationModel: RideAttenuationModel? = RideAttenuationModel.NONE
 ): Encodable {
@@ -48,9 +46,7 @@ data class RideSoundSettings(
         buffer.writeResourceLocation(soundLocation)
         buffer.writeExpression(volumeExpr)
         buffer.writeExpression(pitchExpr)
-        buffer.writeBoolean(playForPassengers)
         buffer.writeBoolean(playForNonPassengers)
-        buffer.writeBoolean(submerged)
         buffer.writeBoolean(muffleEnabled)
         buffer.writeEnum(attenuationModel)
     }
@@ -61,9 +57,7 @@ data class RideSoundSettings(
             val soundLocation = buffer.readResourceLocation()
             val volumeExpr = buffer.readExpression()
             val pitchExpr = buffer.readExpression()
-            val playForPassengers = buffer.readBoolean()
             val playForNonPassengers = buffer.readBoolean()
-            val submerged = buffer.readBoolean()
             val muffleEnabled = buffer.readBoolean()
             val attenuationModel = buffer.readEnum(RideAttenuationModel::class.java)
 
@@ -71,9 +65,7 @@ data class RideSoundSettings(
                 soundLocation,
                 volumeExpr,
                 pitchExpr,
-                playForPassengers,
                 playForNonPassengers,
-                submerged,
                 muffleEnabled,
                 attenuationModel
             )

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/influence/SpawnBaitInfluence.kt

@@ -26,7 +26,7 @@ import net.minecraft.world.entity.Entity
 /**
  * A [SpawningInfluence] that applies some number of SpawnBait effects.
  *
- * @author Hiroku, Plastered_Crab, ppVon
+ * @author Hiroku, Plastered_Crab
  * @since March 18th, 2025
  */
 open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (time: Int, entity: PokemonEntity?) -> Unit = { _, _ -> }) : SpawningInfluence {
@@ -50,84 +50,85 @@ open class SpawnBaitInfluence(val effects: List<SpawnBait.Effect>, val onUsed: (
         }
     }
 
-    // EV, Type, and Egg Group related bait effects
+    // EV related bait effects
     override fun affectWeight(detail: SpawnDetail, spawnablePosition: SpawnablePosition, weight: Float): Float {
         val merged = SpawnBaitUtils.mergeEffects(effects)
 
-        val hasRelevantEffects =
-            merged.any { it.type == Effects.EV } ||
-            merged.any { it.type == Effects.TYPING } ||
-            merged.any { it.type == Effects.EGG_GROUP }
-
-        if (!hasRelevantEffects) {
-            return super.affectWeight(detail, spawnablePosition, weight)
-        }
-
-        val pokemonDetail = detail as? PokemonSpawnDetail
-            ?: return super.affectWeight(detail, spawnablePosition, weight)
-
-        val detailSpecies = pokemonDetail.pokemon.species
-            ?.let { PokemonSpecies.getByName(it) }
-            ?: return super.affectWeight(detail, spawnablePosition, weight)
-
-        val formData = detailSpecies.getForm(pokemonDetail.pokemon.aspects)
-
-        var newWeight = weight
-        var used = false
-
         // if bait exists and any effects are related to EV yields
-        if (merged.any { it.type == Effects.EV }) {
-            val evEffect = effects.firstOrNull { it.type == Effects.EV }
-            val baitEVStat = evEffect?.subcategory?.path?.let { Stats.getStat(it) }
+        if (merged.any { it.type == Effects.EV }){
+            if (detail is PokemonSpawnDetail) {
+                val detailSpecies = detail.pokemon.species?.let { PokemonSpecies.getByName(it) }
+                val baitEVStat = effects.firstOrNull { it.type == Effects.EV }?.subcategory?.path?.let { Stats.getStat(it) }
 
-            if (baitEVStat != null) {
-                val evYieldValue = formData.evYield[baitEVStat]?.toFloat() ?: 0f
-                used = true
-
-                if (evYieldValue <= 0f) {
-                    newWeight = 0f
-                } else {
-                    LOGGER.debug("Boosted weight value");
+                if (detailSpecies != null && baitEVStat != null) {
+                    val detailAspects = detail.pokemon.aspects
+                    val formData = detailSpecies.getForm(detailAspects)
+                    val evYieldValue = formData.evYield[baitEVStat]?.toFloat() ?: 0f
+                    return when {
+                        evYieldValue > 0 -> {
+                            markUsed()
+                            super.affectWeight(detail, spawnablePosition, weight)
+                        }
+                        else -> {
+                            markUsed()
+                            super.affectWeight(detail, spawnablePosition, 0f)
+                        }
+                    }
                 }
             }
         }
-
         // if bait exists and any effects are related to Typing
-        if (newWeight > 0f && merged.any { it.type == Effects.TYPING }) {
-            val baitEffect = effects.firstOrNull { it.type == Effects.TYPING }
-            val baitTypingEffect = baitEffect?.subcategory?.path?.let { ElementalTypes.get(it) }
+        if (merged.any { it.type == Effects.TYPING }){
+            if (detail is PokemonSpawnDetail) {
+                val detailSpecies = detail.pokemon.species?.let { PokemonSpecies.getByName(it) }
+                val baitEffect = effects.firstOrNull { it.type == Effects.TYPING }
+                val baitTypingEffect = baitEffect?.subcategory?.path?.let { ElementalTypes.get(it) }
 
-            if (baitEffect != null && baitTypingEffect != null) {
-                val isMatchingType = formData.types.contains(baitTypingEffect)
-                used = true
-
-                if (isMatchingType) {
-                    newWeight *= baitEffect.value.toFloat()
+                if (detailSpecies != null && baitTypingEffect != null) {
+                    val detailAspects = detail.pokemon.aspects
+                    val formData = detailSpecies.getForm(detailAspects)
+                    val isMatchingType = formData.types.contains(baitTypingEffect)
+                    return when {
+                        isMatchingType -> {
+                            markUsed()
+                            super.affectWeight(detail, spawnablePosition, weight * baitEffect.value.toFloat())
+                        }
+                        else -> super.affectWeight(detail, spawnablePosition, weight)
+                    }
                 }
             }
         }
-
         // if bait exists and any effects are related to Egg Groups
-        if (newWeight > 0f && merged.any { it.type == Effects.EGG_GROUP }) {
-            val eggGroupEffects = effects.filter { it.type == Effects.EGG_GROUP }
+        if (merged.any { it.type == Effects.EGG_GROUP }) {
+            if (detail is PokemonSpawnDetail) {
+                val detailSpecies = detail.pokemon.species?.let { PokemonSpecies.getByName(it) }
 
-            val matchingEffect = eggGroupEffects.firstOrNull { effect ->
-                val key = effect.subcategory?.path ?: return@firstOrNull false
-                val eggGroup = EggGroup.fromIdentifier(key)
-                if (eggGroup == null) {
-                    LOGGER.warn("Unknown egg group identifier: $key")
-                    return@firstOrNull false
+                if (detailSpecies != null) {
+                    val detailAspects = detail.pokemon.aspects
+                    val formData = detailSpecies.getForm(detailAspects)
+
+                    // Collect all the egg group effects
+                    val eggGroupEffects = effects.filter { it.type == Effects.EGG_GROUP }
+
+                    // Check if any of the egg group effects match the species' egg groups
+                    val matchingEffect = eggGroupEffects.firstOrNull { effect ->
+                        val effectEggGroupKey = effect.subcategory?.path ?: return@firstOrNull false
+                        val eggGroup = EggGroup.fromIdentifier(effectEggGroupKey)
+                        if (eggGroup == null) {
+                            LOGGER.warn("Unknown egg group identifier: $effectEggGroupKey")
+                            return@firstOrNull false
+                        }
+                        formData.eggGroups.contains(eggGroup)
+                    }
+
+                    if (matchingEffect != null) {
+                        markUsed()
+                        val multiplier = matchingEffect.value
+                        return super.affectWeight(detail, spawnablePosition, (weight * multiplier).toFloat())
+                    }
                 }
-                formData.eggGroups.contains(eggGroup)
-            }
-
-            if (matchingEffect != null) {
-                used = true
-                newWeight *= matchingEffect.value.toFloat()
             }
         }
-
-        if (used) markUsed()
-        return super.affectWeight(detail, spawnablePosition, newWeight)
+        return super.affectWeight(detail, spawnablePosition, weight)
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/stats/CobblemonStats.kt

@@ -8,58 +8,30 @@
 
 package com.cobblemon.mod.common.api.stats
 
-import com.cobblemon.mod.common.Cobblemon
-import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.stats.StatFormatter
 
 object CobblemonStats {
-    val stats = mutableMapOf<String, CobblemonStat>()
+    val stats = mutableMapOf<String,  ResourceLocation>()
 
-    @JvmField
-    var CAPTURED: CobblemonStat = CobblemonStat("captured")
-    @JvmField
-    val SHINIES_CAPTURED: CobblemonStat = CobblemonStat("shinies_captured")
-    @JvmField
-    val RELEASED: CobblemonStat = CobblemonStat("released")
-    @JvmField
-    val EVOLVED: CobblemonStat = CobblemonStat("evolved")
-    @JvmField
-    val LEVEL_UP: CobblemonStat = CobblemonStat("level_up")
-    @JvmField
-    val BATTLES_WON: CobblemonStat = CobblemonStat("battles_won")
-    @JvmField
-    val BATTLES_LOST: CobblemonStat = CobblemonStat("battles_lost")
-    @JvmField
-    val BATTLES_FLED: CobblemonStat = CobblemonStat("battles_fled")
-    @JvmField
-    val BATTLES_TOTAL: CobblemonStat = CobblemonStat("battles_total")
-    @JvmField
-    val DEX_ENTRIES: CobblemonStat = CobblemonStat("dex_entries")
-    @JvmField
-    val EGGS_COLLECTED: CobblemonStat = CobblemonStat("eggs_collected")
-    @JvmField
-    val EGGS_HATCHED: CobblemonStat = CobblemonStat("eggs_hatched")
-    @JvmField
-    val TRADED: CobblemonStat = CobblemonStat("traded")
-    @JvmField
-    val FOSSILS_REVIVED: CobblemonStat = CobblemonStat("fossils_revived")
-    @JvmField
-    val TIMES_RIDDEN: CobblemonStat = CobblemonStat("times_ridden")
-    @JvmField
-    val ROD_CASTS: CobblemonStat = CobblemonStat("rod_casts")
-    @JvmField
-    val REEL_INS: CobblemonStat = CobblemonStat("reel_ins")
-    @JvmField
-    val POKEMON_INTERACTED_WITH: CobblemonStat = CobblemonStat("pokemon_interacted_with")
-    @JvmField
-    val RIDING_LAND: CobblemonStat = CobblemonStat("riding_land", StatFormatter.DISTANCE)
-    @JvmField
-    val RIDING_AIR: CobblemonStat = CobblemonStat("riding_air", StatFormatter.DISTANCE)
-    @JvmField
-    val RIDING_LIQUID: CobblemonStat = CobblemonStat("riding_liquid", StatFormatter.DISTANCE)
-
-    //TODO block, stats (interact, gimmi)
+    var CAPTURED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "captured") //makeCustomStat("captured", StatFormatter.DEFAULT)
+    val SHINIES_CAPTURED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "shinies_captured") //makeCustomStat("shinies_captured", StatFormatter.DEFAULT)
+    val RELEASED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "released") //makeCustomStat("released", StatFormatter.DEFAULT)
+    val EVOLVED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "evolved") //makeCustomStat("evolved", StatFormatter.DEFAULT)
+    val LEVEL_UP: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "level_up") //makeCustomStat("level_up", StatFormatter.DEFAULT)
+    val BATTLES_WON: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_won") //makeCustomStat("battles_won", StatFormatter.DEFAULT)
+    val BATTLES_LOST: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_lost") //makeCustomStat("battles_lost", StatFormatter.DEFAULT)
+    val BATTLES_FLED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_fled") //makeCustomStat("battles_fled", StatFormatter.DEFAULT)
+    val BATTLES_TOTAL: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "battles_total") //makeCustomStat("battles_total", StatFormatter.DEFAULT)
+    val DEX_ENTRIES: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "dex_entries") //makeCustomStat("dex_entries", StatFormatter.DEFAULT)
+    val EGGS_COLLECTED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "eggs_collected") //makeCustomStat("eggs_collected", StatFormatter.DEFAULT)
+    val EGGS_HATCHED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "eggs_hatched") //makeCustomStat("eggs_hatched", StatFormatter.DEFAULT)
+    val TRADED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "traded") //makeCustomStat("traded", StatFormatter.DEFAULT)
+    val FOSSILS_REVIVED: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "fossils_revived") //makeCustomStat("fossils_revived", StatFormatter.DEFAULT)
+    val TIMES_RIDDEN: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "times_ridden")
+    val ROD_CASTS: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "rod_casts")
+    val REEL_INS: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "reel_ins")
+    val POKEMON_INTERACTED_WITH: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", "pokemon_interacted_with") //makeCustomStat("pokemon_interacted_with", StatFormatter.DEFAULT)
+    //TODO block, stats (interact, gimmi), riding (styles?)
 
     fun registerStats() {
         stats["captured"] = CAPTURED
@@ -80,22 +52,5 @@ object CobblemonStats {
         stats["rod_casts"] = ROD_CASTS
         stats["reel_ins"] = REEL_INS
         stats["pokemon_interacted_with"] = POKEMON_INTERACTED_WITH
-        stats["riding_land"] = RIDING_LAND
-        stats["riding_air"] = RIDING_AIR
-        stats["riding_liquid"] = RIDING_LIQUID
-    }
-
-    @JvmStatic
-    fun getStat(cobblemonStat: CobblemonStat) : ResourceLocation {
-        val resourceLocation = cobblemonStat.resourceLocation
-        val stat = BuiltInRegistries.CUSTOM_STAT.get(resourceLocation)
-        if (stat == null) {
-            Cobblemon.LOGGER.error("Could not find stat with id {}", resourceLocation)
-        }
-        return stat ?: throw NullPointerException("Could not find stat with id $resourceLocation")
-    }
-
-    data class CobblemonStat(val path: String, val formatter: StatFormatter = StatFormatter.DEFAULT) {
-        val resourceLocation: ResourceLocation = ResourceLocation.fromNamespaceAndPath("cobblemon", path);
     }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/party/PartyStore.kt

@@ -258,22 +258,17 @@ open class PartyStore(override val uuid: UUID) : PokemonStore<PartyPosition>() {
 
     @JvmOverloads
     fun toBattleTeam(clone: Boolean = false, healPokemon: Boolean = false, leadingPokemon: UUID? = null) : List<BattlePokemon> {
-        var leadingPokemonId = leadingPokemon
         val result = this.mapNotNull {
             return@mapNotNull if (clone) {
-                BattlePokemon.safeCopyOf(it).also { copy ->
-                    if (leadingPokemon != null && it.uuid == leadingPokemonId) {
-                        leadingPokemonId = copy.uuid
-                    }
-                }
+                BattlePokemon.safeCopyOf(it)
             } else {
                 BattlePokemon.playerOwned(it)
             }.also { if (healPokemon) it.effectedPokemon.heal() }
         }.toMutableList()
 
         // reposition lead to front of the party
-        if (leadingPokemonId != null && result.first().uuid != leadingPokemonId) {
-            result.find { it.uuid == leadingPokemonId }?.let { lead ->
+        if (leadingPokemon != null && result.first().uuid != leadingPokemon) {
+            result.find { it.uuid == leadingPokemon }?.let { lead ->
                 result.remove(lead)
                 result.add(0, lead)
             }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/party/PlayerPartyStore.kt

@@ -154,12 +154,12 @@ open class PlayerPartyStore(
 
                 // Metabolism for Fullness
                 if (pokemon.currentFullness > 0) {
-                    pokemon.tickMetabolism(20)
+                    pokemon.tickMetabolism()
                 }
 
                 // Interaction Cooldown
                 if (pokemon.interactionCooldowns.any()) {
-                    pokemon.tickInteractionCooldown(20)
+                    pokemon.tickInteractionCooldown()
                 }
 
                 pokemon.features.filterIsInstance<TickingSpeciesFeature>().forEach { it.onSecondPassed(player.serverLevel(), pokemon, null) }

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/GeneralPlayerData.kt

@@ -28,7 +28,6 @@ data class GeneralPlayerData(
     var starterUUID: UUID?,
     var keyItems: MutableSet<ResourceLocation>,
     var battleTheme: ResourceLocation?,
-    var partySelectTutorialDone: Boolean = false,
     val extraData: MutableMap<String, PlayerDataExtension>,
 ) : InstancedPlayerData {
     var advancementData: PlayerAdvancementData = PlayerAdvancementData()
@@ -54,8 +53,7 @@ data class GeneralPlayerData(
             starterSelected,
             starterUUID,
             advancementData.totalBattleVictoryCount == 0,
-            battleTheme,
-            partySelectTutorialDone
+            battleTheme
         )
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/PlayerDataJsonBackend.kt

@@ -36,8 +36,7 @@ class PlayerDataJsonBackend: JsonBackedPlayerDataStoreBackend<GeneralPlayerData>
         starterUUID =  null,
         keyItems = Cobblemon.config.defaultKeyItems,
         extraData = mutableMapOf(),
-        battleTheme = CobblemonSounds.PVP_BATTLE.location,
-        partySelectTutorialDone = false
+        battleTheme = CobblemonSounds.PVP_BATTLE.location
     )}
 
     override val gson = GsonBuilder()

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/PlayerDataMongoBackend.kt

@@ -37,8 +37,7 @@ class PlayerDataMongoBackend(mongoClient: MongoClient, databaseName: String, col
         starterUUID =  null,
         keyItems = Cobblemon.config.defaultKeyItems,
         extraData = mutableMapOf(),
-        battleTheme = CobblemonSounds.PVP_BATTLE.location,
-        partySelectTutorialDone = false
+        battleTheme = CobblemonSounds.PVP_BATTLE.location
     )}
 
     override val gson = GsonBuilder()

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/client/ClientGeneralPlayerData.kt

@@ -34,8 +34,7 @@ data class ClientGeneralPlayerData(
     var starterSelected: Boolean = false,
     var starterUUID: UUID? = null,
     var showChallengeLabel: Boolean = true,
-    val battleTheme: ResourceLocation? = null,
-    var partySelectTutorialDone: Boolean = false
+    val battleTheme: ResourceLocation? = null
 ) : ClientInstancedPlayerData {
 
     override fun encode(buf: RegistryFriendlyByteBuf) {
@@ -47,7 +46,6 @@ data class ClientGeneralPlayerData(
         buf.writeNullable(starterUUID) { pb, value -> pb.writeString(value.toString()) }
         buf.writeNullable(resetStarters) { pb, value -> pb.writeBoolean(value) }
         buf.writeNullable(battleTheme) {pb, value -> pb.writeIdentifier(value)}
-        buf.writeBoolean(partySelectTutorialDone)
     }
     companion object {
         fun decode(buffer: RegistryFriendlyByteBuf): SetClientPlayerDataPacket {
@@ -59,7 +57,6 @@ data class ClientGeneralPlayerData(
             val starterUUID = buffer.readNullable { it.readString() }?.let { UUID.fromString(it) }
             val resetStarterPrompt = buffer.readNullable { it.readBoolean() }
             val battleTheme = buffer.readNullable { it.readIdentifier() }
-            val partySelectTutorialDone = buffer.readBoolean()
             val data = ClientGeneralPlayerData(
                 resetStarterPrompt,
                 promptStarter,
@@ -67,8 +64,7 @@ data class ClientGeneralPlayerData(
                 starterSelected,
                 starterUUID,
                 showChallengeLabel,
-                battleTheme,
-                partySelectTutorialDone
+                battleTheme
             )
             //Weird to do this, but since the flag doesn't get passed to the decoded obj, do it here
             //Should be fine, as long as decode doesn't get run on the server for some reason

common/src/main/kotlin/com/cobblemon/mod/common/api/tags/CobblemonItemTags.kt

@@ -42,7 +42,6 @@ object CobblemonItemTags {
     @JvmField val DAWN_STONE_ORES = create("dawn_stone_ores")
     @JvmField val POTTERY_SHERDS = create("decorated_pot_sherds")
     @JvmField val DEEP_SEAS = create("deep_seas")
-    @JvmField val DISPLAY_CASE_ITEMS = create("display_case_items")
     @JvmField val DUSK_STONE_ORES = create("dusk_stone_ores")
     @JvmField val ETHERS = create("ethers")
     @JvmField val EVOLUTION_ITEMS = create("evolution_items")
@@ -58,7 +57,6 @@ object CobblemonItemTags {
     @JvmField val HANGING_SIGNS = create("hanging_signs")
     @JvmField val HERBS = create("herbs")
     @JvmField val ICE_STONE_ORES = create("ice_stone_ores")
-    @JvmField val ITEM_BLOCKS = create("item_blocks")
     @JvmField val LEAF_STONE_ORES = create("leaf_stone_ores")
     @JvmField val MACHINES = create("machines")
     @JvmField val MINT_LEAF = create("mint_leaf")
@@ -67,7 +65,6 @@ object CobblemonItemTags {
     @JvmField val MOCHIS = create("mochis")
     @JvmField val MOON_STONE_ORES = create("moon_stone_ores")
     @JvmField val MUTATED_BERRIES = create("mutated_berries")
-    @JvmField val PLAQUES = create("plaques")
     @JvmField val PLANTS = create("plants")
     @JvmField val POKE_BALLS = create("poke_balls")
     @JvmField val POKE_RODS = create("poke_rods")

common/src/main/kotlin/com/cobblemon/mod/common/battles/BattleBuilder.kt

@@ -63,8 +63,8 @@ object BattleBuilder {
     ): BattleStartResult {
 
         val adjustLevel = battleFormat.adjustLevel
-        val team1 = partyAccessor(player1).toBattleTeam(clone = cloneParties || adjustLevel > 0,  healPokemon = healFirst, leadingPokemonPlayer1)
-        val team2 = partyAccessor(player2).toBattleTeam(clone = cloneParties || adjustLevel > 0,  healPokemon = healFirst, leadingPokemonPlayer2)
+        val team1 = partyAccessor(player1).toBattleTeam(clone = cloneParties || adjustLevel > 0,  healPokemon = healFirst, leadingPokemonPlayer1).sortedBy { it.health <= 0 }
+        val team2 = partyAccessor(player2).toBattleTeam(clone = cloneParties || adjustLevel > 0,  healPokemon = healFirst, leadingPokemonPlayer2).sortedBy { it.health <= 0 }
 
         val battlePartyStores = mutableListOf<PlayerPartyStore>()
 

common/src/main/kotlin/com/cobblemon/mod/common/battles/BattleFormat.kt

@@ -105,18 +105,12 @@ data class BattleFormat(
     }
 
     fun toFormatJSON(): String {
-        /*
-          Bag clause does not exist in showdown as a rule because showdown simply has no concept of a 'bag'.
-          If we try sending it, the battle will error. So this simply omits that from ever getting sent.
-          If we ever find a case where we are doing this for more than just bag clause, we should make a proper abstraction.
-         */
-        val rulesToSendToShowdown = ruleSet.filter { it != BattleRules.BAG_CLAUSE }
         return """
             {
                 "mod": "$mod",
                 "gameType": "${battleType.name}",
                 "gen": $gen,
-                "ruleset": [${rulesToSendToShowdown.joinToString { "\"$it\"" }}],
+                "ruleset": [${ruleSet.joinToString { "\"$it\"" }}],
                 "effectType": "Format"
             }
         """.trimIndent().replace("\n", "")

common/src/main/kotlin/com/cobblemon/mod/common/battles/BattleRegistry.kt

@@ -221,7 +221,6 @@ object BattleRegistry {
     fun closeBattle(battle: PokemonBattle) {
         battle.onEndHandlers.forEach { it(battle) }
         battleMap.remove(battle.battleId)
-        ShowdownService.service.endBattle(battle)
     }
 
     @JvmStatic

common/src/main/kotlin/com/cobblemon/mod/common/battles/BattleRules.kt

@@ -12,7 +12,6 @@ object BattleRules {
     const val OBTAINABLE = "Obtainable"
     const val PAST = "+Past"
     const val UNOBTAINABLE = "+Unobtainable"
-    const val BAG_CLAUSE = "Bag Clause"
     const val TEAM_PREVIEW = "Team Preview"
     const val ENDLESS_BATTLE_CLAUSE = "Endless Battle Clause"
     const val CANCEL_MOD = "Cancel Mod"

common/src/main/kotlin/com/cobblemon/mod/common/battles/ShowdownActionRequest.kt

@@ -289,8 +289,6 @@ class ShowdownMoveset {
     var canDynamax = false
     var maxMoves: List<InBattleGimmickMove?>? = null
     var canTerastallize: String? = null
-    /** This stores a list of gimmicks that have already been used this turn by a previous Pokemon, but the full turn has not been processed (ie. double battles). */
-    val pendingGimmickUsedThisTurn = mutableListOf<Gimmick>()
 
     fun saveToBuffer(buffer: RegistryFriendlyByteBuf) {
         buffer.writeSizedInt(IntSize.U_BYTE, moves.size)

common/src/main/kotlin/com/cobblemon/mod/common/battles/ShowdownInterpreter.kt

@@ -300,35 +300,4 @@ object ShowdownInterpreter {
         } ?:
         MissingContext()
     }
-
-    /**
-     * Registers a new update instruction parser.
-     * @param id The ID of the instruction to register.
-     * @param callback The callback function to create the instruction.
-     */
-    @JvmStatic
-    fun registerUpdateInstructionParser(id: String, callback: (PokemonBattle, InstructionSet, BattleMessage, Iterator<BattleMessage>) -> InterpreterInstruction) {
-        updateInstructionParser[id] = callback
-    }
-
-    /**
-     * Registers a new split instruction parser.
-     * @param id The ID of the instruction to register.
-     * @param callback The callback function to create the instruction.
-     */
-    @JvmStatic
-    fun registerSplitInstructionParser(id: String, callback: (PokemonBattle, BattleActor, InstructionSet, BattleMessage, BattleMessage, Iterator<BattleMessage>) -> InterpreterInstruction) {
-        splitInstructionParser[id] = callback
-    }
-
-    /**
-     * Registers a new side instruction parser.
-     * @param id The ID of the instruction to register.
-     * @param callback The callback function to create the instruction.
-     */
-    @JvmStatic
-    fun registerSideInstructionParser(id: String, callback: (PokemonBattle, BattleActor, InstructionSet, BattleMessage) -> InterpreterInstruction) {
-        sideInstructionParser[id] = callback
-    }
-
-}
+}

common/src/main/kotlin/com/cobblemon/mod/common/battles/actor/MultiPokemonBattleActor.kt

@@ -18,7 +18,7 @@ import java.util.UUID
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.network.chat.Component
 
-open class MultiPokemonBattleActor(
+class MultiPokemonBattleActor(
     pokemonList: List<BattlePokemon>,
     artificialDecider: BattleAI = RandomBattleAI(),
     uuid: UUID = UUID.randomUUID()

common/src/main/kotlin/com/cobblemon/mod/common/battles/actor/PokemonBattleActor.kt

@@ -24,14 +24,17 @@ import net.minecraft.network.chat.MutableComponent
 import net.minecraft.network.chat.Component
 import net.minecraft.world.phys.Vec3
 
-open class PokemonBattleActor(
+class PokemonBattleActor(
     uuid: UUID,
     val pokemon: BattlePokemon,
     override val fleeDistance: Float,
-    artificialDecider: BattleAI = RandomBattleAI(),
+    artificialDecider: BattleAI = RandomBattleAI()
 ) : AIBattleActor(uuid, listOf(pokemon), artificialDecider), EntityBackedBattleActor<PokemonEntity>, FleeableBattleActor {
 
-    override val initialPos: Vec3? = pokemon.entity?.position()
+    override val initialPos: Vec3?
+    init {
+        initialPos = entity?.position()
+    }
     override fun getName() = pokemon.effectedPokemon.species.translatedName
     override fun nameOwned(name: String): MutableComponent = Component.literal(name)
     override fun getWorldAndPosition(): Pair<ServerLevel, Vec3>? {

common/src/main/kotlin/com/cobblemon/mod/common/battles/actor/TrainerBattleActor.kt

@@ -17,7 +17,7 @@ import com.cobblemon.mod.common.util.battleLang
 import java.util.UUID
 import net.minecraft.network.chat.MutableComponent
 
-open class TrainerBattleActor(
+class TrainerBattleActor(
     val trainerName: String,
     uuid: UUID,
     pokemonList: List<BattlePokemon>,

common/src/main/kotlin/com/cobblemon/mod/common/battles/ai/StrongBattleAI.kt

@@ -31,7 +31,6 @@ import kotlin.collections.associateWith
 import kotlin.collections.partition
 import kotlin.math.absoluteValue
 
-
 /**
  * AI that tries to choose the best move for the given situations. Based off of the Pokemon Trainer Tournament Simulator Github
  * https://github.com/cRz-Shadows/Pokemon_Trainer_Tournament_Simulator/blob/main/pokemon-showdown/sim/examples/Simulation-test-1.ts#L330
@@ -272,11 +271,6 @@ class StrongBattleAI(skill: Int) : BattleAI {
         }
         activeTrackerPokemon.firstTurn = false
 
-        // If HP is below 30% and not switching out, always use the most damaging move
-        if (activeTrackerPokemon.currentHpPercent < 0.3 && !shouldSwitchOut(aiSide, battle, activeBattlePokemon, moveset)) {
-            findAndUseMostDamagingMove(activeBattlePokemon, activeTrackerPokemon, opponents, availableMoves, moveset, battle, aiSide)?.let { return it }
-        }
-
         // Decision-making based on move availability and switch-out condition
         if (!shouldSwitchOut(aiSide, battle, activeBattlePokemon, moveset)) {
             val nRemainingMons = activeTracker.alliedSide.actors.sumOf { actor -> actor.party.filter { it.currentHpPercent > 0 }.size }
@@ -527,19 +521,6 @@ class StrongBattleAI(skill: Int) : BattleAI {
 
         val opponentActiveTracker = activeTracker.opponentSide.activePokemon
         val opponentSpeedEstimations = opponentActiveTracker.map { statEstimationActive(it, Stats.SPEED) }
-
-
-        // Only switch if a switch-in is significantly better than the current Pokémon
-        val currentScore = estimateMatchup(activeBattlePokemon, side, battle)
-        val bestSwitchScore = availableSwitches.maxOfOrNull { estimateMatchup(activeBattlePokemon, side, battle, it) } ?: currentScore
-        val improvementThreshold = currentScore.absoluteValue * 0.25 + 2
-        if (bestSwitchScore <= currentScore + improvementThreshold) {
-            return false
-        }
-
-        if(bestSwitchScore < 1) {
-            return false
-        }
         // todo add some way to keep track of the player's boosting to see if it needs to switch out to something that can stop it
 
         // if slower speed stat than the opposing pokemon and HP is less than 20% don't switch out
@@ -567,8 +548,6 @@ class StrongBattleAI(skill: Int) : BattleAI {
         if (availableSwitches.isEmpty() || availableSwitches.none { estimateMatchup(activeBattlePokemon, side, battle, it) > 0 })
             return false
 
-        
-
         // ...and a 'good' reason to switch out
         if (opponentActiveTracker.any { it.boosts.getOrDefault(Stats.ACCURACY, 0) <= accuracySwitchThreshold } ||
             opponentActiveTracker.any { it.boosts.getOrDefault(Stats.DEFENCE, 0) <= -3 } ||

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/ActivateInstruction.kt

@@ -114,14 +114,7 @@ class ActivateInstruction(val instructionSet: InstructionSet, val message: Battl
                 }
                 "maxguard", "protect" -> battleLang("activate.protect", pokemonName)
                 "shadowforce", "hyperspacefury", "hyperspacehole" -> battleLang("activate.phantomforce", pokemonName)
-                else -> {
-                    val msgVariant = message.optionalArgument("msg")
-                    if (msgVariant != null) {
-                        battleLang("activate.${effect.id}.$msgVariant", pokemonName, sourceName, extraEffect)
-                    } else {
-                        battleLang("activate.${effect.id}", pokemonName, sourceName, extraEffect)
-                    }
-                }
+                else -> battleLang("activate.${effect.id}", pokemonName, sourceName, extraEffect)
             }
             battle.broadcastChatMessage(lang)
             //We check holds here so the chat msg + particle effect happen more concurrently, instead of sequentially

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/FaintInstruction.kt

@@ -52,7 +52,7 @@ class FaintInstruction(battle: PokemonBattle, val message: BattleMessage) : Inte
             preamble.thenAccept {
                 faintingPokemon.effectedPokemon.currentHealth = 0
                 faintingPokemon.sendUpdate()
-                CobblemonEvents.BATTLE_FAINTED.post(BattleFaintedEvent(battle, pokemon, context, pnx))
+                CobblemonEvents.BATTLE_FAINTED.post(BattleFaintedEvent(battle, pokemon, context))
                 battle.getActorAndActiveSlotFromPNX(pnx).second.battlePokemon = null
                 faintingPokemon.contextManager.add(context)
                 faintingPokemon.contextManager.clear(BattleContext.Type.STATUS, BattleContext.Type.VOLATILE, BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/FormeChangeInstruction.kt

@@ -26,7 +26,6 @@ import com.cobblemon.mod.common.util.battleLang
 class FormeChangeInstruction(val message: BattleMessage): InterpreterInstruction {
 
     override fun invoke(battle: PokemonBattle) {
-        val (pnx, _) = message.pnxAndUuid(0) ?: return
         val battlePokemon = message.battlePokemon(0, battle) ?: return
         val details = message.argumentAt(1)?.split(',')?.get(0)?.lowercase() ?: return
         val speciesName = details.substringBefore('-')
@@ -38,7 +37,7 @@ class FormeChangeInstruction(val message: BattleMessage): InterpreterInstruction
         battle.dispatchWaiting {
             battle.minorBattleActions[battlePokemon.uuid] = message
 
-            CobblemonEvents.FORME_CHANGE.post(FormeChangeEvent(battle, battlePokemon, formName, pnx))
+            CobblemonEvents.FORME_CHANGE.post(FormeChangeEvent(battle, battlePokemon, formName))
             val pokemonName = battlePokemon.getName()
             val lang = when(formName) {
                 "busted", "hero", "complete" -> return@dispatchWaiting

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/SwitchInstruction.kt

@@ -166,11 +166,6 @@ class SwitchInstruction(val instructionSet: InstructionSet, val battleActor: Bat
             // If we can't find the entity for some reason then we're going to skip the recall animation
             val sendOutFuture = CompletableFuture<Unit>()
             (pokemonEntity?.recallWithAnimation() ?: CompletableFuture.completedFuture(Unit)).thenApply {
-                if (battle.ended) {
-                    sendOutFuture.complete(Unit)
-                    return@thenApply
-                }
-
                 // Queue actual swap and send-in after the animation has ended
                 actor.pokemonList.swap(actor.activePokemon.indexOf(activePokemon), actor.pokemonList.indexOf(newPokemon))
                 activePokemon.battlePokemon = newPokemon

common/src/main/kotlin/com/cobblemon/mod/common/battles/interpreter/instructions/WinInstruction.kt

@@ -43,17 +43,17 @@ class WinInstruction(val message: BattleMessage): InterpreterInstruction {
         val losersText = losers.map { it.getName() }.reduce { acc, next -> acc + " & " + next }
         val wasCaught = battle.showdownMessages.any { "capture" in it }
 
-        // If the battle was a PvW battle, we need to set the killer of the wild Pokémon to the player
-        if (battle.isPvW) {
-            val nonPlayerActor = battle.actors.first { it.type == ActorType.WILD }
-            val wildPokemon: BattlePokemon = nonPlayerActor.pokemonList.first()
-
-            if (!wasCaught && losers.any { it.uuid == wildPokemon.uuid }) {
-                wildPokemon.effectedPokemon.entity?.killer = (battle.actors.firstOrNull { it.type == ActorType.PLAYER } as? PlayerBattleActor)?.entity
-            }
-        }
-
         battle.dispatch {
+            // If the battle was a PvW battle, we need to set the killer of the wild Pokémon to the player
+            if (battle.isPvW) {
+                val nonPlayerActor = battle.actors.first { it.type == ActorType.WILD }
+                val wildPokemon: BattlePokemon = nonPlayerActor.pokemonList.first()
+
+                if (!wasCaught && losers.any { it.uuid == wildPokemon.uuid }) {
+                    wildPokemon.effectedPokemon.entity?.killer = (battle.actors.firstOrNull { it.type == ActorType.PLAYER } as? PlayerBattleActor)?.entity
+                }
+            }
+
             // broadcast victory / defeat
             if (!wasCaught) {
                 val blackedOut = battle.isPvW && losers.any { it is PlayerBattleActor }

common/src/main/kotlin/com/cobblemon/mod/common/battles/pokemon/BattlePokemon.kt

@@ -36,18 +36,10 @@ import java.util.function.Function
 open class BattlePokemon(
     val originalPokemon: Pokemon,
     val effectedPokemon: Pokemon = originalPokemon,
-    var postBattlePokemonOperations: MutableList<(BattlePokemon) -> Unit> = mutableListOf(),
-    var postBattleEntityOperations: MutableList<(PokemonEntity) -> Unit> = mutableListOf()
+    val postBattleEntityOperation: (PokemonEntity) -> Unit = {}
 ) {
     lateinit var actor: BattleActor
 
-    constructor(originalPokemon: Pokemon, effectedPokemon: Pokemon, postBattleEntityOperation: (PokemonEntity) -> Unit) : this(
-        originalPokemon = originalPokemon,
-        effectedPokemon = effectedPokemon,
-        postBattlePokemonOperations = mutableListOf<(BattlePokemon) -> Unit>(),
-        postBattleEntityOperations = mutableListOf(postBattleEntityOperation)
-    )
-
     companion object {
         fun safeCopyOf(pokemon: Pokemon): BattlePokemon {
             //TOOD figure out a closer registry access (might have to break some method signatures for this (1.7?)

common/src/main/kotlin/com/cobblemon/mod/common/battles/runner/ShowdownService.kt

@@ -27,7 +27,6 @@ interface ShowdownService {
     fun openConnection()
     fun closeConnection()
     fun startBattle(battle: PokemonBattle, messages: Array<String>)
-    fun endBattle(battle: PokemonBattle)
     fun send(battleId: UUID, messages: Array<String>)
     fun getRegistryData(type: String): JsonArray
     fun sendRegistryData(data: Map<String, String>, type: String)

common/src/main/kotlin/com/cobblemon/mod/common/battles/runner/graal/GraalShowdownService.kt

@@ -129,11 +129,6 @@ class GraalShowdownService : ShowdownService {
         startBattleFunction.execute(this, battle.battleId.toString(), messages)
     }
 
-    override fun endBattle(battle: PokemonBattle) {
-        val endBattleFunction = context.getBindings("js").getMember("endBattle")
-        endBattleFunction.execute(battle.battleId.toString())
-    }
-
     override fun send(battleId: UUID, messages: Array<String>) {
         sendToShowdown(battleId, messages)
     }

common/src/main/kotlin/com/cobblemon/mod/common/battles/runner/socket/SocketShowdownService.kt

@@ -62,11 +62,6 @@ class SocketShowdownService(val host: String = "localhost", val port: Int = 1846
         send(battle.battleId, messages)
     }
 
-    override fun endBattle(battle: PokemonBattle) {
-        writer.write(">endbattle ${battle.battleId}\n")
-        acknowledge { Cobblemon.LOGGER.error("Failed to end battle ${battle.battleId}!") }
-    }
-
     override fun send(battleId: UUID, messages: Array<String>) {
         for (message in messages) {
             writer.write("$battleId~$message\n")

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

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2023 Cobblemon Contributors
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/.
+ */
+
+package com.cobblemon.mod.common.block
+
+import net.minecraft.world.item.Item
+import net.minecraft.core.dispenser.DispenseItemBehavior
+import net.minecraft.world.item.Items
+import net.minecraft.world.item.alchemy.PotionContents
+import net.minecraft.world.item.alchemy.Potions
+import net.minecraft.world.level.block.DispenserBlock
+
+object DispenserBehaviorRegistry {
+    private val behaviors = mutableMapOf<Item, DispenseItemBehavior>()
+
+    fun register(items: List<Item>, behaviorProvider: (Item) -> DispenseItemBehavior) {
+        for (item in items) {
+            behaviors[item] = behaviorProvider(item)
+        }
+    }
+
+    fun applyBehaviors() {
+        behaviors.forEach { (item, behavior) ->
+            DispenserBlock.registerBehavior(item, behavior)
+        }
+    }
+
+    // TODO: Seems like there can only 1 behavior per item, so registering the leaves with the honey bottle overrode the honey bottle behavior for the log.
+    //  Registering a new behavior with `DispenserBlock.registerBehavior` will override any existing ones for that item, possibly even ones from Minecraft and other mods
+    //  Will probably need to use an alternate way of implementing this to avoid conflicts.
+    fun registerDispenserBehaviors() {
+        // register(listOf(PotionContents.createItemStack(Items.POTION, Potions.WATER).item)) { SaccharineLogSlatheredBlock.createBehavior() }
+        // register(listOf(Items.HONEY_BOTTLE)) { SaccharineLogBlock.createBehavior() }
+        // register(listOf(Items.HONEY_BOTTLE, Items.GLASS_BOTTLE)) { item -> SaccharineLeafBlock.createBehavior(item)}
+        applyBehaviors()
+    }
+}

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

@@ -19,7 +19,6 @@ import net.minecraft.world.InteractionResult
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.BlockItem
 import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.LevelAccessor
 import net.minecraft.world.level.block.BaseEntityBlock
@@ -111,8 +110,6 @@ class DisplayCaseBlock(settings: Properties) : BaseEntityBlock(settings) {
 
     override fun getRenderShape(state: BlockState) = RenderShape.MODEL
 
-    override fun getShadeBrightness(state: BlockState, level: BlockGetter, pos: BlockPos): Float = 0.75F
-
     override fun getAnalogOutputSignal(state: BlockState, world: Level, pos: BlockPos): Int {
         val stack = (world.getBlockEntity(pos) as DisplayCaseBlockEntity).getStack()
 

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

@@ -29,7 +29,6 @@ import net.minecraft.world.level.block.SoundType
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.block.state.StateDefinition
 import net.minecraft.world.level.block.state.properties.BlockStateProperties
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
 import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
 import net.minecraft.world.level.block.state.properties.EnumProperty
 import net.minecraft.world.level.block.state.properties.IntegerProperty
@@ -44,6 +43,7 @@ class HeartyGrainsBlock(settings: Properties) : CropBlock(settings), SimpleWater
         val CODEC = simpleCodec(::HeartyGrainsBlock)
         const val MATURE_AGE = 6
         const val AGE_AFTER_HARVEST = 3 // Last single block stage
+        val WATERLOGGED = BlockStateProperties.WATERLOGGED
         val AGE: IntegerProperty = IntegerProperty.create("age", 0, MATURE_AGE)
         val HALF: EnumProperty<DoubleBlockHalf> = BlockStateProperties.DOUBLE_BLOCK_HALF
 

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

@@ -21,7 +21,6 @@ import com.cobblemon.mod.common.util.isInBattle
 import com.cobblemon.mod.common.util.playSoundServer
 import com.cobblemon.mod.common.util.toVec3d
 import com.cobblemon.mod.common.util.voxelShape
-import com.cobblemon.mod.common.util.rotateShape
 import com.mojang.serialization.MapCodec
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
@@ -72,10 +71,10 @@ class PastureBlock(settings: Properties): BaseEntityBlock(settings), SimpleWater
         private val WEST_AABB_TOP = buildCollider(top = true, Direction.WEST)
         private val EAST_AABB_TOP = buildCollider(top = true, Direction.EAST)
 
+        private val SOUTH_AABB_BOTTOM = buildCollider(top = false, Direction.SOUTH)
+        private val NORTH_AABB_BOTTOM = buildCollider(top = false, Direction.NORTH)
+        private val WEST_AABB_BOTTOM = buildCollider(top = false, Direction.WEST)
         private val EAST_AABB_BOTTOM = buildCollider(top = false, Direction.EAST)
-        private val SOUTH_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.SOUTH, EAST_AABB_BOTTOM)
-        private val NORTH_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.NORTH, EAST_AABB_BOTTOM)
-        private val WEST_AABB_BOTTOM = rotateShape(Direction.EAST, Direction.WEST, EAST_AABB_BOTTOM)
 
         private fun buildCollider(top: Boolean, direction: Direction): VoxelShape {
             if (top) {

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

@@ -1,128 +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.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.FaceAttachedHorizontalDirectionalBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class PlaqueBlock(properties : Properties) : FaceAttachedHorizontalDirectionalBlock(properties), SimpleWaterloggedBlock {
-    companion object {
-        val CODEC: MapCodec<PlaqueBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::PlaqueBlock)
-        }
-
-        val FLOOR_NORTH = Shapes.or(
-            Shapes.box(0.0625, 0.25, 0.4375, 0.9375, 1.0, 0.5625),
-            Shapes.box(0.125, 0.0, 0.4375, 0.25, 0.25, 0.5625),
-            Shapes.box(0.75, 0.0, 0.4375, 0.875, 0.25, 0.5625),
-        )
-        val WALL_NORTH = Shapes.box(0.0625, 0.125, 0.9375, 0.9375, 0.875, 1.0)
-        val CEILING_NORTH = Shapes.box(0.0625, 0.0, 0.4375, 0.9375, 0.75, 0.5625)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(FACE, AttachFace.WALL)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(FACING, FACE, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? {
-        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        for (direction in context.nearestLookingDirections) {
-            val blockState: BlockState
-            if (direction.getAxis() === Direction.Axis.Y) {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, if (direction == Direction.UP) AttachFace.CEILING else AttachFace.FLOOR) as BlockState)
-                    .setValue(FACING, context.horizontalDirection.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                ) as BlockState
-            } else {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, AttachFace.WALL) as BlockState)
-                    .setValue(FACING, direction.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                ) as BlockState
-
-            }
-
-            if (blockState.canSurvive(context.getLevel(), context.getClickedPos())) {
-                return blockState
-            }
-        }
-        return null
-    }
-
-    override fun codec(): MapCodec<PlaqueBlock> = CODEC
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, FLOOR_NORTH)
-                } else FLOOR_NORTH
-            AttachFace.WALL ->
-                when (direction) {
-                    Direction.NORTH, Direction.UP, Direction.DOWN -> WALL_NORTH
-                    else -> rotateShape(Direction.NORTH, direction, WALL_NORTH)
-                }
-            AttachFace.CEILING ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, CEILING_NORTH)
-                } else CEILING_NORTH
-        }
-    }
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (getConnectedDirection(state).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return if (state.getValue(FACE) == AttachFace.CEILING) {
-            val direction = getConnectedDirection(state)
-            canSupportCenter(level, pos.relative(direction.opposite), direction)
-        } else {
-            super.canSurvive(state, level, pos)
-        }
-    }
-}

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

@@ -28,8 +28,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.Item
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
-import net.minecraft.world.item.alchemy.PotionContents
-import net.minecraft.world.item.alchemy.Potions
 import net.minecraft.world.level.BlockGetter
 import net.minecraft.world.level.Level
 import net.minecraft.world.level.LevelAccessor
@@ -69,16 +67,9 @@ class SaccharineLeafBlock(settings: Properties) : LeavesBlock(settings) {
 
                 if (blockState.block is SaccharineLeafBlock) {
                     val currentAge = blockState.getValue(AGE)
-
-                    val waterBottle = PotionContents.createItemStack(Items.POTION, Potions.WATER).item
-
-                    val newAge = when (item) {
-                        Items.HONEY_BOTTLE if currentAge < MAX_AGE ->
-                            (currentAge + 2).coerceAtMost(MAX_AGE)
-
-                        waterBottle if currentAge > MIN_AGE ->
-                            (currentAge - 2).coerceAtLeast(MIN_AGE)
-
+                    val newAge = when {
+                        item == Items.HONEY_BOTTLE && currentAge < MAX_AGE -> (currentAge + 2).coerceAtMost(MAX_AGE)
+                        item == Items.GLASS_BOTTLE && currentAge > MIN_AGE -> (currentAge - 2).coerceAtLeast(MIN_AGE)
                         else -> currentAge
                     }
 
@@ -88,23 +79,21 @@ class SaccharineLeafBlock(settings: Properties) : LeavesBlock(settings) {
                         stack.shrink(1)
 
                         val dispenserEntity = source.blockEntity
-                        val outputItem = Items.GLASS_BOTTLE
+                        val outputItem = if (item == Items.HONEY_BOTTLE) Items.GLASS_BOTTLE else Items.HONEY_BOTTLE
                         val outputStack = ItemStack(outputItem)
                         var added = false
 
-                        if (dispenserEntity != null) {
-                            for (i in 0 until dispenserEntity.containerSize) {
-                                val slotStack = dispenserEntity.getItem(i)
+                        for (i in 0 until dispenserEntity.containerSize) {
+                            val slotStack = dispenserEntity.getItem(i)
 
-                                if (slotStack.isEmpty) {
-                                    dispenserEntity.setItem(i, outputStack.copy())
-                                    added = true
-                                    break
-                                } else if (slotStack.`is`(outputItem) && slotStack.count < slotStack.maxStackSize) {
-                                    slotStack.grow(1)
-                                    added = true
-                                    break
-                                }
+                            if (slotStack.isEmpty) {
+                                dispenserEntity.setItem(i, outputStack.copy())
+                                added = true
+                                break
+                            } else if (slotStack.`is`(outputItem) && slotStack.count < slotStack.maxStackSize) {
+                                slotStack.grow(1)
+                                added = true
+                                break
                             }
                         }
 

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

@@ -25,7 +25,6 @@ import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.Items
 import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.DispenserBlock
 import net.minecraft.world.level.block.HorizontalDirectionalBlock
 import net.minecraft.world.level.block.RotatedPillarBlock
 import net.minecraft.world.level.block.state.BlockState
@@ -38,7 +37,7 @@ class SaccharineLogBlock(properties: Properties) : RotatedPillarBlock(properties
         fun createBehavior(): DispenseItemBehavior {
             return DispenseItemBehavior { source, stack ->
                 val level = source.level
-                val facing = source.state.getValue(DispenserBlock.FACING)
+                val facing = source.state.getValue(HorizontalDirectionalBlock.FACING)
                 val pos = source.pos.relative(facing)
                 val blockState = level.getBlockState(pos)
 
@@ -51,13 +50,7 @@ class SaccharineLogBlock(properties: Properties) : RotatedPillarBlock(properties
             }
         }
 
-        fun changeLogTypeDispenser(
-            level: ServerLevel,
-            pos: BlockPos,
-            newState: BlockState,
-            stack: ItemStack,
-            source: BlockSource
-        ) {
+        fun changeLogTypeDispenser(level: ServerLevel, pos: BlockPos, newState: BlockState, stack: ItemStack, source: BlockSource) {
             level.setBlock(pos, newState, 3)
             level.gameEvent(null, GameEvent.BLOCK_CHANGE, pos)
 
@@ -82,23 +75,11 @@ class SaccharineLogBlock(properties: Properties) : RotatedPillarBlock(properties
             }
 
             if (!added) {
-                Containers.dropItemStack(
-                    level,
-                    source.pos.x.toDouble(),
-                    source.pos.y.toDouble(),
-                    source.pos.z.toDouble(),
-                    glassBottle
-                )
+                Containers.dropItemStack(level, source.pos.x.toDouble(), source.pos.y.toDouble(), source.pos.z.toDouble(), glassBottle)
             }
         }
 
-        fun changeLogType(
-            level: Level,
-            pos: BlockPos,
-            newState: BlockState,
-            player: Player? = null,
-            itemStack: ItemStack? = null
-        ) {
+        fun changeLogType(level: Level, pos: BlockPos, newState: BlockState, player: Player? = null, itemStack: ItemStack? = null) {
             level.setBlock(pos, newState, 3)
             level.gameEvent(null, GameEvent.BLOCK_CHANGE, pos)
 
@@ -112,15 +93,7 @@ class SaccharineLogBlock(properties: Properties) : RotatedPillarBlock(properties
         }
     }
 
-    override fun useItemOn(
-        stack: ItemStack,
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        player: Player,
-        hand: InteractionHand,
-        hitResult: BlockHitResult
-    ): ItemInteractionResult {
+    override fun useItemOn(stack: ItemStack, state: BlockState, level: Level, pos: BlockPos, player: Player, hand: InteractionHand, hitResult: BlockHitResult): ItemInteractionResult {
         val axis = state.getValue(AXIS)
         val itemStack = player.getItemInHand(hand)
         if (!level.isClientSide && itemStack.`is`(Items.HONEY_BOTTLE) && axis == Direction.Axis.Y) {

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

@@ -1,204 +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.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.util.StringRepresentable
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.HORIZONTAL_FACING
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.block.state.properties.IntegerProperty
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-import kotlin.math.min
-
-class StackableItemBlock(settings: Properties, val type: StackableItemBlockType): HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
-    enum class StackableItemBlockType: StringRepresentable {
-        BATTLE_ITEM,
-        ETHER,
-        MAX_POTION,
-        POTION,
-        STATUS_RESTORE;
-
-        override fun getSerializedName(): String = this.name.lowercase()
-
-        companion object {
-            val CODEC = StringRepresentable.fromEnum(::values)
-        }
-    }
-
-    companion object {
-        val MAX_AMOUNT: Int = 4
-        val AMOUNT: IntegerProperty = IntegerProperty.create("amount", 1, MAX_AMOUNT)
-
-        val CODEC: MapCodec<StackableItemBlock> = RecordCodecBuilder.mapCodec { it.group(
-            propertiesCodec(),
-            StackableItemBlockType.CODEC.fieldOf("type").forGetter(StackableItemBlock::type)
-        ).apply(it, ::StackableItemBlock) }
-
-        val northShapeMap: Map<StackableItemBlockType, List<VoxelShape>> = mapOf(
-            StackableItemBlockType.BATTLE_ITEM to listOf(
-                Shapes.box(0.34375, 0.0, 0.34375, 0.65625, 0.4375, 0.65625),
-                Shapes.or(
-                    Shapes.box(0.09375, 0.0, 0.34375, 0.40625, 0.4375, 0.65625),
-                    Shapes.box(0.59375, 0.0, 0.40625, 0.90625, 0.4375, 0.71875)
-                ),
-                Shapes.or(
-                    Shapes.box(0.59375, 0.0, 0.59375, 0.90625, 0.4375, 0.90625),
-                    Shapes.box(0.09375, 0.0, 0.53125, 0.40625, 0.4375, 0.84375),
-                    Shapes.box(0.34375, 0.0, 0.09375, 0.65625, 0.4375, 0.40625)
-                ),
-                Shapes.or(
-                    Shapes.box(0.09375, 0.0, 0.09375, 0.40625, 0.4375, 0.40625),
-                    Shapes.box(0.59375, 0.0, 0.15625, 0.90625, 0.4375, 0.46875),
-                    Shapes.box(0.65625, 0.0, 0.59375, 0.96875, 0.4375, 0.90625),
-                    Shapes.box(0.15625, 0.0, 0.53125, 0.46875, 0.4375, 0.84375)
-                )
-            ),
-            StackableItemBlockType.ETHER to listOf(
-                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5, 0.6875),
-                Shapes.or(
-                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.5, 0.75),
-                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.5, 0.6875)
-                ),
-                Shapes.or(
-                    Shapes.box(0.375, 0.0, 0.125, 0.625, 0.5, 0.5),
-                    Shapes.box(0.125, 0.0, 0.5625, 0.375, 0.5, 0.9375),
-                    Shapes.box(0.625, 0.0, 0.625, 0.875, 0.5, 1.0)
-                ),
-                Shapes.or(
-                    Shapes.box(0.125, 0.0, 0.0625, 0.375, 0.5, 0.4375),
-                    Shapes.box(0.625, 0.0, 0.125, 0.875, 0.5, 0.5),
-                    Shapes.box(0.6875, 0.0, 0.625, 0.9375, 0.5, 1.0),
-                    Shapes.box(0.1875, 0.0, 0.5625, 0.4375, 0.5, 0.9375)
-                )
-            ),
-            StackableItemBlockType.MAX_POTION to listOf(
-                Shapes.box(0.34375, 0.0, 0.3125, 0.65625, 0.5, 0.6875),
-                Shapes.or(
-                    Shapes.box(0.09375, 0.0, 0.3125, 0.40625, 0.5, 0.6875),
-                    Shapes.box(0.59375, 0.0, 0.375, 0.90625, 0.5, 0.75)
-                ),
-                Shapes.or(
-                    Shapes.box(0.34375, 0.0, 0.0625, 0.65625, 0.5, 0.4375),
-                    Shapes.box(0.09375, 0.0, 0.5625, 0.40625, 0.5, 0.9375),
-                    Shapes.box(0.59375, 0.0, 0.625, 0.90625, 0.5, 1.0)
-                ),
-                Shapes.or(
-                    Shapes.box(0.09375, 0.0, 0.0625, 0.40625, 0.5, 0.4375),
-                    Shapes.box(0.15625, 0.0, 0.5625, 0.46875, 0.5, 0.9375),
-                    Shapes.box(0.65625, 0.0, 0.625, 0.96875, 0.5, 1.0),
-                    Shapes.box(0.59375, 0.0, 0.125, 0.90625, 0.5, 0.5)
-                ).singleEncompassing()
-            ),
-            StackableItemBlockType.POTION to listOf(
-                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5625, 0.75),
-                Shapes.or(
-                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.5625, 0.75),
-                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.5625, 0.8125)
-                ),
-                Shapes.or(
-                    Shapes.box(0.375, 0.0, 0.0625, 0.625, 0.5625, 0.5),
-                    Shapes.box(0.625, 0.0, 0.5625, 0.875, 0.5625, 1.0),
-                    Shapes.box(0.125, 0.0, 0.5, 0.375, 0.5625, 0.9375)
-                ),
-                Shapes.or(
-                    Shapes.box(0.125, 0.0, 0.0, 0.375, 0.5625, 0.4375),
-                    Shapes.box(0.625, 0.0, 0.0625, 0.875, 0.5625, 0.5),
-                    Shapes.box(0.6875, 0.0, 0.5625, 0.9375, 0.5625, 1.0),
-                    Shapes.box(0.1875, 0.0, 0.5, 0.4375, 0.5625, 0.9375)
-                )
-            ),
-            StackableItemBlockType.STATUS_RESTORE to listOf(
-                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.4375, 0.6875),
-                Shapes.or(
-                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.4375, 0.75),
-                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.4375, 0.75)
-                ),
-                Shapes.or(
-                    Shapes.box(0.125, 0.0, 0.5, 0.375, 0.4375, 0.875),
-                    Shapes.box(0.625, 0.0, 0.5625, 0.875, 0.4375, 0.9375),
-                    Shapes.box(0.375, 0.0, 0.0625, 0.625, 0.4375, 0.4375)
-                ),
-                Shapes.or(
-                    Shapes.box(0.1875, 0.0, 0.5, 0.4375, 0.4375, 0.875),
-                    Shapes.box(0.125, 0.0, 0.0, 0.375, 0.4375, 0.375),
-                    Shapes.box(0.625, 0.0, 0.0625, 0.875, 0.4375, 0.4375),
-                    Shapes.box(0.6875, 0.0, 0.5625, 0.9375, 0.4375, 0.9375)
-                )
-            )
-        )
-
-        fun getShape(type: StackableItemBlockType, count: Int): VoxelShape = northShapeMap[type]?.let { list -> list[(count - 1).coerceIn(0, list.lastIndex)] } ?: Shapes.block()
-        fun getMaxAmount(type: StackableItemBlockType): Int = min(northShapeMap[type]?.size ?: 1 , MAX_AMOUNT)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(AMOUNT, 1)
-            .setValue(WATERLOGGED, false))
-    }
-
-    override fun codec(): MapCodec<StackableItemBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HORIZONTAL_FACING, AMOUNT, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? = if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState)
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (state.getValue(HORIZONTAL_FACING).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun getCollisionShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(HORIZONTAL_FACING)
-        val count = state.getValue(AMOUNT)
-        return rotateShape(Direction.NORTH, direction, getShape(type, count))
-    }
-
-    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        return getCollisionShape(state, level, pos, context).singleEncompassing()
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val blockState = context.level.getBlockState(context.clickedPos)
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        return if (blockState.`is`(this)) blockState.setValue(AMOUNT, min(getMaxAmount(type), (blockState.getValue(AMOUNT) + 1)))
-            else super.getStateForPlacement(context)?.setValue(HORIZONTAL_FACING, context.horizontalDirection.opposite)?.setValue(WATERLOGGED, fluidState.type === Fluids.WATER)
-    }
-
-    override fun canBeReplaced(state: BlockState, useContext: BlockPlaceContext): Boolean {
-        return if (
-            !useContext.isSecondaryUseActive
-            && useContext.itemInHand.`is`(this.asItem())
-            && state.getValue(AMOUNT) <= getMaxAmount(type)
-        ) true else super.canBeReplaced(state, useContext)
-    }
-}

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

@@ -1,81 +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.block
-
-import com.mojang.serialization.MapCodec
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.HORIZONTAL_FACING
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-
-open class WallAttachedDirectionalBlock(settings: Properties): HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
-    companion object {
-        val CODEC = simpleCodec(::WallAttachedDirectionalBlock)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(WATERLOGGED, false))
-    }
-
-    override fun codec(): MapCodec<out WallAttachedDirectionalBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HORIZONTAL_FACING, WATERLOGGED)
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        var direction = context.clickedFace
-        if (direction === null || direction.axis === Direction.Axis.Y) {
-            direction = context.horizontalDirection.opposite
-        }
-
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        val blockState = this.defaultBlockState()
-            .setValue(HORIZONTAL_FACING, direction)
-            .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-        ) as BlockState
-
-        if (blockState.canSurvive(context.getLevel(), context.getClickedPos())) {
-            return blockState
-        }
-        return null
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? = if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState)
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (state.getValue(HORIZONTAL_FACING).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return canAttach(level, pos, state.getValue(HORIZONTAL_FACING))
-    }
-
-    fun canAttach(reader: LevelReader, pos: BlockPos, direction: Direction): Boolean {
-        val blockPos = pos.relative(direction.opposite)
-        return reader.getBlockState(blockPos).isFaceSturdy(reader, blockPos, direction)
-    }
-}

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

@@ -1,68 +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.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.Codec
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class WallAttachedDirectionalShapeBlock(settings: Properties, val width: Int = 16, val height: Int = 16, val depth: Int = 16): WallAttachedDirectionalBlock(settings) {
-    companion object {
-        /**
-         * Calculates a [VoxelShape] based on a center point of (8, 8, 16).
-         *
-         * The resulting shape is centered X horizontally and Y vertically
-         * expanding inwards/North along the Z-axis from the South face (16).
-         *
-         * @param width The width of the shape from 0-16, along the X-axis.
-         * @param height The height of the shape from 0-16 along the Y-axis.
-         * @param depth The depth of the shape from 0-16 along the Z-axis, extending inwards from 16.
-         * @return A VoxelShape.
-         */
-        fun convertToShape(sizeX: Int, sizeY: Int, sizeZ: Int): VoxelShape {
-            val x = sizeX.coerceIn(0, 16).toDouble()
-            val y = sizeY.coerceIn(0, 16).toDouble()
-            val z = sizeZ.coerceIn(0, 16).toDouble()
-
-            val minX = (8.0 - (x / 2.0)) / 16.0
-            val maxX = (8.0 + (x / 2.0)) / 16.0
-
-            val minY = (8.0 - (y / 2.0)) / 16.0
-            val maxY = (8.0 + (y / 2.0)) / 16.0
-
-            val minZ = (16.0 - z) / 16.0
-
-            return Shapes.box(minX, minY, minZ, maxX, maxY, 1.0)
-        }
-    }
-
-    override fun codec(): MapCodec<WallAttachedDirectionalShapeBlock> = RecordCodecBuilder.mapCodec { instance ->
-        instance.group(
-            propertiesCodec(),
-            Codec.INT.fieldOf("width").forGetter { it.width },
-            Codec.INT.fieldOf("height").forGetter { it.height },
-            Codec.INT.fieldOf("depth").forGetter { it.depth }
-        ).apply(instance, { properties, width, height, depth ->
-            WallAttachedDirectionalShapeBlock(properties, width, height, depth)
-        })
-    }
-
-    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return rotateShape(Direction.NORTH, direction, convertToShape(width, height, depth))
-    }
-}

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

@@ -1,100 +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.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.util.StringRepresentable
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.HORIZONTAL_FACING
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.block.state.properties.IntegerProperty
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-import kotlin.math.min
-
-class WallAttachedStackableItemBlock(settings: Properties, val type: WallStackableItemBlockType): WallAttachedDirectionalBlock(settings) {
-    enum class WallStackableItemBlockType: StringRepresentable {
-        TAG;
-
-        override fun getSerializedName(): String = this.name.lowercase()
-
-        companion object {
-            val CODEC = StringRepresentable.fromEnum(::values)
-        }
-    }
-
-    companion object {
-        val MAX_AMOUNT: Int = 8
-        val AMOUNT: IntegerProperty = IntegerProperty.create("amount", 1, MAX_AMOUNT)
-
-        val CODEC: MapCodec<WallAttachedStackableItemBlock> = RecordCodecBuilder.mapCodec { it.group(
-            propertiesCodec(),
-            WallStackableItemBlockType.CODEC.fieldOf("type").forGetter(WallAttachedStackableItemBlock::type)
-        ).apply(it, ::WallAttachedStackableItemBlock) }
-
-        val northShapeMap: Map<WallStackableItemBlockType, List<VoxelShape>> = mapOf(
-            WallStackableItemBlockType.TAG to listOf(
-                Shapes.box(0.375, 0.25, 0.9375, 0.625, 0.6875, 1.0),
-                Shapes.box(0.375, 0.0625, 0.9375, 1.0, 0.6875, 1.0),
-                Shapes.box(0.0, 0.0625, 0.9375, 1.0, 0.9375, 1.0),
-                Shapes.box(0.0, 0.0625, 0.9375, 1.0, 1.0, 1.0),
-                Shapes.box(0.0, 0.0, 0.9375, 1.0, 1.0, 1.0),
-                Shapes.box(0.0, 0.0, 0.9375, 1.0, 1.0, 1.0),
-                Shapes.box(0.0, 0.0, 0.9375, 1.0, 1.0, 1.0),
-                Shapes.box(0.0, 0.0, 0.9375, 1.0, 1.0, 1.0)
-            )
-        )
-
-        fun getShape(type: WallStackableItemBlockType, count: Int): VoxelShape = northShapeMap[type]?.let { list -> list[(count - 1).coerceIn(0, list.lastIndex)] } ?: Shapes.block()
-        fun getMaxAmount(type: WallStackableItemBlockType): Int = min(northShapeMap[type]?.size ?: 1 , MAX_AMOUNT)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(AMOUNT, 1)
-            .setValue(WATERLOGGED, false))
-    }
-
-    override fun codec(): MapCodec<WallAttachedStackableItemBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        super.createBlockStateDefinition(builder)
-        builder.add(AMOUNT)
-    }
-
-    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(HORIZONTAL_FACING)
-        val count = state.getValue(AMOUNT)
-        return rotateShape(Direction.NORTH, direction, getShape(type, count))
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val blockState = context.level.getBlockState(context.clickedPos)
-        return if (blockState.`is`(this)) blockState.setValue(AMOUNT, min(getMaxAmount(type), (blockState.getValue(AMOUNT) + 1)))
-            else super.getStateForPlacement(context)
-    }
-
-    override fun canBeReplaced(state: BlockState, useContext: BlockPlaceContext): Boolean {
-        return if (
-            !useContext.isSecondaryUseActive
-            && useContext.itemInHand.`is`(this.asItem())
-            && state.getValue(AMOUNT) <= getMaxAmount(type)
-        ) true else super.canBeReplaced(state, useContext)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/dispenser/ChainedDispenseItemBehavior.kt

@@ -1,57 +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.block.dispenser
-
-import net.minecraft.core.dispenser.BlockSource
-import net.minecraft.core.dispenser.DispenseItemBehavior
-import net.minecraft.world.item.ItemStack
-import java.util.concurrent.CopyOnWriteArrayList
-
-class ChainedDispenseItemBehavior(private val base: DispenseItemBehavior) : DispenseItemBehavior {
-    private val extras = CopyOnWriteArrayList<DispenseItemBehavior>()
-
-    fun add(behavior: DispenseItemBehavior) {
-        extras.add(behavior)
-    }
-
-    override fun dispense(blockSource: BlockSource, itemStack: ItemStack): ItemStack {
-
-        var current = itemStack
-        for (b in extras) {
-            val prev = current.copy()
-            val next = try {
-                b.dispense(blockSource, current)
-            } catch (t: Throwable) {
-                continue
-            }
-            current = next
-            if (handled(prev, current)) {
-                return current
-            }
-        }
-
-        val beforeBase = current.copy()
-        val afterBase = try {
-            base.dispense(blockSource, current)
-        } catch (_: Throwable) {
-            return current
-        }
-
-        if (handled(beforeBase, afterBase)) {
-            return afterBase
-        }
-
-        return afterBase
-    }
-
-    private fun handled(before: ItemStack, after: ItemStack): Boolean {
-        return !ItemStack.matches(before, after)
-    }
-
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/dispenser/DispenserBehaviorRegistry.kt

@@ -1,90 +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.block.dispenser
-
-import com.cobblemon.mod.common.block.SaccharineLeafBlock
-import com.cobblemon.mod.common.block.SaccharineLogBlock
-import com.cobblemon.mod.common.block.SaccharineLogSlatheredBlock
-import com.cobblemon.mod.common.mixin.accessor.DispenserBlockAccessor
-import net.minecraft.core.dispenser.DispenseItemBehavior
-import net.minecraft.world.item.Item
-import net.minecraft.world.item.Items
-import net.minecraft.world.item.alchemy.PotionContents
-import net.minecraft.world.item.alchemy.Potions
-import net.minecraft.world.level.block.DispenserBlock
-
-object DispenserBehaviorRegistry {
-    private val behaviors = mutableMapOf<Item, DispenseItemBehavior>()
-
-    fun register(items: List<Item>, behaviorProvider: (Item) -> DispenseItemBehavior) {
-        register(behaviorProvider, items = items)
-    }
-
-    fun register(vararg behaviorProviders: (Item) -> DispenseItemBehavior, items: List<Item>) {
-        for (item in items) {
-            val providedBehaviors = behaviorProviders.map { provider -> provider(item) }
-
-            val existingLocal = behaviors[item]
-            if (existingLocal is ChainedDispenseItemBehavior) {
-                providedBehaviors.forEach { existingLocal.add(it) }
-                continue
-            }
-
-            val currentRegistered = getCurrentRegisteredBehavior(item)
-            if (currentRegistered is ChainedDispenseItemBehavior) {
-                behaviors[item] = currentRegistered
-                providedBehaviors.forEach { currentRegistered.add(it) }
-                continue
-            }
-
-            val base = currentRegistered ?: DispenseItemBehavior.NOOP
-            val chained = ChainedDispenseItemBehavior(base)
-            providedBehaviors.forEach { chained.add(it) }
-
-            behaviors[item] = chained
-            DispenserBlock.registerBehavior(item, chained)
-        }
-    }
-
-    private fun getCurrentRegisteredBehavior(item: Item): DispenseItemBehavior? {
-        return try {
-            val map = DispenserBlockAccessor.getItemBehaviors()
-            map[item]
-        } catch (t: Throwable) {
-            DispenseItemBehavior.LOGGER.error("Failed to read existing dispenser behaviors via mixin accessor", t)
-            null
-        }
-    }
-
-    fun registerDispenserBehaviors() {
-        register(
-            { SaccharineLogSlatheredBlock.createBehavior() },
-            items = listOf(
-                PotionContents.createItemStack(
-                    Items.POTION,
-                    Potions.WATER
-                ).item
-            )
-        )
-        register(
-            { SaccharineLogBlock.createBehavior() },
-            items = listOf(Items.HONEY_BOTTLE)
-        )
-        register(
-            { item -> SaccharineLeafBlock.createBehavior(item) },
-            items = listOf(
-                Items.HONEY_BOTTLE,
-                PotionContents.createItemStack(
-                    Items.POTION,
-                    Potions.WATER
-                ).item
-            )
-        )
-    }
-}

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

@@ -17,6 +17,7 @@ import com.cobblemon.mod.common.api.pasture.PastureLinkManager
 import com.cobblemon.mod.common.api.scheduling.afterOnServer
 import com.cobblemon.mod.common.api.text.italicise
 import com.cobblemon.mod.common.api.text.red
+import com.cobblemon.mod.common.api.text.textClickHandlers
 import com.cobblemon.mod.common.block.PastureBlock
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormEntityParticlePacket
@@ -109,10 +110,10 @@ class PokemonPastureBlockEntity(pos: BlockPos, state: BlockState) :
             for (tetheredPokemon in tetheredPokemonList) {
                 val pokemon = tetheredPokemon.getPokemon()!!
                 if (pokemon.currentFullness > 0) {
-                    pokemon.tickMetabolism(1)
+                    pokemon.tickMetabolism()
                 }
                 if (pokemon.interactionCooldowns.any()) {
-                    pokemon.tickInteractionCooldown(1)
+                    pokemon.tickInteractionCooldown()
                 }
             }
             blockEntity.togglePastureOn(blockEntity.getInRangeViewerCount(world, blockEntity.blockPos) > 0)

common/src/main/kotlin/com/cobblemon/mod/common/block/multiblock/FossilMultiblockStructure.kt

@@ -128,11 +128,11 @@ class FossilMultiblockStructure (
 
                 if(pokemon != null) {
                     pokemon.caughtBall = ballType
+                    player.party().add(pokemon)
                     this.fossilState.growthState = "Taken"
                     player.playSound(CobblemonSounds.FOSSIL_MACHINE_RETRIEVE_POKEMON, 1.0F, 1.0F)
                     CobblemonEvents.FOSSIL_REVIVED.post(FossilRevivedEvent(pokemon, player))
                     CobblemonCriteria.RESURRECT_POKEMON.trigger(player, pokemon)
-                    player.party().add(pokemon)
                 }
 
                 // Turn the monitor off

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

@@ -8,7 +8,9 @@
 
 package com.cobblemon.mod.common.client
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.LOGGER
+import com.cobblemon.mod.common.Cobblemon.cobblemonVR
 import com.cobblemon.mod.common.CobblemonBlockEntities
 import com.cobblemon.mod.common.CobblemonBlocks
 import com.cobblemon.mod.common.CobblemonClientImplementation
@@ -24,10 +26,10 @@ import com.cobblemon.mod.common.block.entity.TintBlockEntity
 import com.cobblemon.mod.common.client.battle.ClientBattle
 import com.cobblemon.mod.common.client.gui.PartyOverlay
 import com.cobblemon.mod.common.client.gui.PartyOverlayDataControl
-import com.cobblemon.mod.common.client.gui.RideOverlay
+import com.cobblemon.mod.common.client.gui.RideControlsOverlay
 import com.cobblemon.mod.common.client.gui.battle.BattleOverlay
 import com.cobblemon.mod.common.client.gui.cookingpot.CookingPotScreen
-import com.cobblemon.mod.common.client.gui.party.PartyTutorialToasts
+import com.cobblemon.mod.common.client.integration.vivecraft.CobblemonVRClient
 import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
 import com.cobblemon.mod.common.client.render.ClientPlayerIcon
 import com.cobblemon.mod.common.client.render.DeferredRenderer
@@ -73,6 +75,7 @@ import com.cobblemon.mod.common.client.tooltips.TooltipManager
 import com.cobblemon.mod.common.client.trade.ClientTrade
 import com.cobblemon.mod.common.entity.boat.CobblemonBoatType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
+import com.cobblemon.mod.common.integration.vivecraft.CobblemonVR
 import com.cobblemon.mod.common.platform.events.PlatformEvents
 import com.cobblemon.mod.common.pokedex.scanner.PokedexUsageContext
 import com.cobblemon.mod.common.util.isLookingAt
@@ -112,7 +115,7 @@ object CobblemonClient {
     val overlay: PartyOverlay by lazy { PartyOverlay() }
     val battleOverlay: BattleOverlay by lazy { BattleOverlay() }
     val pokedexUsageContext: PokedexUsageContext by lazy { PokedexUsageContext() }
-    val rideControlsOverlay: RideOverlay by lazy { RideOverlay() }
+    val rideControlsOverlay: RideControlsOverlay by lazy { RideControlsOverlay() }
 
     fun onLogin() {
         clientPlayerData = ClientGeneralPlayerData()
@@ -129,8 +132,6 @@ object CobblemonClient {
         battleOverlay.onLogout()
         ClientTaskTracker.clear()
         checkedStarterScreen = false
-        overlay.resetAttachedToast()
-        PartyTutorialToasts.reset()
 //        CobblemonDataProvider.canReload = true
         DeferredRenderer.clearAll()
         ClientPlayerIcon.clear()
@@ -155,6 +156,10 @@ object CobblemonClient {
         this.registerTooltipManagers()
         this.registerMenuScreens()
 
+        if (Cobblemon.implementation.isModInstalled("vivecraft")) {  // VR integration
+            CobblemonVRClient.init()
+        }
+
         LOGGER.info("Registering custom BuiltinItemRenderers")
         CobblemonBuiltinItemRendererRegistry.register(CobblemonItems.POKEMON_MODEL, PokemonItemRenderer())
 
@@ -168,12 +173,13 @@ object CobblemonClient {
         PlatformEvents.CLIENT_TICK_POST.subscribe { event ->
             val player = event.client.player
             if (player != null) {
-                val selectedItem = player.inventory.getItem(player.inventory.selected)
+                var selectedItem = player.inventory.getItem(player.inventory.selected)
                 if (pokedexUsageContext.scanningGuiOpen &&
                     !(selectedItem.`is`(CobblemonItemTags.POKEDEX)) &&
                     !(player.offhandItem.`is`(CobblemonItemTags.POKEDEX) &&
-                            player.isUsingItem &&
-                            player.usedItemHand == InteractionHand.OFF_HAND)
+                            player.isUsingItem == true &&
+                            player.usedItemHand == InteractionHand.OFF_HAND
+                            )
                 ) {
                     // Stop using Pokédex in main hand if player switches to a different slot in hotbar
                     pokedexUsageContext.stopUsing(PokedexUsageContext.OPEN_SCANNER_BUFFER_TICKS + 1)
@@ -189,7 +195,9 @@ object CobblemonClient {
 
                 nearbyPokemon?.forEach { entity ->
                     if (entity is PokemonEntity && !entity.isSilent && !entity.passengers.contains(player)) {
-                        if (player.isLookingAt(entity) && !player.isSpectator && entity.pokemon.shiny) entity.delegate.spawnShinyParticle(player)
+                        if (player.isLookingAt(entity) && !player.isSpectator && entity.pokemon.shiny) entity.delegate.spawnShinyParticle(
+                            player
+                        )
                         entity.delegate.spawnAspectParticle()
                     }
                 }
@@ -218,7 +226,7 @@ object CobblemonClient {
     }
 
     fun registerColors() {
-        this.implementation.registerBlockColors(BlockColor { _, view, blockPos, _ ->
+        this.implementation.registerBlockColors(BlockColor { blockState, view, blockPos, tintIndex ->
             blockPos?.let { pos ->
                 view?.getBlockEntity(pos)?.let { blockEntity ->
                     if (blockEntity is TintBlockEntity) return@BlockColor blockEntity.getTint()
@@ -321,48 +329,7 @@ object CobblemonClient {
             CobblemonBlocks.PINK_CAMPFIRE_POT,
             CobblemonBlocks.RED_CAMPFIRE_POT,
             CobblemonBlocks.WHITE_CAMPFIRE_POT,
-            CobblemonBlocks.YELLOW_CAMPFIRE_POT,
-            CobblemonBlocks.WHITE_PLAQUE,
-            CobblemonBlocks.LIGHT_GRAY_PLAQUE,
-            CobblemonBlocks.GRAY_PLAQUE,
-            CobblemonBlocks.BLACK_PLAQUE,
-            CobblemonBlocks.BROWN_PLAQUE,
-            CobblemonBlocks.RED_PLAQUE,
-            CobblemonBlocks.ORANGE_PLAQUE,
-            CobblemonBlocks.YELLOW_PLAQUE,
-            CobblemonBlocks.LIME_PLAQUE,
-            CobblemonBlocks.GREEN_PLAQUE,
-            CobblemonBlocks.CYAN_PLAQUE,
-            CobblemonBlocks.LIGHT_BLUE_PLAQUE,
-            CobblemonBlocks.BLUE_PLAQUE,
-            CobblemonBlocks.PURPLE_PLAQUE,
-            CobblemonBlocks.MAGENTA_PLAQUE,
-            CobblemonBlocks.PINK_PLAQUE,
-            CobblemonBlocks.BLUNDER_POLICY,
-            CobblemonBlocks.WEAKNESS_POLICY,
-            CobblemonBlocks.POTION,
-            CobblemonBlocks.SUPER_POTION,
-            CobblemonBlocks.HYPER_POTION,
-            CobblemonBlocks.MAX_POTION,
-            CobblemonBlocks.FULL_RESTORE,
-            CobblemonBlocks.ANTIDOTE,
-            CobblemonBlocks.AWAKENING,
-            CobblemonBlocks.BURN_HEAL,
-            CobblemonBlocks.ICE_HEAL,
-            CobblemonBlocks.PARALYZE_HEAL,
-            CobblemonBlocks.FULL_HEAL,
-            CobblemonBlocks.ETHER,
-            CobblemonBlocks.MAX_ETHER,
-            CobblemonBlocks.ELIXIR,
-            CobblemonBlocks.MAX_ELIXIR,
-            CobblemonBlocks.DIRE_HIT,
-            CobblemonBlocks.GUARD_SPEC,
-            CobblemonBlocks.X_ACCURACY,
-            CobblemonBlocks.X_ATTACK,
-            CobblemonBlocks.X_DEFENSE,
-            CobblemonBlocks.X_SP_ATK,
-            CobblemonBlocks.X_SP_DEF,
-            CobblemonBlocks.X_SPEED
+            CobblemonBlocks.YELLOW_CAMPFIRE_POT
         )
 
         this.createBoatModelLayers()
@@ -412,7 +379,10 @@ object CobblemonClient {
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.DISPLAY_CASE, ::DisplayCaseRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.LECTERN, ::LecternBlockEntityRenderer)
         this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.CAMPFIRE, ::CampfireBlockEntityRenderer)
-        this.implementation.registerBlockEntityRenderer(CobblemonBlockEntities.POKE_SNACK, ::PokeSnackBlockEntityRenderer)
+        this.implementation.registerBlockEntityRenderer(
+            CobblemonBlockEntities.POKE_SNACK,
+            ::PokeSnackBlockEntityRenderer
+        )
     }
 
     private fun registerEntityRenderers() {
@@ -441,7 +411,11 @@ object CobblemonClient {
 
     private fun registerItemColors() {
         implementation.registerItemColors(AprijuiceItemColorProvider, *CobblemonItems.aprijuices.toTypedArray())
-        implementation.registerItemColors(PokeSnackItemColorProvider, CobblemonItems.POKE_SNACK, CobblemonItems.POKE_CAKE)
+        implementation.registerItemColors(
+            PokeSnackItemColorProvider,
+            CobblemonItems.POKE_SNACK,
+            CobblemonItems.POKE_CAKE
+        )
         implementation.registerItemColors(PokeBaitItemColorProvider, CobblemonItems.POKE_BAIT)
         implementation.registerItemColors(PonigiriItemColorProvider, CobblemonItems.PONIGIRI)
         implementation.registerItemColors(SinisterTeaItemColorProvider, CobblemonItems.SINISTER_TEA)

common/src/main/kotlin/com/cobblemon/mod/common/client/battle/ClientBattle.kt

@@ -11,11 +11,10 @@ package com.cobblemon.mod.common.client.battle
 import com.cobblemon.mod.common.CobblemonNetwork
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
+import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.battles.BattleFormat
 import com.cobblemon.mod.common.battles.ForcePassActionResponse
-import com.cobblemon.mod.common.battles.MoveActionResponse
 import com.cobblemon.mod.common.battles.PassActionResponse
-import com.cobblemon.mod.common.battles.ShowdownMoveset
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.net.messages.server.battle.BattleSelectActionsPacket
 import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
@@ -62,15 +61,8 @@ class ClientBattle(
         if (index != -1) {
            while(index < pendingActionRequests.size) {
                val request = pendingActionRequests[index]
-               if (request.response != PassActionResponse && request.response !is ForcePassActionResponse) {
-                   val response = request.response
-                   // If we're cancelling a turn that used a gimmick, we re-enable the ability for that gimmick to be used.
-                   if (response is MoveActionResponse && response.gimmickID != null) {
-                       val gimmick = ShowdownMoveset.Gimmick.entries.find { it.id == response.gimmickID }
-                       pendingActionRequests.forEach { it.moveSet?.pendingGimmickUsedThisTurn?.remove(gimmick) }
-                   }
+               if (request.response != PassActionResponse && request.response !is ForcePassActionResponse)
                    request.response = null
-               }
                index++
            }
         }

common/src/main/kotlin/com/cobblemon/mod/common/client/entity/PokemonClientDelegate.kt

@@ -507,7 +507,9 @@ class PokemonClientDelegate : PosableState(), PokemonSideDelegate {
 
     override fun positionRider(passenger: Entity, positionUpdater: MoveFunction) {
         val locatorName = getSeatLocator(passenger)
-        val locator = this.locatorStates[locatorName] ?: return
+        val locator = this.locatorStates[locatorName]
+
+        if (locator == null) return
 
         val offset = locator.matrix.getTranslation(Vector3f())
             .sub(

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/PartyOverlay.kt

@@ -18,10 +18,10 @@ import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.gui.battle.BattleGUI
-import com.cobblemon.mod.common.client.gui.party.PartyTutorialToasts
 import com.cobblemon.mod.common.client.gui.toast.CobblemonToast
 import com.cobblemon.mod.common.client.keybind.boundKey
-import com.cobblemon.mod.common.client.keybind.keybinds.*
+import com.cobblemon.mod.common.client.keybind.keybinds.HidePartyBinding
+import com.cobblemon.mod.common.client.keybind.keybinds.SummaryBinding
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.client.render.getDepletableRedGreen
 import com.cobblemon.mod.common.client.render.models.blockbench.FloatingState
@@ -29,7 +29,6 @@ import com.cobblemon.mod.common.client.render.renderScaledGuiItemIcon
 import com.cobblemon.mod.common.pokemon.Gender
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
-import com.cobblemon.mod.common.util.toAssetPath
 import java.util.UUID
 import net.minecraft.client.DeltaTracker
 import net.minecraft.client.Minecraft
@@ -39,7 +38,6 @@ import net.minecraft.client.gui.components.toasts.AdvancementToast
 import net.minecraft.client.gui.components.toasts.Toast
 import net.minecraft.client.gui.screens.ChatScreen
 import net.minecraft.client.gui.screens.Screen
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
 import kotlin.math.ceil
 import kotlin.math.floor
@@ -150,9 +148,6 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
         val portraitFrameOffsetY = 2
         val selectedSlot = CobblemonClient.storage.selectedSlot
 
-        val partySize = party.slots.count { it != null }
-        PartyTutorialToasts.onOverlayRender(partySize)
-
         party.forEachIndexed { index, pokemon ->
             if (pokemon != null) {
                 val selectedOffsetX = if (selectedSlot == index) 6 else 0
@@ -472,7 +467,7 @@ class PartyOverlay : Gui(Minecraft.getInstance()) {
                     )
                 }
 
-                val ballIcon = pokemon.caughtBall.name.toAssetPath("textures/gui/ball/", ".png")
+                val ballIcon = cobblemonResource("textures/gui/ball/" + pokemon.caughtBall.name.path + ".png")
                 val ballHeight = 22
                 blitk(
                     matrixStack = matrices,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/RideControlsOverlay.kt

@@ -10,8 +10,6 @@ package com.cobblemon.mod.common.client.gui
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.gui.blitk
-import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourSettings
-import com.cobblemon.mod.common.api.riding.behaviour.RidingBehaviourState
 import com.cobblemon.mod.common.api.riding.behaviour.types.air.*
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.composite.CompositeState
@@ -21,7 +19,6 @@ import com.cobblemon.mod.common.api.riding.behaviour.types.land.VehicleBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BoatBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.BurstBehaviour
 import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.DolphinBehaviour
-import com.cobblemon.mod.common.api.riding.behaviour.types.liquid.DolphinState
 import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.asTranslated
@@ -33,28 +30,17 @@ import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.screens.ChatScreen
 import net.minecraft.client.gui.screens.Screen
 import net.minecraft.client.player.Input
-import net.minecraft.client.player.LocalPlayer
-import net.minecraft.client.renderer.BiomeColors
 import net.minecraft.network.chat.MutableComponent
 import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.FastColor
 import net.minecraft.util.Mth
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.level.BlockAndTintGetter
-import kotlin.math.floor
 import kotlin.math.max
-import kotlin.math.round
 
-class RideOverlay : Gui(Minecraft.getInstance()) {
+class RideControlsOverlay : Gui(Minecraft.getInstance()) {
 
     companion object {
         private const val CONTROLS_FADE_FRAMES = 20F
         private const val BASELINE_FPS = 60F
 
-        private const val MOTION_FADE_FRAMES = 10
-        private const val MOTION_FRAMES = 10
-        private const val MOTION_OVERLAY_MAX_OPACITY = 0.6F
-
         private const val HALF_SCALE = 0.5F
 
         private val mouseResource = cobblemonResource("textures/gui/riding/mouse.png")
@@ -73,8 +59,6 @@ class RideOverlay : Gui(Minecraft.getInstance()) {
         private val keyJumpResource = cobblemonResource("textures/gui/riding/key_jump.png")
         private val keySneakWideResource = cobblemonResource("textures/gui/riding/key_sneak_wide.png")
         private val keyJumpWideResource = cobblemonResource("textures/gui/riding/key_jump_wide.png")
-
-        private val motionLinesResource = cobblemonResource("textures/gui/riding/motion_lines_overlay.png")
     }
 
     private val screenExemptions: List<Class<out Screen>> = listOf(ChatScreen::class.java)
@@ -83,9 +67,6 @@ class RideOverlay : Gui(Minecraft.getInstance()) {
     private var controlsDurationFrames = controlsMaxDurationFrames
     private var controlsFadeFrames = CONTROLS_FADE_FRAMES
 
-    private var motionFrameIntervals = 0F
-    private var motionFadeFrames = 0
-
     private var lastMouseX = 0
     private var lastMouseY = 0
 
@@ -100,83 +81,27 @@ class RideOverlay : Gui(Minecraft.getInstance()) {
     override fun render(context: GuiGraphics, tickCounter: DeltaTracker) {
         val minecraft = Minecraft.getInstance()
 
+        // Hiding if a Screen is open and not exempt
+        minecraft.screen?.let { screen ->
+            if ((!screenExemptions.contains(screen.javaClass as Class<out Screen>))) return
+        }
+
+        if (minecraft.options.hideGui || minecraft.debugOverlay.showDebugScreen()) return
+
         minecraft.player?.let { player ->
-            // Hiding if a Screen is open and not exempt
-            minecraft.screen?.let { screen ->
-                if ((!screenExemptions.contains(screen.javaClass as Class<out Screen>))) return
-            }
-
-            if (minecraft.options.hideGui || minecraft.debugOverlay.showDebugScreen()) return
-
             val riddenEntity = player.vehicle
-
             if (riddenEntity != null && riddenEntity is PokemonEntity) {
-                val ridingBehaviourSettings = riddenEntity.ridingController?.context?.settings ?: return
-                val ridingBehaviourState = riddenEntity.ridingController?.context?.state ?: return
-
-                setCurrentRideBehaviour(ridingBehaviourSettings, ridingBehaviourState)
-
-                val tickDelta = tickCounter.realtimeDeltaTicks.takeIf { !minecraft.isPaused } ?: 0F
-                val updateInterval = (tickDelta / 20F) * BASELINE_FPS
-
-                renderMotionOverlay(minecraft, player, riddenEntity, context, updateInterval, ridingBehaviourSettings, ridingBehaviourState)
-                renderRideControls(minecraft, context, updateInterval, ridingBehaviourSettings, ridingBehaviourState)
+                // Only show controls to driver
+                if (riddenEntity === player.controlledVehicle) {
+                    renderControls(minecraft, context, tickCounter, riddenEntity)
+                }
             } else {
                 resetControlsOverlayState()
             }
         }
     }
 
-    fun renderMotionOverlay(minecraft: Minecraft, player: LocalPlayer, riddenEntity: Entity, context: GuiGraphics, updateInterval: Float, ridingBehaviourSettings: RidingBehaviourSettings, ridingBehaviourState: RidingBehaviourState) {
-        if (currentBehaviourKey == JetBehaviour.KEY || currentBehaviourKey  == DolphinBehaviour.KEY) {
-            val isBoosting = if (currentBehaviourKey == JetBehaviour.KEY) (ridingBehaviourState as JetState).boosting.get()
-            else (ridingBehaviourState as DolphinState).boosting.get()
-            val interval = round(updateInterval).toInt()
-
-            motionFadeFrames = (motionFadeFrames + (interval * (if (isBoosting) 1 else -1))).coerceIn(0, MOTION_FADE_FRAMES)
-            val opacity = (motionFadeFrames * (1F / MOTION_FADE_FRAMES)).coerceIn(0F, MOTION_OVERLAY_MAX_OPACITY)
-            val tint = if (player.isUnderWater && currentBehaviourKey == DolphinBehaviour.KEY) BiomeColors.getAverageWaterColor(minecraft.level as BlockAndTintGetter, riddenEntity.blockPosition()) else 0xFFFFFF
-
-            motionFrameIntervals += updateInterval * (if (minecraft.options.cameraType.isMirrored) -1 else 1)
-            val frameIndex = floor(motionFrameIntervals).toInt() % MOTION_FRAMES
-
-            blitk(
-                matrixStack = context.pose(),
-                texture = motionLinesResource,
-                x = 0,
-                y = 0,
-                textureHeight = 2560,
-                width = minecraft.window.guiScaledWidth,
-                height = minecraft.window.guiScaledHeight,
-                vOffset = 256 * frameIndex,
-                alpha = opacity,
-                red = FastColor.ARGB32.red(tint) / 255F,
-                green = FastColor.ARGB32.green(tint) / 255F,
-                blue = FastColor.ARGB32.blue(tint) / 255F
-            )
-        } else if (motionFadeFrames > 0) {
-            motionFadeFrames = 0
-        }
-    }
-
-    private fun setCurrentRideBehaviour(ridingBehaviourSettings: RidingBehaviourSettings, ridingBehaviourState: RidingBehaviourState) {
-        val rideBehaviourKey = ridingBehaviourSettings.key
-
-        // Update current ride behaviour if changed.
-        // If behaviour is composite, get active behaviour instead
-        if (rideBehaviourKey == CompositeBehaviour.KEY) {
-            val activeBehaviour = (ridingBehaviourState as CompositeState).activeBehaviour.get()
-            if (currentBehaviourKey != activeBehaviour) {
-                currentBehaviourKey = activeBehaviour
-                resetControlsOverlayState()
-            }
-        } else if (currentBehaviourKey != rideBehaviourKey) {
-            currentBehaviourKey = rideBehaviourKey
-            resetControlsOverlayState()
-        }
-    }
-
-    private fun renderRideControls(minecraft: Minecraft, context: GuiGraphics, updateInterval: Float, ridingBehaviourSettings: RidingBehaviourSettings, ridingBehaviourState: RidingBehaviourState) {
+    private fun renderControls(minecraft: Minecraft, context: GuiGraphics, tickCounter: DeltaTracker, riddenEntity: PokemonEntity) {
         // Update max duration if user has changed config
         val configDuration = Cobblemon.config.displayControlSeconds  * BASELINE_FPS
         if (controlsMaxDurationFrames != configDuration) {
@@ -187,8 +112,28 @@ class RideOverlay : Gui(Minecraft.getInstance()) {
         // Don't render if duration config set to 0 or less
         if (controlsMaxDurationFrames <= 0F) return
 
+        val rideBehaviourSettings = riddenEntity.ridingController?.context?.settings ?: return
+        val ridingBehaviourState = riddenEntity.ridingController?.context?.state ?: return
+        val rideBehaviourKey = rideBehaviourSettings.key
+
+        // Update current ride behaviour if changed
+        // If composite, get active behaviour instead
+        if (rideBehaviourKey == CompositeBehaviour.KEY) {
+            val activeBehaviour = (ridingBehaviourState as CompositeState).activeBehaviour.get()
+            if (currentBehaviourKey != activeBehaviour) {
+                currentBehaviourKey = activeBehaviour
+                resetControlsOverlayState()
+            }
+        } else if (currentBehaviourKey != rideBehaviourKey) {
+            currentBehaviourKey = rideBehaviourKey
+            resetControlsOverlayState()
+        }
+
         // Render elements if entity has ride behaviour and if display duration has not ended yet
-        if (ridingBehaviourSettings != null && controlsFadeFrames > 0) {
+        if (rideBehaviourSettings != null && controlsFadeFrames > 0) {
+            val tickDelta = tickCounter.realtimeDeltaTicks.takeIf { !minecraft.isPaused } ?: 0F
+            val updateInterval = (tickDelta / 20F) * BASELINE_FPS
+
             controlsDurationFrames = max(controlsDurationFrames - updateInterval, 0F)
             if (controlsDurationFrames == 0F && controlsFadeFrames > 0) controlsFadeFrames = max(controlsFadeFrames - updateInterval, 0F)
 

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/battle/subscreen/BattleMoveSelection.kt

@@ -68,7 +68,7 @@ class BattleMoveSelection(
     var moveTiles = baseTiles
 
     val backButton = BattleBackButton(x - 11F, Minecraft.getInstance().window.guiScaledHeight - 22F)
-    val gimmickButtons = moveSet.getGimmicks().filter { it !in moveSet.pendingGimmickUsedThisTurn }.mapIndexed { index, gimmick ->
+    val gimmickButtons = moveSet.getGimmicks().mapIndexed { index, gimmick ->
         val initOff = BattleBackButton.WIDTH * 0.65F
         val xOff = initOff + BattleGimmickButton.SPACING * index
         BattleGimmickButton.create(gimmick, this, backButton.x + xOff, backButton.y)

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/battle/subscreen/BattleSwitchPokemonSelection.kt

@@ -31,14 +31,12 @@ import com.cobblemon.mod.common.util.battleLang
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
 import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
-import com.cobblemon.mod.common.util.toAssetPath
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.narration.NarratableEntry
 import net.minecraft.client.gui.narration.NarrationElementOutput
 import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.client.sounds.SoundManager
-import net.minecraft.resources.ResourceLocation
 import org.joml.Quaternionf
 import org.joml.Vector3f
 
@@ -233,7 +231,7 @@ class BattleSwitchPokemonSelection(
                     textureHeight = SELECT_HEIGHT * 2,
                 )
 
-                val ballIcon = pokemon.caughtBall.name.toAssetPath("textures/gui/ball/", ".png")
+                val ballIcon = cobblemonResource("textures/gui/ball/" + pokemon.caughtBall.name.path + ".png")
                 val ballHeight = 22
                 blitk(
                     matrixStack = matrixStack,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/battle/subscreen/BattleTargetSelection.kt

@@ -17,7 +17,6 @@ import com.cobblemon.mod.common.api.text.text
 import com.cobblemon.mod.common.battles.InBattleGimmickMove
 import com.cobblemon.mod.common.battles.InBattleMove
 import com.cobblemon.mod.common.battles.MoveActionResponse
-import com.cobblemon.mod.common.battles.ShowdownMoveset
 import com.cobblemon.mod.common.client.CobblemonClient
 import com.cobblemon.mod.common.client.CobblemonResources
 import com.cobblemon.mod.common.client.battle.ActiveClientBattlePokemon
@@ -128,7 +127,7 @@ class BattleTargetSelection(
         private val isMultiTarget = multiTargetList?.firstOrNull { it.getPNX() == target.getPNX() } != null
         private val isCurrentPokemon = request.activePokemon.battlePokemon?.uuid == target.battlePokemon!!.uuid
 
-        open val response: MoveActionResponse get() = MoveActionResponse(targetSelection.move.id, responseTarget, gimmickID)
+        open val response: MoveActionResponse get() = MoveActionResponse(targetSelection.move.id, responseTarget)
         val state = FloatingState()
 
         open val selectable: Boolean get() = isMultiTarget || (responseTarget != null)
@@ -312,13 +311,6 @@ class BattleTargetSelection(
         fun onClick() {
             if (!selectable) return
             targetSelection.playDownSound(Minecraft.getInstance().soundManager)
-            // If a gimmick is used, remove the ability to use it on any pending action requests ahead of it
-            if (response.gimmickID != null) {
-                val gimmick = ShowdownMoveset.Gimmick.entries.first { it.id == response.gimmickID }
-                CobblemonClient.battle?.pendingActionRequests?.forEach {
-                    it.moveSet?.pendingGimmickUsedThisTurn?.add(gimmick)
-                }
-            }
             targetSelection.battleGUI.selectAction(targetSelection.request, response)
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/interact/partyselect/PartySlotButton.kt

@@ -24,13 +24,11 @@ import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
 import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
-import com.cobblemon.mod.common.util.toAssetPath
 import com.google.common.collect.Lists
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.client.gui.components.Button
 import net.minecraft.client.sounds.SoundManager
 import net.minecraft.network.chat.Component
-import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.FormattedCharSequence
 import net.minecraft.world.item.ItemStack
 import org.joml.Quaternionf
@@ -113,7 +111,7 @@ class PartySlotButton(
         )
         context.pose().popPose()
 
-        val ballIcon = pokemon.pokeball!!.asIdentifierDefaultingNamespace().toAssetPath("textures/gui/ball/", ".png")
+        val ballIcon = cobblemonResource("textures/gui/ball/" + pokemon.pokeball!!.asIdentifierDefaultingNamespace().path + ".png")
         val ballHeight = 22
         blitk(
             matrixStack = matrices,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/party/PartyTutorialToasts.kt

@@ -1,99 +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.gui.party
-
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.api.text.darkGray
-import com.cobblemon.mod.common.api.text.red
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.client.gui.toast.CobblemonToast
-import com.cobblemon.mod.common.client.keybind.boundKey
-import com.cobblemon.mod.common.client.keybind.keybinds.DownShiftPartyBinding
-import com.cobblemon.mod.common.client.keybind.keybinds.PartySendBinding
-import com.cobblemon.mod.common.client.keybind.keybinds.UpShiftPartyBinding
-import com.cobblemon.mod.common.net.messages.server.storage.party.PartyTutorialPacket
-import com.cobblemon.mod.common.util.lang
-import com.mojang.blaze3d.platform.InputConstants
-import net.minecraft.client.Minecraft
-import net.minecraft.client.gui.components.toasts.Toast
-import net.minecraft.client.gui.components.toasts.AdvancementToast
-import net.minecraft.network.chat.Component
-import net.minecraft.util.Mth
-
-object PartyTutorialToasts {
-
-    private var toastAttached = false
-
-    val upKey = UpShiftPartyBinding.boundKey()
-    val downKey = DownShiftPartyBinding.boundKey()
-
-    val upDisplay =
-        if (upKey.type == InputConstants.Type.KEYSYM && upKey.value == InputConstants.KEY_UP)
-            Component.literal("↑")
-        else upKey.displayName
-
-    val downDisplay =
-        if (downKey.type == InputConstants.Type.KEYSYM && downKey.value == InputConstants.KEY_DOWN)
-            Component.literal("↓")
-        else downKey.displayName
-
-    private val toast = CobblemonToast(
-        Mth.createInsecureUUID(),
-        CobblemonItems.POKEDEX_RED.defaultInstance,
-        lang("ui.party.party_select_title").red(),
-        lang(
-            "ui.party.party_select_description",
-            upDisplay,
-            downDisplay,
-            PartySendBinding.boundKey().displayName
-        ).darkGray(),
-        AdvancementToast.BACKGROUND_SPRITE,
-        -1F,
-        0
-    )
-
-    fun reset() {
-        toastAttached = false
-    }
-
-    fun onOverlayRender(partySize: Int) {
-        if (partySize <= 1) return
-
-        if (!CobblemonClient.clientPlayerData.partySelectTutorialDone) {
-            showToast()
-        }
-    }
-
-    fun onArrowKeySwitchedSlot() {
-        if (CobblemonClient.clientPlayerData.partySelectTutorialDone) return
-        if (CobblemonClient.storage.party.count { it != null } < 2) return
-        PartyTutorialPacket().sendToServer()
-        hideToast()
-    }
-
-    fun onHoldKeyScrollSwitchedSlot() {
-        if (CobblemonClient.clientPlayerData.partySelectTutorialDone) return
-        if (CobblemonClient.storage.party.count { it != null } < 2) return
-        PartyTutorialPacket().sendToServer()
-        hideToast()
-    }
-
-    private fun showToast() {
-        val minecraft = Minecraft.getInstance()
-        if (!toastAttached) {
-            toast.nextVisibility = Toast.Visibility.SHOW
-            minecraft.toasts.addToast(toast)
-            toastAttached = true
-        }
-    }
-
-    private fun hideToast() {
-        if (toastAttached) toast.nextVisibility = Toast.Visibility.HIDE
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pc/PCGUI.kt

@@ -40,7 +40,6 @@ import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.isInventoryKeyPressed
 import com.cobblemon.mod.common.util.lang
-import com.cobblemon.mod.common.util.toAssetPath
 import com.mojang.blaze3d.platform.InputConstants
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
@@ -464,7 +463,7 @@ class PCGUI(
             )
 
             // Poké Ball
-            val ballResource = pokemon.caughtBall.name.toAssetPath("textures/item/poke_balls/", ".png")
+            val ballResource = cobblemonResource("textures/item/poke_balls/" + pokemon.caughtBall.name.path + ".png")
             blitk(
                 matrixStack = matrices,
                 texture = ballResource,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/pokedex/widgets/StatsWidget.kt

@@ -237,11 +237,9 @@ class StatsWidget(val pX: Int, val pY: Int) : SoundlessWidget(
             blitk(matrixStack = matrices, texture = divider, x = pX + 51, y = pY + 10, height = 27.5, width = 1)
             blitk(matrixStack = matrices, texture = divider, x = pX + 9, y = pY + 2, height = 6, width = 121)
 
-            val rideStyle = selectedBehaviour.value.key.path.toString().split("/").last().lowercase()
             drawScaledText(
                 context = context,
-                text = lang("ui.ride_style.${selectedBehaviour.key.toString().lowercase()}.${rideStyle}")
-                    .append(" | ").append(lang("ui.ride_style.${selectedBehaviour.key.toString().lowercase()}")).bold(),
+                text = lang("ui.ride_style.${selectedBehaviour.key.name.lowercase()}").bold(),
                 x = pX + 69.5,
                 y = pY + 3,
                 colour = 0x3A96B6,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/summary/Summary.kt

@@ -45,7 +45,6 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.isInventoryKeyPressed
 import com.cobblemon.mod.common.util.lang
-import com.cobblemon.mod.common.util.toAssetPath
 import com.mojang.blaze3d.platform.InputConstants
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
@@ -559,7 +558,7 @@ class Summary private constructor(party: Collection<Pokemon?>, private val edita
         }
 
         // Poké Ball
-        val ballResource = selectedPokemon.caughtBall.name.toAssetPath("textures/item/poke_balls/", ".png")
+        val ballResource = cobblemonResource("textures/item/poke_balls/" + selectedPokemon.caughtBall.name.path + ".png")
         blitk(
             matrixStack = matrices,
             texture = ballResource,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/summary/widgets/PartySlotWidget.kt

@@ -24,7 +24,6 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
 import com.cobblemon.mod.common.util.math.fromEulerXYZDegrees
-import com.cobblemon.mod.common.util.toAssetPath
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.network.chat.Component
 import net.minecraft.resources.ResourceLocation
@@ -108,7 +107,7 @@ class PartySlotWidget(
                 )
             }
 
-            val ballIcon = slotPokemon.caughtBall.name.toAssetPath("textures/gui/ball/", ".png")
+            val ballIcon = cobblemonResource("textures/gui/ball/" + slotPokemon.caughtBall.name.path + ".png")
             val ballHeight = 22
             blitk(
                 matrixStack = matrices,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/summary/widgets/screens/moves/MovesWidget.kt

@@ -19,11 +19,11 @@ import com.cobblemon.mod.common.client.render.drawScaledText
 import com.cobblemon.mod.common.net.messages.server.RequestMoveSwapPacket
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
-import java.math.RoundingMode
-import java.text.DecimalFormat
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
 import net.minecraft.network.chat.Component
+import java.math.RoundingMode
+import java.text.DecimalFormat
 
 class MovesWidget(
     pX: Int, pY: Int,

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/summary/widgets/screens/stats/StatWidget.kt

@@ -66,7 +66,6 @@ class StatWidget(
         private const val MARKER_WIDTH = 8
         private const val WIDTH = 134
         private const val HEIGHT = 148
-        private const val RIDE_ICON_SIZE = 32
         const val SCALE = 0.5F
 
         private const val WHITE = 0x00FFFFFF
@@ -337,16 +336,14 @@ class StatWidget(
                         colour = pentagonColour
                     )
 
-                    val rideStyle = selectedBehaviour.value.key.path.toString().split("/").last().lowercase()
-                    val iconResource = cobblemonResource("textures/gui/summary/icon_ride_${selectedBehaviour.key.toString().lowercase()}_${rideStyle}.png")
-                    blitk(
-                        matrixStack = matrices,
-                        texture = iconResource,
-                        x= (x + 59) / SCALE,
-                        y = (y + 62.5) / SCALE,
-                        width = RIDE_ICON_SIZE,
-                        height = RIDE_ICON_SIZE,
-                        scale = SCALE
+                    drawScaledText(
+                        context = context,
+                        font = CobblemonResources.DEFAULT_LARGE,
+                        text = lang("ui.ride_style.${selectedBehaviour.key.name.lowercase()}").bold(),
+                        x = x + (WIDTH / 2),
+                        y = y + 66,
+                        shadow = true,
+                        centered = true
                     )
 
                     // Stat Labels
@@ -371,16 +368,6 @@ class StatWidget(
                         verticesOffset = pentagonVerticesOffset,
                         offsetY = 5.5
                     )
-
-                    if (pMouseX >= (x + 59) && pMouseY >= (y + 62.5) && pMouseX <= ((x + 59) + (RIDE_ICON_SIZE * SCALE)) && pMouseY <= ((y + 62.5) + (RIDE_ICON_SIZE * SCALE))) {
-                        context.renderTooltip(
-                            Minecraft.getInstance().font,
-                            lang("ui.ride_style.${selectedBehaviour.key.toString().lowercase()}.${rideStyle}")
-                                .append(" | ").append(lang("ui.ride_style.${selectedBehaviour.key.toString().lowercase()}")),
-                            pMouseX,
-                            pMouseY
-                        )
-                    }
                 }
 
             } else {

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/toast/CobblemonToast.kt

@@ -20,8 +20,6 @@ import net.minecraft.resources.ResourceLocation
 import net.minecraft.util.Mth
 import java.util.*
 import kotlin.math.min
-import net.minecraft.client.gui.Font
-import net.minecraft.util.FormattedCharSequence
 
 @Environment(EnvType.CLIENT)
 class CobblemonToast(
@@ -40,18 +38,11 @@ class CobblemonToast(
     private var lastTime = 0L
     internal var nextVisibility: Toast.Visibility = Toast.Visibility.SHOW
 
-    fun getLines(font: Font, maxWidth: Int): List<FormattedCharSequence> {
-        return font.split(this.description, maxWidth)
-    }
-
     override fun render(context: GuiGraphics, manager: ToastComponent, startTime: Long): Toast.Visibility {
-        val maxWidth = 125
+        context.blitSprite(this.frameTexture, 0, 0, this.width(), this.height())
         val textRenderer = manager.minecraft.font
-
-        context.blitSprite(this.frameTexture, 0, 0, this.width(), this.height() + (getLines(textRenderer, maxWidth).size - 1) * 10)
-
         context.drawString(textRenderer, this.title, 30, 7, this.title.style.color?.value ?: -1, false)
-        context.drawWordWrap(textRenderer, this.description, 30, 18, maxWidth, this.description.style.color?.value ?: -1)
+        context.drawString(textRenderer, this.description, 30, 18, this.description.style.color?.value ?: -1, false)
         context.renderFakeItem(this.icon, 8, 8)
         if (this.hasProgressBar()) {
             context.fill(3, 28, 157, 29, -1)

common/src/main/kotlin/com/cobblemon/mod/common/client/gui/trade/TradeGUI.kt

@@ -32,7 +32,6 @@ import com.cobblemon.mod.common.pokemon.Pokemon
 import com.cobblemon.mod.common.util.asTranslated
 import com.cobblemon.mod.common.util.cobblemonResource
 import com.cobblemon.mod.common.util.lang
-import com.cobblemon.mod.common.util.toAssetPath
 import com.mojang.blaze3d.platform.InputConstants
 import net.minecraft.client.Minecraft
 import net.minecraft.client.gui.GuiGraphics
@@ -585,7 +584,7 @@ class TradeGUI(
 
             // Poké Ball
             val nameXOffset = if (isOpposing) 75 else 0
-            val ballResource = pokemon.caughtBall.name.toAssetPath("textures/item/poke_balls/", ".png")
+            val ballResource = cobblemonResource("textures/item/poke_balls/" + pokemon.caughtBall.name.path + ".png")
             blitk(
                 matrixStack = context.pose(),
                 texture = ballResource,

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/CobblemonVRClient.kt

@@ -0,0 +1,26 @@
+package com.cobblemon.mod.common.client.integration.vivecraft
+
+import com.cobblemon.mod.common.client.integration.vivecraft.party.PartyOnArm
+import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityManager
+import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityRegistration
+import com.cobblemon.mod.common.client.integration.vivecraft.listener.proximity.PokeRodBaitListener
+import org.vivecraft.api.data.VRBodyPart
+
+class CobblemonVRClient {
+
+    companion object {
+        fun init() {
+            PartyOnArm.init()
+            ProximityManager.init()
+            ProximityManager.register(
+                ProximityRegistration(
+                    bodyA = VRBodyPart.MAIN_HAND,
+                    bodyB = VRBodyPart.OFF_HAND,
+                    distanceThreshold = 0.25f,
+                    angleThreshold = 120f,
+                    listener = PokeRodBaitListener("Main-OffHand")
+                )
+            )
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/proximity/PokeRodBaitListener.kt

@@ -0,0 +1,40 @@
+package com.cobblemon.mod.common.client.integration.vivecraft.listener.proximity
+
+import com.cobblemon.mod.common.Cobblemon
+import com.cobblemon.mod.common.CobblemonNetwork
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags
+import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityListener
+import com.cobblemon.mod.common.client.integration.vivecraft.proximity.ProximityRegistration
+import com.cobblemon.mod.common.net.messages.server.pokerod.ApplyBaitPacket
+import net.minecraft.client.Minecraft
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.item.ItemStack
+import org.vivecraft.api.data.VRBodyPart
+import org.vivecraft.api.data.VRPose
+
+class PokeRodBaitListener(private val name: String) : ProximityListener {
+    //TODO: Also add that if 1 is Rod the other needs to be seasoning
+    override fun isActive(registration: ProximityRegistration): Boolean {
+        val player = Minecraft.getInstance().player ?: return false
+        val handA: InteractionHand = VRBodyPart.toInteractionHand(registration.bodyA) ?: return false
+        val itemStackA: ItemStack = player.getItemInHand(handA)
+
+        val handB: InteractionHand = VRBodyPart.toInteractionHand(registration.bodyB) ?: return false
+        val itemStackB: ItemStack = player.getItemInHand(handB)
+
+        return itemStackA.`is`(CobblemonItemTags.POKE_RODS) || itemStackB.`is`(CobblemonItemTags.POKE_RODS)
+    }
+
+    override fun onEnter(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
+        Cobblemon.LOGGER.info("[$name] Enter: $bodyA <-> $bodyB")
+    }
+
+    override fun onExit(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
+        Cobblemon.LOGGER.info("[$name] Exit: $bodyA <-> $bodyB")
+    }
+
+    override fun onTick(bodyA: VRBodyPart, bodyB: VRBodyPart, pose: VRPose) {
+        Cobblemon.LOGGER.info("[$name] Proximity: $bodyA <-> $bodyB")
+        CobblemonNetwork.sendToServer(ApplyBaitPacket())
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/swing/DirectionalSwingListener.kt

@@ -0,0 +1,237 @@
+package com.cobblemon.mod.common.client.integration.vivecraft.listener.swing
+
+import com.cobblemon.mod.common.Cobblemon
+import net.minecraft.client.Minecraft
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.phys.Vec3
+import org.vivecraft.api.client.VRClientAPI
+import org.vivecraft.api.client.tracker.swing.SwingContext
+import org.vivecraft.api.client.tracker.swing.SwingListener
+import org.vivecraft.api.data.VRBodyPart
+import kotlin.math.abs
+
+/**
+ * Listener that classifies directional swings (up, down, forward, backward, left, right)
+ * using Vivecraft VR pose history and invokes handler methods for each direction.
+ *
+ * @param forwardDotThreshold Dot product threshold used to classify forward/back/left/right directions.
+ * @param historyTicks Number of ticks used to compute velocity from historical poses.
+ */
+abstract class DirectionalSwingListener(
+    private val forwardDotThreshold: Double = 0.3,
+    private val historyTicks: Int = 10
+) : SwingListener {
+
+    protected val minecraft: Minecraft = Minecraft.getInstance()
+    protected val clientData: VRClientAPI = VRClientAPI.instance()
+
+    /**
+     * Compute the net movement vector for the specified body part over the given number of ticks.
+     * Returns null if historical pose data is unavailable, insufficient, or movement is negligible.
+     *
+     * @param bodyPart The VR body part to compute movement for.
+     * @param ticks The number of ticks of history to consider.
+     * @return The movement vector or null if unavailable/insignificant.
+     */
+    private fun changeForVelocity(bodyPart: VRBodyPart, ticks: Int = historyTicks): Vec3? {
+        val history = clientData.historicalVRPoses ?: return null
+        if (history.ticksOfHistory() < ticks) return null
+
+        val delta = history.netMovement(bodyPart, ticks)
+        delta?.lengthSqr()?.let { if (it < 1e-6) return null }
+
+        return delta
+    }
+
+    /**
+     * Called when an upward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the upward action was handled, false otherwise.
+     */
+    protected open fun onUpwardSwing(
+        useHand: InteractionHand,
+        player: Player
+    ): Boolean {
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: upward movement. player={}, hand={}",
+            player, useHand
+        )
+        return true
+    }
+
+    /**
+     * Called when a downward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the downward action was handled, false otherwise.
+     */
+    protected open fun onDownwardSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: downward movement. handVel={}, player={}, hand={}",
+            handVel, player, useHand
+        )
+        return true
+    }
+
+    /**
+     * Called when a forward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the forward action was handled, false otherwise.
+     */
+    protected open fun onForwardSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        return true
+    }
+
+    /**
+     * Called when a backward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the backward action was handled, false otherwise.
+     */
+    protected open fun onBackwardSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: backward movement. handVel={}, player={}, hand={}",
+            handVel, player, useHand
+        )
+        return true
+    }
+
+    /**
+     * Called when a leftward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the leftward action was handled, false otherwise.
+     */
+    protected open fun onLeftSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: leftward movement. handVel={}, player={}, hand={}",
+            handVel, player, useHand
+        )
+        return true
+    }
+
+    /**
+     * Called when a rightward swing is detected.
+     *
+     * @param useHand The hand used for the swing.
+     * @param handVel The velocity vector of the hand during the swing.
+     * @param player The player performing the swing.
+     * @return True if the rightward action was handled, false otherwise.
+     */
+    protected open fun onRightSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: rightward movement. handVel={}, player={}, hand={}",
+            handVel, player, useHand
+        )
+        return true
+    }
+
+
+    /**
+     * Checks if the given item stack is valid for processing by this swing listener.
+     * Subclasses must implement this to specify which items they handle.
+     * @param itemStack The item stack to validate.
+     * @return True if the item stack is valid, false otherwise.
+     */
+    protected abstract fun isValidItem(itemStack: ItemStack): Boolean
+
+    /**
+     * Called when a swing ends. Validates the held item, computes hand velocity from historical poses,
+     * handles vertical swings first (upward/downward) and then classifies horizontal direction:
+     * forward/backward by dot with player look direction; left/right by projecting onto a right vector
+     * computed from world up and forward. Ambiguous swings are ignored.
+     *
+     * @param context Vivecraft swing context containing body part information.
+     */
+    override fun onSwingEnd(context: SwingContext?) {
+        val player = minecraft.player ?: return
+        val ctx = context ?: return
+        val useHand: InteractionHand = VRBodyPart.toInteractionHand(ctx.bodyPart) ?: return
+        val itemStack: ItemStack = player.getItemInHand(useHand)
+
+        if (!isValidItem(itemStack)) return
+
+        val handVel = changeForVelocity(ctx.bodyPart) ?: run {
+            Cobblemon.LOGGER.info(
+                "Ignoring swing: insufficient historical pose data for velocity. bodyPart={}, player={}",
+                ctx.bodyPart, player
+            )
+            return
+        }
+
+        val vertical = handVel.y
+        if (vertical > 0.0) {
+            if (onUpwardSwing(useHand, player)) return
+        } else if (vertical < 0.0) {
+            if (onDownwardSwing(useHand, handVel, player)) return
+        }
+
+        val forward = player.lookAngle.normalize()
+        val handDir = handVel.normalize()
+        val forwardDot = handDir.dot(forward)
+
+        val worldUp = Vec3(0.0, 1.0, 0.0)
+        val right = forward.cross(worldUp).let {
+            if (it.lengthSqr() < 1e-6) Vec3(1.0, 0.0, 0.0) else it.normalize()
+        }
+        val rightDot = handDir.dot(right)
+
+        if (forwardDot > forwardDotThreshold) {
+            if (onForwardSwing(useHand, handVel, player)) return
+            return
+        }
+
+        if (forwardDot < -forwardDotThreshold) {
+            if (onBackwardSwing(useHand, handVel, player)) return
+            return
+        }
+
+        if (abs(rightDot) > forwardDotThreshold) {
+            if (rightDot > 0.0) {
+                if (onRightSwing(useHand, handVel, player)) return
+            } else {
+                if (onLeftSwing(useHand, handVel, player)) return
+            }
+            return
+        }
+
+        Cobblemon.LOGGER.info(
+            "Ignoring swing: ambiguous direction. forwardDot={}, rightDot={}, handVel={}, player={}",
+            forwardDot, rightDot, handVel, player
+        )
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/client/integration/vivecraft/listener/swing/PokeBallSwingListener.kt

@@ -0,0 +1,29 @@
+package com.cobblemon.mod.common.client.integration.vivecraft.listener.swing
+
+import com.cobblemon.mod.common.CobblemonNetwork
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags
+import com.cobblemon.mod.common.net.messages.server.pokeball.SendOutPokeBallPacket
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.phys.Vec3
+
+class PokeBallSwingListener : DirectionalSwingListener() {
+
+    override fun isValidItem(itemStack: ItemStack): Boolean =
+        itemStack.`is`(CobblemonItemTags.POKE_BALLS)
+
+    override fun onForwardSwing(
+        useHand: InteractionHand,
+        handVel: Vec3,
+        player: Player
+    ): Boolean {
+        CobblemonNetwork.sendToServer(SendOutPokeBallPacket())
+        return true
+    }
+
+    override fun onDownwardSwing(useHand: InteractionHand, handVel: Vec3, player: Player): Boolean {
+        CobblemonNetwork.sendToServer(SendOutPokeBallPacket())
+        return super.onDownwardSwing(useHand, handVel, player)
+    }
+}