copper fridge basics

# Conflicts:
#	common/src/main/kotlin/com/cobblemon/mod/common/CobblemonBlocks.kt
#	common/src/main/kotlin/com/cobblemon/mod/common/client/CobblemonClient.kt

CHANGELOG.md

@@ -1,55 +1,29 @@
 # Changelog
-## [1.8.3 (MONTH xth, 2026)](#1-8-3)
+## [1.8.5 (MONTH xth, 2026)](#1-8-5)
 
 ### Additions
-
-### Pokémon Added
-#### Generation 4
-
-#### Generation 5
-
-#### Generation 6
-
-#### Generation 7
-
-#### Generation 8
-
-#### Generation 9
-
-### Model updates for the following Pokémon
-
-### Animation updates for the following Pokémon
+- Added the `healersSetSpawn` gamerule. When enabled, using a healing machine will set your spawnpoint.
+- A Pokémon holding a Power item now gains 1 point in the corresponding riding stat every two minutes while being ridden. The interval is configurable, and can be disabled with `-1`.
+- Added sounds to Gigaton Hammer and Pyro Ball
+- Added stepsounds to Venusaur, Blastoise, Dewgong, Rhydon, Rhyhorn, Parasect and Mr. Mime.
 
 ### Changes
-- Changed the Misc icon in the Campfire Pot Recipe Book to Health Candy
-- Moved EXP Candies from the Medicine recipe book category to the Misc category
+- Amethyst now grows from Typegem core blocks like typegems do
+- Updated the recipe category for the Create compatibility EXP Candy recipe
+- Added No Man's Lands' Honeyed Apple to the Leaves Leftovers tag
 
 ### Fixes
-- Fixed datapacks with item interaction evolutions that don't specify an item crashing the world on load.
-- Fixed the Pokédex evolution tree crashing when a datapack's dex entry is missing an evolution's form.
-- Fixed the Pokédex evolution tree crashing with a stack overflow on evolutions that loop back on themselves.
-- Fixed the Pokédex evolution tree crashing when looking at a dex that is not part of the "National Dex" aggregate.
-- Fixed evolution trees not building properly when a pokemon has several pokedex entries for different regions.
-- Fixed form-changing evolutions sometimes resolving to the source form in the Pokédex evolution tree.
-- Broken datapack evolutions are now logged and skipped in the Pokédex evolution tree instead of crashing.
-- Fixed friendship booster items not being recognised as such
-- Fixed conflicts with other mods that would make use of recipe books in certain ways (Farmer's Delight Cooking Pot)
-- Fixed Pokémon battles stalling when a sidemod cancels the `THROWN_POKEBALL_HIT` hit event
-- Fixed choice feature tab completion in `spawnpokemon/pokegive/pokeedit` commands
-- Fixed MoLang that's targeting players intermittedly failing when they have died, needing them to relog
-- Fixed all pots of mod on NeoForge
-- Fixed party overlay not hiding when player opens the pokedex scanner 
-- Added compat for AppleSkin
+- Fixed Ponigiri food values for AppleSkin integration
+- Fixed errors emitted by typos in Parched Peat bog structure files
 
 ### Developer
-- Bumped NeoForge to `21.1.195` to get access to MixinExtras `0.5` and the expressions annotation
-- New Platform Event `PLAYER_RESPAWN` which is fired when a player respawns (either through death or returning from the end)
-- Platform Events `SERVER_PLAYER_TICK_PRE` and `SERVER_PLAYER_TICK_POST` no longer fire when the player is dead
-  - it is now tied much closer to the actual entity rather than the player (or their connection)
 
 ### Molang & Datapacks
-- Fixed `q.pokemon.nature` returning class instance instead of proper string value (`cobblemon:adamant`)
-- Fixed `q.entity.is_looking_at` result being always `1` for whatever entity passed as target
+- `q.is_standing_on_blocks` now properly checks for non-full blocks like slabs, Mud or Soul Sand
+- Added Molang functions to play footstep sounds based on the corresponding surface. These are intended to be used by Pokémon animations.
+- Pokémon can now have their Minecraft footstep sounds silenced in their poser. This doesn't affect emitting game events.
+
+### Particles
 
 ### Localization
 - Updated translations for:

Rotom Notes.txt

@@ -0,0 +1,2 @@
+Spec Doc: https://docs.google.com/document/d/1hEKKrT4JEagJBykx-k9K2BoeNxiMGahUWXnf8YQ85xo/edit?tab=t.0
+Marshal: dhi_holo

changelogs/CHANGELOG-1.8.3.md

@@ -0,0 +1,107 @@
+# Changelog
+## [1.8.3 (October 25th, 2026)](#1-8-3)
+
+### Additions
+- Added compatability with AppleSkin.
+
+### New Rideable Pokémon
+- Vikavolt
+- Fearow
+
+### Particles
+## New Move Animations
+- Water Shuriken
+
+### Cries added/updated for the following Pokémon
+- Hoppip
+- Skiploom
+- Jumpluff
+- Houndour
+- Houndoom
+- Wurmple
+- Silcoon
+- Beautifly
+- Cascoon
+- Dustox
+- Surskit
+- Masquerain
+- Torkoal
+- Starly
+- Staravia
+- Staraptor
+- Combee
+- Vespiquen
+- Dusknoir
+- Helioptile
+- Heliolisk
+- Grubbin
+- Charjabug
+- Vikavolt
+- Applin (updated)
+- Flapple (updated)
+- Appletun
+- Runerigus
+- Dipplin
+
+### Animation updates for the following Pokémon
+- Vikavolt
+- Magby
+- Magmar
+- Ninetales (+ Alolan)
+- Spearow
+- Fearow
+- Squawkabilly
+- Mudkip
+- Marshtomp
+- Swampert
+
+### Changes
+- Changed the Misc icon in the Campfire Pot Recipe Book to Health Candy.
+- Moved EXP Candies from the Medicine recipe book category to the Misc category.
+- Removed Dynamic Lights data from the Magmarizer item for consistency with the block.
+- Added `doPokemonPredation` game rule, which controls aggressiveness of Pokémon with the `hate_entity` brain task defined.
+- Added `predation_chance` server config value, which controls the possibility of attacking the hated entity found in `hate_entity` brain tasks.
+- Prehistoric Eroded Pillar generates slightly more frequently.
+- Togekiss was changed from a jet-style mount to bird-style.
+
+### Fixes
+- Fixed datapacks with item interaction evolutions that don't specify an item crashing the world on load.
+- Fixed the Pokédex evolution tree crashing when a datapack's dex entry is missing an evolution's form.
+- Fixed the Pokédex evolution tree crashing with a stack overflow on evolutions that loop back on themselves.
+- Fixed the Pokédex evolution tree crashing when looking at a dex that is not part of the "National Dex" aggregate.
+- Fixed some display names in the Pokédex evolution tree having unintended font colours.
+- Fixed evolution trees not building properly when a Pokémon has several Pokédex entries for different regions.
+- Fixed form-changing evolutions sometimes resolving to the source form in the Pokédex evolution tree.
+- Broken datapack evolutions are now logged and skipped in the Pokédex evolution tree instead of crashing.
+- Fixed the `alpha` property having no tab completion in commands such as `/pokespawn`, `/pokegive` and `/pokeedit`, and added the missing `dmax_level`, `gmax_factor` and `tradable` aliases to tab completion.
+- Fixed friendship booster items not being recognised as such.
+- Fixed conflicts with other mods that would make use of recipe books in certain ways (Farmer's Delight Cooking Pot).
+- Fixed Pokémon battles stalling when a sidemod cancels the `THROWN_POKEBALL_HIT` hit event.
+- Fixed choice feature tab completion in `spawnpokemon/pokegive/pokeedit` commands.
+- Fixed MoLang that's targeting players intermittedly failing when they have died, requiring them to relog.
+- Fixed a NeoForge bug where none of the Cobblemon plants/berries could be placed into pots.
+- Fixed party overlay not hiding when the player opens the Pokédex scanner.
+- Fixed `hate_entity` task focusing on its own entity, therefore enabling deadly warfare between Zangoose and Seviper.
+- Prehistoric Frozen Pond, Prehistoric Frozen Spike, and Prehistoric Lush Den now actually generate (oops).
+- Fixed Frogadier floating in its `battle_idle` animation.
+- Fixed absence or incorrect mergers in spawning conditions, causing the max height/depth of conditions to use the min value instead.
+- Added stricter riding checks on server side to prevent possible packet forgery when a player tries to ride Pokémon.
+- Fixed Pokémon cries and animation sounds played from GUIs, such as the starter selection screen and the Pokédex, being tied to the Master volume slider instead of Friendly Creatures.
+- Fixed Archeops T-posing during its `air_cry` animation.
+
+### Developer
+- Bumped NeoForge to `21.1.195` to get access to MixinExtras `0.5` and the expressions annotation.
+- New Platform Event `PLAYER_RESPAWN` which is fired when a player respawns (either through death or returning from the end).
+- Platform Events `SERVER_PLAYER_TICK_PRE` and `SERVER_PLAYER_TICK_POST` no longer fire when the player is dead.
+  - It is now tied much closer to the actual entity rather than the player or their connection.
+
+### Molang & Datapacks
+- Fixed `q.pokemon.nature` returning class instance instead of proper string value (`cobblemon:adamant`).
+- Fixed `q.entity.is_looking_at` result being always `1` for whatever entity passed as the target parameter.
+- Added hate chance optional parameter to `hate_entity` task. `1.0` will make an entity always attack the target.
+
+### Localization
+- Updated translations for:
+  - Russian
+  - Japanese
+  - Brazilian Portuguese

changelogs/CHANGELOG-1.8.4.md

@@ -0,0 +1,25 @@
+# Changelog
+## [1.8.4 (October 27th, 2026)](#1-8-4)
+
+### Changes
+- The Froakie line now blinks. The world will never be the same.
+
+### Fixes
+- Fixed heaps of spawns not working. This was caused by us missing something before release. RIP.
+- Fixed a crash caused by Fearow blinking while you're riding one. Makes sense to me.
+- Fixed Minior's "Shields Down" ability being very broken.
+- Fixed Dusclops using Squirtle's cry sound (lol).
+- Fixed blank Cooking Pot recipe book entries and missing tabs on Fabric.
+- Fixed a hitbox issue with placeable Orb held items attached to a ceiling.
+- Fixed something sneaky. I'll tell you about it later.
+
+### Molang & Datapacks
+- Added `q.target_fainted` function to move action effects that checks if any opponents fainted from the move.
+
+### Particles
+- Updated Water Shuriken effect to be timed better when the opponent faints.
+
+### Localization
+- Updated translations for:
+  - Korean
+  - Simplified Chinese

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

@@ -15,6 +15,7 @@ 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.block.HealingMachineBlock;
 import com.cobblemon.mod.common.duck.ServerLevelDuck;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules;
@@ -22,10 +23,14 @@ 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.core.BlockPos;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -33,6 +38,9 @@ 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 org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Optional;
 
 @Mixin(ServerPlayer.class)
 public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
@@ -142,4 +150,17 @@ public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
                         ((ServerLevelDuck) this.serverLevel()).cobblemon$getLevelResourceLocation()
                 );
     }
+
+    @Inject(
+            method = "findRespawnAndUseSpawnBlock(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/core/BlockPos;FZZ)Ljava/util/Optional;",
+            at = @At(value = "HEAD"),
+            cancellable = true
+    )
+    private static void cobblemon$useHealthStationAsRespawn(ServerLevel level, BlockPos pos, float angle, boolean forced, boolean keepInventory, CallbackInfoReturnable<Optional<ServerPlayer.RespawnPosAngle>> cir) {
+        BlockState state = level.getBlockState(pos);
+        Block block = state.getBlock();
+        if (block instanceof HealingMachineBlock && HealingMachineBlock.Companion.canSetSpawn(level)) {
+            cir.setReturnValue(HealingMachineBlock.Companion.findStandUpPosition(EntityType.PLAYER, level, pos).map((vec3) -> ServerPlayer.RespawnPosAngle.of(vec3, pos)));
+        }
+    }
 }

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

@@ -69,7 +69,7 @@ public abstract class ClientRecipeBookMixin {
                     value = "INVOKE",
                     target = "Lcom/google/common/collect/ImmutableMap;copyOf(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;"
             ))
-    private void addCustomAggregateCategories(Iterable<RecipeHolder<?>> recipes, RegistryAccess registryAccess, CallbackInfo ci, @Local(name = "map2") Map<RecipeBookCategories, List<RecipeCollection>> map2) {
+    private void addCustomAggregateCategories(Iterable<RecipeHolder<?>> recipes, RegistryAccess registryAccess, CallbackInfo ci, @Local(ordinal = 1) Map<RecipeBookCategories, List<RecipeCollection>> map2) {
         CobblemonRecipeCategories.Companion.getCustomAggregateCategories().forEach((recipeBookCategories, list) -> map2.put(recipeBookCategories, (List) list.stream().flatMap((recipeBookCategoriesx) -> ((List) map2.getOrDefault(recipeBookCategoriesx, ImmutableList.of())).stream()).collect(ImmutableList.toImmutableList())));
     }
 }

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

@@ -20,14 +20,14 @@ import org.spongepowered.asm.mixin.injection.At;
 
 @Mixin(RecipeBookComponent.class)
 public class RecipeBookComponentMixin {
-    @Definition(id = "recipeBookCategories", local = @Local(name = "recipeBookCategories"))
+    @Definition(id = "recipeBookCategories", local = @Local(type = RecipeBookCategories.class))
     @Definition(id = "FURNACE_SEARCH", field = "Lnet/minecraft/client/RecipeBookCategories;FURNACE_SEARCH:Lnet/minecraft/client/RecipeBookCategories;")
     @Expression("recipeBookCategories != FURNACE_SEARCH")
     @ModifyExpressionValue(
             method = "updateTabs",
             at = @At(value = "MIXINEXTRAS:EXPRESSION")
     )
-    private boolean notCookingPotSearch(boolean original, @Local(name = "recipeBookCategories") RecipeBookCategories recipeBookCategories) {
+    private boolean notCookingPotSearch(boolean original, @Local RecipeBookCategories recipeBookCategories) {
         return original && recipeBookCategories != CobblemonRecipeCategories.COOKING_POT_SEARCH.toVanillaCategory();
     }
 }

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

@@ -60,8 +60,6 @@ import com.cobblemon.mod.common.api.storage.pc.PCStore
 import com.cobblemon.mod.common.api.storage.pc.link.PCLinkManager
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreManager
 import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import com.cobblemon.mod.common.api.storage.player.adapter.BadgeMongoBackend
-import com.cobblemon.mod.common.api.storage.player.adapter.BadgeNbtBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.DexDataMongoBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.DexDataNbtBackend
 import com.cobblemon.mod.common.api.storage.player.adapter.PlayerDataJsonBackend
@@ -393,13 +391,10 @@ object Cobblemon {
 
                     val tmMoveFactory = CachedPlayerDataStoreFactory(TMMoveNbtBackend())
                     tmMoveFactory.setup(server)
-                    val badgeFactory = CachedPlayerDataStoreFactory(BadgeNbtBackend())
-                    badgeFactory.setup(server)
 
                     playerDataManager.setFactory(generalJsonFactory, PlayerInstancedDataStoreTypes.GENERAL)
                     playerDataManager.setFactory(pokedexNbtFactory, PlayerInstancedDataStoreTypes.POKEDEX)
                     playerDataManager.setFactory(tmMoveFactory, PlayerInstancedDataStoreTypes.TM_MOVES)
-                    playerDataManager.setFactory(badgeFactory, PlayerInstancedDataStoreTypes.BADGES)
 
                     if (config.storageFormat == "nbt") {
                         NBTStoreAdapter(pokemonStoreRoot.absolutePath, useNestedFolders = true, folderPerClass = true)
@@ -430,15 +425,10 @@ object Cobblemon {
                                 TMMoveMongoBackend(mongoClient, config.mongoDBDatabaseName, "TMMovesCollection")
                         )
                         tmMovesMongoFactory.setup(server)
-                        val badgesMongoFactory = CachedPlayerDataStoreFactory(
-                            BadgeMongoBackend(mongoClient, config.mongoDBDatabaseName, "BadgesCollection")
-                        )
-                        badgesMongoFactory.setup(server)
 
                         playerDataManager.setFactory(generalMongoFactory, PlayerInstancedDataStoreTypes.GENERAL)
                         playerDataManager.setFactory(pokedexMongoFactory, PlayerInstancedDataStoreTypes.POKEDEX)
                         playerDataManager.setFactory(tmMovesMongoFactory, PlayerInstancedDataStoreTypes.TM_MOVES)
-                        playerDataManager.setFactory(badgesMongoFactory, PlayerInstancedDataStoreTypes.BADGES)
                         MongoDBStoreAdapter(mongoClient, config.mongoDBDatabaseName)
                     } catch (e: ClassNotFoundException) {
                         LOGGER.error("MongoDB driver not found.")
@@ -623,7 +613,6 @@ object Cobblemon {
         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("tm"), TmArgumentType::class, SingletonArgumentInfo.contextFree(TmArgumentType::tm))
-        this.implementation.registerCommandArgument(cobblemonResource("badge"), BadgeArgumentType::class, SingletonArgumentInfo.contextFree(BadgeArgumentType::badge))
     }
 
 }

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

@@ -8,6 +8,7 @@
 
 package com.cobblemon.mod.common
 
+import com.cobblemon.mod.common.block.appliances.CopperFridgeBlockEntity
 import com.cobblemon.mod.common.block.entity.*
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
 import com.cobblemon.mod.common.block.multiblock.FossilMultiblockBuilder
@@ -126,4 +127,19 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
             CobblemonBlocks.MISTLEAF
         ).build(null)
     )
+
+    @JvmField
+    val COPPER_FRIDGE: BlockEntityType<CopperFridgeBlockEntity> = this.create(
+        "copper_fridge",
+        BlockEntityType.Builder.of(::CopperFridgeBlockEntity,
+            CobblemonBlocks.COPPER_FRIDGE,
+            CobblemonBlocks.EXPOSED_COPPER_FRIDGE,
+            CobblemonBlocks.WEATHERED_COPPER_FRIDGE,
+            CobblemonBlocks.OXIDIZED_COPPER_FRIDGE,
+            CobblemonBlocks.WAXED_COPPER_FRIDGE,
+            CobblemonBlocks.WAXED_EXPOSED_COPPER_FRIDGE,
+            CobblemonBlocks.WAXED_WEATHERED_COPPER_FRIDGE,
+            CobblemonBlocks.WAXED_OXIDIZED_COPPER_FRIDGE
+        ).build(null)
+    )
 }

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

@@ -12,6 +12,7 @@ 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.LecternBlock
+import com.cobblemon.mod.common.block.appliances.*
 import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
 import com.cobblemon.mod.common.block.campfirepot.CampfirePotBlock
@@ -28,12 +29,7 @@ import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
 import com.cobblemon.mod.common.block.tmmachine.TMMachineBlock
 import com.cobblemon.mod.common.block.general.MintLitterBlock
-import com.cobblemon.mod.common.mixin.invoker.BlocksInvoker
-import com.cobblemon.mod.common.mixin.invoker.DoorBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.FireBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.PressurePlateBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.StairsBlockInvoker
-import com.cobblemon.mod.common.mixin.invoker.TrapdoorBlockInvoker
+import com.cobblemon.mod.common.mixin.invoker.*
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.BlockPos
@@ -821,6 +817,93 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val DISPLAY_CASE = create("display_case", DisplayCaseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3F).requiresCorrectToolForDrops()))
 
+    //Rotom Blocks
+    //Oven
+    @JvmField
+    val COPPER_OVEN = create("copper_oven", WeatheringCopperOvenBlock(WeatheringCopper.WeatherState.UNAFFECTED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_ORANGE).requiresCorrectToolForDrops().strength(3.0f, 6.0f).sound(SoundType.COPPER).pushReaction(PushReaction.BLOCK)))
+    @JvmField
+    val EXPOSED_COPPER_OVEN = create("exposed_copper_oven", WeatheringCopperOvenBlock(WeatheringCopper.WeatherState.EXPOSED, BlockBehaviour.Properties.ofFullCopy(COPPER_OVEN).mapColor(MapColor.TERRACOTTA_LIGHT_GRAY)))
+    @JvmField
+    val WEATHERED_COPPER_OVEN = create("weathered_copper_oven", WeatheringCopperOvenBlock(WeatheringCopper.WeatherState.WEATHERED, BlockBehaviour.Properties.ofFullCopy(COPPER_OVEN).mapColor(MapColor.WARPED_STEM)))
+    @JvmField
+    val OXIDIZED_COPPER_OVEN = create("oxidized_copper_oven", WeatheringCopperOvenBlock(WeatheringCopper.WeatherState.OXIDIZED, BlockBehaviour.Properties.ofFullCopy(COPPER_OVEN).mapColor(MapColor.WARPED_NYLIUM)))
+    @JvmField
+    val WAXED_COPPER_OVEN = create("waxed_copper_oven", CopperOvenBlock(BlockBehaviour.Properties.ofFullCopy(COPPER_OVEN)))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_OVEN = create("waxed_exposed_copper_oven", CopperOvenBlock(BlockBehaviour.Properties.ofFullCopy(EXPOSED_COPPER_OVEN)))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_OVEN = create("waxed_weathered_copper_oven", CopperOvenBlock(BlockBehaviour.Properties.ofFullCopy(WEATHERED_COPPER_OVEN)))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_OVEN = create("waxed_oxidized_copper_oven", CopperOvenBlock(BlockBehaviour.Properties.ofFullCopy(OXIDIZED_COPPER_OVEN)))
+    //Washer
+    @JvmField
+    val COPPER_WASHER = create("copper_washer", WeatheringCopperWasherBlock(WeatheringCopper.WeatherState.UNAFFECTED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_ORANGE).requiresCorrectToolForDrops().strength(3.0f, 6.0f).sound(SoundType.COPPER).pushReaction(PushReaction.BLOCK)))
+    @JvmField
+    val EXPOSED_COPPER_WASHER = create("exposed_copper_washer", WeatheringCopperWasherBlock(WeatheringCopper.WeatherState.EXPOSED, BlockBehaviour.Properties.ofFullCopy(COPPER_WASHER).mapColor(MapColor.TERRACOTTA_LIGHT_GRAY)))
+    @JvmField
+    val WEATHERED_COPPER_WASHER = create("weathered_copper_washer", WeatheringCopperWasherBlock(WeatheringCopper.WeatherState.WEATHERED, BlockBehaviour.Properties.ofFullCopy(COPPER_WASHER).mapColor(MapColor.WARPED_STEM)))
+    @JvmField
+    val OXIDIZED_COPPER_WASHER = create("oxidized_copper_washer", WeatheringCopperWasherBlock(WeatheringCopper.WeatherState.OXIDIZED, BlockBehaviour.Properties.ofFullCopy(COPPER_WASHER).mapColor(MapColor.WARPED_NYLIUM)))
+    @JvmField
+    val WAXED_COPPER_WASHER = create("waxed_copper_washer", CopperWasherBlock(BlockBehaviour.Properties.ofFullCopy(COPPER_WASHER)))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_WASHER = create("waxed_exposed_copper_washer", CopperWasherBlock(BlockBehaviour.Properties.ofFullCopy(EXPOSED_COPPER_WASHER)))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_WASHER = create("waxed_weathered_copper_washer", CopperWasherBlock(BlockBehaviour.Properties.ofFullCopy(WEATHERED_COPPER_WASHER)))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_WASHER = create("waxed_oxidized_copper_washer", CopperWasherBlock(BlockBehaviour.Properties.ofFullCopy(OXIDIZED_COPPER_WASHER)))
+    //Fan
+    @JvmField
+    val COPPER_FAN = create("copper_fan", WeatheringCopperFanBlock(WeatheringCopper.WeatherState.UNAFFECTED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_ORANGE).requiresCorrectToolForDrops().strength(3.0f, 6.0f).sound(SoundType.COPPER).pushReaction(PushReaction.DESTROY)))
+    @JvmField
+    val EXPOSED_COPPER_FAN = create("exposed_copper_fan", WeatheringCopperFanBlock(WeatheringCopper.WeatherState.EXPOSED, BlockBehaviour.Properties.ofFullCopy(COPPER_FAN).mapColor(MapColor.TERRACOTTA_LIGHT_GRAY)))
+    @JvmField
+    val WEATHERED_COPPER_FAN = create("weathered_copper_fan", WeatheringCopperFanBlock(WeatheringCopper.WeatherState.WEATHERED, BlockBehaviour.Properties.ofFullCopy(COPPER_FAN).mapColor(MapColor.WARPED_STEM)))
+    @JvmField
+    val OXIDIZED_COPPER_FAN = create("oxidized_copper_fan", WeatheringCopperFanBlock(WeatheringCopper.WeatherState.OXIDIZED, BlockBehaviour.Properties.ofFullCopy(COPPER_FAN).mapColor(MapColor.WARPED_NYLIUM)))
+    @JvmField
+    val WAXED_COPPER_FAN = create("waxed_copper_fan", CopperFanBlock(BlockBehaviour.Properties.ofFullCopy(COPPER_FAN)))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_FAN = create("waxed_exposed_copper_fan", CopperFanBlock(BlockBehaviour.Properties.ofFullCopy(EXPOSED_COPPER_FAN)))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_FAN = create("waxed_weathered_copper_fan", CopperFanBlock(BlockBehaviour.Properties.ofFullCopy(WEATHERED_COPPER_FAN)))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_FAN = create("waxed_oxidized_copper_fan", CopperFanBlock(BlockBehaviour.Properties.ofFullCopy(OXIDIZED_COPPER_FAN)))
+    //Mower
+    @JvmField
+    val COPPER_MOWER = create("copper_mower", WeatheringCopperMowerBlock(WeatheringCopper.WeatherState.UNAFFECTED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_ORANGE).requiresCorrectToolForDrops().strength(3.0f, 6.0f).sound(SoundType.COPPER).pushReaction(PushReaction.NORMAL)))
+    @JvmField
+    val EXPOSED_COPPER_MOWER = create("exposed_copper_mower", WeatheringCopperMowerBlock(WeatheringCopper.WeatherState.EXPOSED, BlockBehaviour.Properties.ofFullCopy(COPPER_MOWER).mapColor(MapColor.TERRACOTTA_LIGHT_GRAY)))
+    @JvmField
+    val WEATHERED_COPPER_MOWER = create("weathered_copper_mower", WeatheringCopperMowerBlock(WeatheringCopper.WeatherState.WEATHERED, BlockBehaviour.Properties.ofFullCopy(COPPER_MOWER).mapColor(MapColor.WARPED_STEM)))
+    @JvmField
+    val OXIDIZED_COPPER_MOWER = create("oxidized_copper_mower", WeatheringCopperMowerBlock(WeatheringCopper.WeatherState.OXIDIZED, BlockBehaviour.Properties.ofFullCopy(COPPER_MOWER).mapColor(MapColor.WARPED_NYLIUM)))
+    @JvmField
+    val WAXED_COPPER_MOWER = create("waxed_copper_mower", CopperMowerBlock(BlockBehaviour.Properties.ofFullCopy(COPPER_MOWER)))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_MOWER = create("waxed_exposed_copper_mower", CopperMowerBlock(BlockBehaviour.Properties.ofFullCopy(EXPOSED_COPPER_MOWER)))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_MOWER = create("waxed_weathered_copper_mower", CopperMowerBlock(BlockBehaviour.Properties.ofFullCopy(WEATHERED_COPPER_MOWER)))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_MOWER = create("waxed_oxidized_copper_mower", CopperMowerBlock(BlockBehaviour.Properties.ofFullCopy(OXIDIZED_COPPER_MOWER)))
+    //Fridge
+    @JvmField
+    val COPPER_FRIDGE = create("copper_fridge", WeatheringCopperFridgeBlock(WeatheringCopper.WeatherState.UNAFFECTED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_ORANGE).requiresCorrectToolForDrops().strength(3.0f, 6.0f).sound(SoundType.COPPER).pushReaction(PushReaction.BLOCK)))
+    @JvmField
+    val EXPOSED_COPPER_FRIDGE = create("exposed_copper_fridge", WeatheringCopperFridgeBlock(WeatheringCopper.WeatherState.EXPOSED, BlockBehaviour.Properties.ofFullCopy(COPPER_FRIDGE).mapColor(MapColor.TERRACOTTA_LIGHT_GRAY)))
+    @JvmField
+    val WEATHERED_COPPER_FRIDGE = create("weathered_copper_fridge", WeatheringCopperFridgeBlock(WeatheringCopper.WeatherState.WEATHERED, BlockBehaviour.Properties.ofFullCopy(COPPER_FRIDGE).mapColor(MapColor.WARPED_STEM)))
+    @JvmField
+    val OXIDIZED_COPPER_FRIDGE = create("oxidized_copper_fridge", WeatheringCopperFridgeBlock(WeatheringCopper.WeatherState.OXIDIZED, BlockBehaviour.Properties.ofFullCopy(COPPER_FRIDGE).mapColor(MapColor.WARPED_NYLIUM)))
+    @JvmField
+    val WAXED_COPPER_FRIDGE = create("waxed_copper_fridge", CopperFridgeBlock(BlockBehaviour.Properties.ofFullCopy(COPPER_FRIDGE)))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_FRIDGE = create("waxed_exposed_copper_fridge", CopperFridgeBlock(BlockBehaviour.Properties.ofFullCopy(EXPOSED_COPPER_FRIDGE)))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_FRIDGE = create("waxed_weathered_copper_fridge", CopperFridgeBlock(BlockBehaviour.Properties.ofFullCopy(WEATHERED_COPPER_FRIDGE)))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_FRIDGE = create("waxed_oxidized_copper_fridge", CopperFridgeBlock(BlockBehaviour.Properties.ofFullCopy(OXIDIZED_COPPER_FRIDGE)))
+
     // TODO after 1.7
 //    @JvmField
 //    val INCENSE_SWEET = create("incense_sweet", SweetIncenseBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.DISPLAY_CASE_SOUNDS).noOcclusion().pushReaction(PushReaction.BLOCK).mapColor(MapColor.STONE).strength(0.3F)))
@@ -849,7 +932,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val GALARICA_NUT_BUSH = this.create("galarica_nut_bush", NutBushBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).randomTicks().noCollission().sound(SoundType.SWEET_BERRY_BUSH).pushReaction(PushReaction.DESTROY)))
 
-
     @JvmField
     val RED_MINT_LEAF_LITTER = this.mintLitter("red_mint_leaf_litter", MapColor.COLOR_RED)
     @JvmField
@@ -927,6 +1009,57 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
         SACCHARINE_LOG to STRIPPED_SACCHARINE_LOG,
         SACCHARINE_LOG_SLATHERED to STRIPPED_SACCHARINE_LOG
     )
+    /**Same idea as above, but for Copper Oxidation over time (or when inverted, scraping with an axe)*/
+    fun oxidizingBlocks(): Map<Block, Block> = mapOf(
+        //Ovens
+        COPPER_OVEN to EXPOSED_COPPER_OVEN,
+        EXPOSED_COPPER_OVEN to WEATHERED_COPPER_OVEN,
+        WEATHERED_COPPER_OVEN to OXIDIZED_COPPER_OVEN,
+        //Washers
+        COPPER_WASHER to EXPOSED_COPPER_WASHER,
+        EXPOSED_COPPER_WASHER to WEATHERED_COPPER_WASHER,
+        WEATHERED_COPPER_WASHER to OXIDIZED_COPPER_WASHER,
+        //Fans
+        COPPER_FAN to EXPOSED_COPPER_FAN,
+        EXPOSED_COPPER_FAN to WEATHERED_COPPER_FAN,
+        WEATHERED_COPPER_FAN to OXIDIZED_COPPER_FAN,
+        //Fridges
+        COPPER_FRIDGE to EXPOSED_COPPER_FRIDGE,
+        EXPOSED_COPPER_FRIDGE to WEATHERED_COPPER_FRIDGE,
+        WEATHERED_COPPER_FRIDGE to OXIDIZED_COPPER_FRIDGE,
+        //Mowers
+        COPPER_MOWER to EXPOSED_COPPER_MOWER,
+        EXPOSED_COPPER_MOWER to WEATHERED_COPPER_MOWER,
+        WEATHERED_COPPER_MOWER to OXIDIZED_COPPER_MOWER
+    )
+    /**Same idea as above, but for waxing blocks with Honeycomb (or unwaxing them with an axe)*/
+    fun waxingBlocks(): Map<Block, Block> = mapOf(
+        //Ovens
+        COPPER_OVEN to WAXED_COPPER_OVEN,
+        EXPOSED_COPPER_OVEN to WAXED_EXPOSED_COPPER_OVEN,
+        WEATHERED_COPPER_OVEN to WAXED_WEATHERED_COPPER_OVEN,
+        OXIDIZED_COPPER_OVEN to WAXED_OXIDIZED_COPPER_OVEN,
+        //Washers
+        COPPER_WASHER to WAXED_COPPER_WASHER,
+        EXPOSED_COPPER_WASHER to WAXED_EXPOSED_COPPER_WASHER,
+        WEATHERED_COPPER_WASHER to WAXED_WEATHERED_COPPER_WASHER,
+        OXIDIZED_COPPER_WASHER to WAXED_OXIDIZED_COPPER_WASHER,
+        //Fans
+        COPPER_FAN to WAXED_COPPER_FAN,
+        EXPOSED_COPPER_FAN to WAXED_EXPOSED_COPPER_FAN,
+        WEATHERED_COPPER_FAN to WAXED_WEATHERED_COPPER_FAN,
+        OXIDIZED_COPPER_FAN to WAXED_OXIDIZED_COPPER_FAN,
+        //Fridges
+        COPPER_FRIDGE to WAXED_COPPER_FRIDGE,
+        EXPOSED_COPPER_FRIDGE to WAXED_EXPOSED_COPPER_FRIDGE,
+        WEATHERED_COPPER_FRIDGE to WAXED_WEATHERED_COPPER_FRIDGE,
+        OXIDIZED_COPPER_FRIDGE to WAXED_OXIDIZED_COPPER_FRIDGE,
+        //Mowers
+        COPPER_MOWER to WAXED_COPPER_MOWER,
+        EXPOSED_COPPER_MOWER to WAXED_EXPOSED_COPPER_MOWER,
+        WEATHERED_COPPER_MOWER to WAXED_WEATHERED_COPPER_MOWER,
+        OXIDIZED_COPPER_MOWER to WAXED_OXIDIZED_COPPER_MOWER
+    )
 
     private fun apricornBlock(name: String, apricorn: Apricorn): ApricornBlock = this.create(name, ApricornBlock(BlockBehaviour.Properties.of().mapColor(apricorn.mapColor()).randomTicks().strength(Blocks.OAK_LOG.defaultDestroyTime(), Blocks.OAK_LOG.explosionResistance).sound(SoundType.WOOD).noOcclusion(), apricorn))
 

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

@@ -73,7 +73,6 @@ object CobblemonCommands {
         PcTakeCommand.register(dispatcher)
         GiveTmCommand.register(dispatcher)
         TmCommand.register(dispatcher)
-        BadgeCommand.register(dispatcher)
 
         // Possibly lock down registration if and only if under dev environment or running in an environment
         // with a certain system environment variable set

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

@@ -1517,6 +1517,87 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val BLANK_TM = this.create("blank_tm", CobblemonItem(Item.Properties()))
 
+    @JvmField
+    val COPPER_OVEN = this.create("copper_oven", BlockItem(CobblemonBlocks.COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val EXPOSED_COPPER_OVEN = this.create("exposed_copper_oven", BlockItem(CobblemonBlocks.EXPOSED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val WEATHERED_COPPER_OVEN = this.create("weathered_copper_oven", BlockItem(CobblemonBlocks.WEATHERED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val OXIDIZED_COPPER_OVEN = this.create("oxidized_copper_oven", BlockItem(CobblemonBlocks.OXIDIZED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val WAXED_COPPER_OVEN = this.create("waxed_copper_oven", BlockItem(CobblemonBlocks.WAXED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_OVEN = this.create("waxed_exposed_copper_oven", BlockItem(CobblemonBlocks.WAXED_EXPOSED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_OVEN = this.create("waxed_weathered_copper_oven", BlockItem(CobblemonBlocks.WAXED_WEATHERED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_OVEN = this.create("waxed_oxidized_copper_oven", BlockItem(CobblemonBlocks.WAXED_OXIDIZED_COPPER_OVEN, Item.Properties()))
+    @JvmField
+    val COPPER_WASHER = this.create("copper_washer", BlockItem(CobblemonBlocks.COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val EXPOSED_COPPER_WASHER = this.create("exposed_copper_washer", BlockItem(CobblemonBlocks.EXPOSED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val WEATHERED_COPPER_WASHER = this.create("weathered_copper_washer", BlockItem(CobblemonBlocks.WEATHERED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val OXIDIZED_COPPER_WASHER = this.create("oxidized_copper_washer", BlockItem(CobblemonBlocks.OXIDIZED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val WAXED_COPPER_WASHER = this.create("waxed_copper_washer", BlockItem(CobblemonBlocks.WAXED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_WASHER = this.create("waxed_exposed_copper_washer", BlockItem(CobblemonBlocks.WAXED_EXPOSED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_WASHER = this.create("waxed_weathered_copper_washer", BlockItem(CobblemonBlocks.WAXED_WEATHERED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_WASHER = this.create("waxed_oxidized_copper_washer", BlockItem(CobblemonBlocks.WAXED_OXIDIZED_COPPER_WASHER, Item.Properties()))
+    @JvmField
+    val COPPER_FAN = this.create("copper_fan", BlockItem(CobblemonBlocks.COPPER_FAN, Item.Properties()))
+    @JvmField
+    val EXPOSED_COPPER_FAN = this.create("exposed_copper_fan", BlockItem(CobblemonBlocks.EXPOSED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val WEATHERED_COPPER_FAN = this.create("weathered_copper_fan", BlockItem(CobblemonBlocks.WEATHERED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val OXIDIZED_COPPER_FAN = this.create("oxidized_copper_fan", BlockItem(CobblemonBlocks.OXIDIZED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val WAXED_COPPER_FAN = this.create("waxed_copper_fan", BlockItem(CobblemonBlocks.WAXED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_FAN = this.create("waxed_exposed_copper_fan", BlockItem(CobblemonBlocks.WAXED_EXPOSED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_FAN = this.create("waxed_weathered_copper_fan", BlockItem(CobblemonBlocks.WAXED_WEATHERED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_FAN = this.create("waxed_oxidized_copper_fan", BlockItem(CobblemonBlocks.WAXED_OXIDIZED_COPPER_FAN, Item.Properties()))
+    @JvmField
+    val COPPER_MOWER = this.create("copper_mower", BlockItem(CobblemonBlocks.COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val EXPOSED_COPPER_MOWER = this.create("exposed_copper_mower", BlockItem(CobblemonBlocks.EXPOSED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val WEATHERED_COPPER_MOWER = this.create("weathered_copper_mower", BlockItem(CobblemonBlocks.WEATHERED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val OXIDIZED_COPPER_MOWER = this.create("oxidized_copper_mower", BlockItem(CobblemonBlocks.OXIDIZED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val WAXED_COPPER_MOWER = this.create("waxed_copper_mower", BlockItem(CobblemonBlocks.WAXED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_MOWER = this.create("waxed_exposed_copper_mower", BlockItem(CobblemonBlocks.WAXED_EXPOSED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_MOWER = this.create("waxed_weathered_copper_mower", BlockItem(CobblemonBlocks.WAXED_WEATHERED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_MOWER = this.create("waxed_oxidized_copper_mower", BlockItem(CobblemonBlocks.WAXED_OXIDIZED_COPPER_MOWER, Item.Properties()))
+    @JvmField
+    val COPPER_FRIDGE = this.create("copper_fridge", BlockItem(CobblemonBlocks.COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val EXPOSED_COPPER_FRIDGE = this.create("exposed_copper_fridge", BlockItem(CobblemonBlocks.EXPOSED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val WEATHERED_COPPER_FRIDGE = this.create("weathered_copper_fridge", BlockItem(CobblemonBlocks.WEATHERED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val OXIDIZED_COPPER_FRIDGE = this.create("oxidized_copper_fridge", BlockItem(CobblemonBlocks.OXIDIZED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val WAXED_COPPER_FRIDGE = this.create("waxed_copper_fridge", BlockItem(CobblemonBlocks.WAXED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val WAXED_EXPOSED_COPPER_FRIDGE = this.create("waxed_exposed_copper_fridge", BlockItem(CobblemonBlocks.WAXED_EXPOSED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val WAXED_WEATHERED_COPPER_FRIDGE = this.create("waxed_weathered_copper_fridge", BlockItem(CobblemonBlocks.WAXED_WEATHERED_COPPER_FRIDGE, Item.Properties()))
+    @JvmField
+    val WAXED_OXIDIZED_COPPER_FRIDGE = this.create("waxed_oxidized_copper_fridge", BlockItem(CobblemonBlocks.WAXED_OXIDIZED_COPPER_FRIDGE, Item.Properties()))
+
     // Type Gems
     @JvmField
     val NORMAL_GEM = this.create("normal_gem", GemItem(Item.Properties(), CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL))

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

@@ -432,7 +432,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(SpeciesFeatureAssignmentSyncPacket.ID, SpeciesFeatureAssignmentSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(NaturalMaterialRegistrySyncPacket.ID, NaturalMaterialRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(FossilRegistrySyncPacket.ID, FossilRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
-        list.add(PacketRegisterInfo(BadgeRegistrySyncPacket.ID, BadgeRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(NPCRegistrySyncPacket.ID, NPCRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(PokeRodRegistrySyncPacket.ID, PokeRodRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(ScriptRegistrySyncPacket.ID, ScriptRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))

common/src/main/kotlin/com/cobblemon/mod/common/api/ai/config/task/HateEntityTaskConfig.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.api.ai.config.task
 
 import com.bedrockk.molang.Expression
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.ai.BehaviourConfigurationContext
 import com.cobblemon.mod.common.api.ai.ExpressionOrEntityVariable
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMostSpecificMoLangValue
@@ -17,6 +18,7 @@ import com.cobblemon.mod.common.util.asExpression
 import com.cobblemon.mod.common.util.mainThreadRuntime
 import com.cobblemon.mod.common.util.resolveBoolean
 import com.cobblemon.mod.common.util.withQueryValue
+import com.cobblemon.mod.common.world.gamerules.CobblemonGameRules
 import com.mojang.datafixers.util.Either
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.ai.behavior.BehaviorControl
@@ -34,6 +36,8 @@ import net.minecraft.world.entity.ai.sensing.SensorType
 class HateEntityTaskConfig : SingleTaskConfig {
     val entityCondition: Expression = "true".asExpression()
     val range: ExpressionOrEntityVariable = Either.left("24".asExpression())
+    val chance: Float = Cobblemon.config.predationChance
+    private val coercedChance = chance.coerceIn(0f, 1f)
 
     override fun getVariables(entity: LivingEntity, behaviourConfigurationContext: BehaviourConfigurationContext) = emptyList<MoLangConfigVariable>()
     override fun createTask(
@@ -43,24 +47,44 @@ class HateEntityTaskConfig : SingleTaskConfig {
         val range = range.resolveFloat(behaviourConfigurationContext.runtime)
         behaviourConfigurationContext.addMemories(
             MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES,
-            MemoryModuleType.ANGRY_AT
+            MemoryModuleType.ANGRY_AT,
+            MemoryModuleType.ATTACK_TARGET
         )
         behaviourConfigurationContext.addSensors(SensorType.NEAREST_LIVING_ENTITIES)
         return BehaviorBuilder.create { instance ->
             instance.group(
                 instance.present(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES),
-                instance.registered(MemoryModuleType.ANGRY_AT)
-            ).apply(instance) { entities, angryAt ->
+                instance.registered(MemoryModuleType.ANGRY_AT),
+                instance.registered(MemoryModuleType.ATTACK_TARGET),
+            ).apply(instance) { entities, angryAt, attackTarget ->
                 Trigger { world, entity, _ ->
-                    val target = instance.get(entities).findClosest {
-                        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
+                    // bail if gamerule is disabled
+                    if (!world.gameRules.getBoolean(CobblemonGameRules.DO_POKEMON_PREDATION)) return@Trigger false
+                    val target = instance.get(entities).findClosest { hated ->
+                        mainThreadRuntime.withQueryValue("entity", hated.asMostSpecificMoLangValue())
                         return@findClosest mainThreadRuntime.resolveBoolean(entityCondition)
                     }.orElse(null)
 
+                    var shouldTrigger = false
                     if (target != null && target.distanceTo(entity) <= range) {
-                        angryAt.set(target.uuid)
+                        shouldTrigger = when {
+                            // set always attacking if activity chance is equal to 1.0
+                            coercedChance == 1f -> {
+                                angryAt.set(target.uuid)
+                                attackTarget.set(target)
+                                true
+                            }
+                            // roll the dice in other way
+                            coercedChance != 1f && world.random.nextFloat() < coercedChance -> {
+                                angryAt.set(target.uuid)
+                                attackTarget.set(target)
+                                true
+                            }
+                            // fallback to peaceful behavior in unattended cases
+                            else -> false
+                        }
                     }
-                    return@Trigger true
+                    return@Trigger shouldTrigger
                 }
             }
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/badges/Badge.kt

@@ -1,20 +0,0 @@
-package com.cobblemon.mod.common.api.badges
-
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.util.StringRepresentable
-
-class Badge(
-    identifier: ResourceLocation,
-    val name: String,
-    val texture: ResourceLocation,
-    val order: Int
-): StringRepresentable {
-
-    @Transient
-    var identifier: ResourceLocation = identifier
-        internal set
-
-    override fun getSerializedName(): String {
-        return identifier.toString()
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/badges/BadgeManager.kt

@@ -1,54 +0,0 @@
-package com.cobblemon.mod.common.api.badges
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
-import com.cobblemon.mod.common.api.storage.player.InstancedPlayerData
-import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import com.cobblemon.mod.common.api.storage.player.client.ClientBadgeManager
-import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
-import com.cobblemon.mod.common.util.getPlayer
-import com.mojang.serialization.Codec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.resources.ResourceLocation
-import java.util.UUID
-
-class BadgeManager(
-    override val uuid: UUID,
-    val obtainedBadges: MutableSet<ResourceLocation> = mutableSetOf()
-) : InstancedPlayerData {
-
-    val storeType = PlayerInstancedDataStoreTypes.BADGES
-
-    override fun toClientData() = ClientBadgeManager(obtainedBadges.toMutableSet())
-
-    fun give(badge: Badge): Boolean {
-        if (!obtainedBadges.add(badge.identifier)) return false
-        syncAndSave()
-        return true
-    }
-
-    fun remove(badge: Badge): Boolean {
-        if (!obtainedBadges.remove(badge.identifier)) return false
-        syncAndSave()
-        return true
-    }
-
-    private fun syncAndSave() {
-        uuid.getPlayer()?.sendPacket(SetClientPlayerDataPacket(storeType, toClientData()))
-        Cobblemon.playerDataManager.saveSingle(this, storeType)
-    }
-
-    companion object {
-        val CODEC: Codec<BadgeManager> = RecordCodecBuilder.create { instance ->
-            instance.group(
-                Codec.STRING.xmap(UUID::fromString, UUID::toString)
-                    .fieldOf("uuid")
-                    .forGetter { it.uuid },
-                Codec.list(ResourceLocation.CODEC)
-                    .xmap({ it.toMutableSet() }, { it.toList() })
-                    .fieldOf("obtainedBadges")
-                    .forGetter { it.obtainedBadges }
-            ).apply(instance, ::BadgeManager)
-        }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/badges/Badges.kt

@@ -1,64 +0,0 @@
-package com.cobblemon.mod.common.api.badges
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.data.JsonDataRegistry
-import com.cobblemon.mod.common.api.reactive.SimpleObservable
-import com.cobblemon.mod.common.net.messages.client.data.BadgeRegistrySyncPacket
-import com.cobblemon.mod.common.util.adapters.IdentifierAdapter
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.google.gson.Gson
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.server.packs.PackType
-
-object Badges : JsonDataRegistry<Badge> {
-
-    override val id: ResourceLocation = cobblemonResource("badges")
-    override val type: PackType = PackType.SERVER_DATA
-    override val observable = SimpleObservable<Badges>()
-
-    override val gson: Gson = GsonBuilder()
-        .disableHtmlEscaping()
-        .setPrettyPrinting()
-        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-        .create()
-
-    override val typeToken: TypeToken<Badge> = TypeToken.get(Badge::class.java)
-    override val resourcePath: String = "badges"
-
-    private val badges = hashMapOf<ResourceLocation, Badge>()
-
-    override fun reload(data: Map<ResourceLocation, Badge>) {
-        this.badges.clear()
-        data.forEach { (id, badge) ->
-            try {
-                badge.identifier = id
-                this.badges[id] = badge
-            } catch (e: Exception) {
-                Cobblemon.LOGGER.error("Skipped loading the {} badge", id, e)
-            }
-        }
-        Cobblemon.LOGGER.info("Loaded {} badges", this.badges.size)
-        this.observable.emit(this)
-    }
-
-    override fun sync(player: ServerPlayer) {
-        BadgeRegistrySyncPacket(this.all()).sendToPlayer(player)
-    }
-
-    /**
-     * Get all loaded [Badge]s.
-     */
-    @JvmStatic
-    fun all() = this.badges.values.toList()
-
-    /**
-     * Gets a [Badge] by its [ResourceLocation].
-     * @param identifier The identifier of the badge.
-     * @return The [Badge], if loaded, otherwise null.
-     */
-    @JvmStatic
-    fun getByIdentifier(identifier: ResourceLocation): Badge? = this.badges[identifier]
-}

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

@@ -239,6 +239,10 @@ open class PokemonBattle(
     }
 
     fun writeShowdownAction(vararg messages: String) {
+        if (messages.any { it.contains("\n") || it.contains("\r") }) {
+            LOGGER.warn("Refusing to forward Showdown action with an embedded line break for battle {}: {}", battleId, messages.joinToString(" | "))
+            return
+        }
         log(messages.joinToString("\n"))
         ShowdownService.service.send(battleId, messages.toList().toTypedArray())
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/permission/CobblemonPermissions.kt

@@ -145,8 +145,6 @@ object CobblemonPermissions {
     val SPECTATE_BATTLE = this.create("${COMMAND_PREFIX}spectatebattle", PermissionLevel.ALL_COMMANDS)
     @JvmStatic
     val TECHNICAL_MACHINE = this.create("${COMMAND_PREFIX}technicalmachine", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
-    @JvmStatic
-    val BADGE = this.create("${COMMAND_PREFIX}badge", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)
 
     @JvmStatic
     val SEE_HIDDEN_NPCS = this.create("seehiddennpcs", PermissionLevel.CHEAT_COMMANDS_AND_COMMAND_BLOCKS)

common/src/main/kotlin/com/cobblemon/mod/common/api/pokedex/entry/DexEvolutionDisplay.kt

@@ -88,7 +88,7 @@ fun getToolTipHeaderIcon(tradeEvolution: TradeEvolution): CobblemonDexEvolutionR
         lang("ui.pokedex.evolution.trade.tooltip.with_any_species")
     } else {
         PokemonSpecies.getByIdentifier(species.asIdentifierDefaultingNamespace())
-            ?.let { lang("ui.pokedex.evolution.trade.tooltip.with_species", it.translatedName.green()) }
+            ?.let { lang("ui.pokedex.evolution.trade.tooltip.with_species", it.translatedName.plainCopy().green()) }
             ?: lang("ui.pokedex.evolution.trade.tooltip.with_any_species")
     }
     return CobblemonDexEvolutionRequirementDisplay(CobblemonItems.LINK_CABLE, tooltip)
@@ -282,7 +282,7 @@ fun buildLevelRequirement(levelRequirement: LevelRequirement): DexEvolutionRequi
 
 fun buildMoonPhaseRequirement(moonPhaseRequirement: MoonPhaseRequirement): DexEvolutionRequirementDisplay {
     val icon = Items.CLOCK
-    val moonPhaseComponent = moonPhaseRequirement.moonPhase.displayName().green()
+    val moonPhaseComponent = moonPhaseRequirement.moonPhase.displayName().plainCopy().green()
     val tooltip = lang("ui.pokedex.requirement.moon_phase.tooltip", moonPhaseComponent)
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
@@ -290,7 +290,7 @@ fun buildMoonPhaseRequirement(moonPhaseRequirement: MoonPhaseRequirement): DexEv
 
 fun buildMoveSetRequirement(moveSetRequirement: MoveSetRequirement): DexEvolutionRequirementDisplay {
     val icon = CobblemonItems.TECHNICAL_MACHINE
-    val tooltip = lang("ui.pokedex.requirement.has_move.tooltip", moveSetRequirement.move.displayName.green())
+    val tooltip = lang("ui.pokedex.requirement.has_move.tooltip", moveSetRequirement.move.displayName.plainCopy().green())
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
 }
@@ -319,7 +319,7 @@ fun buildMoveTypeRequirement(moveTypeRequirement: MoveTypeRequirement): DexEvolu
         else -> CobblemonItems.NORMAL_GEM
     }
 
-    val tooltip = lang("ui.pokedex.requirement.has_move_type.tooltip", moveTypeRequirement.type.displayName.green())
+    val tooltip = lang("ui.pokedex.requirement.has_move_type.tooltip", moveTypeRequirement.type.displayName.plainCopy().green())
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
 }
@@ -437,7 +437,7 @@ fun buildStructureRequirement(structureRequirement: StructureRequirement, negate
 
 fun buildTimeRangeRequirement(timeRangeRequirement: TimeRangeRequirement): DexEvolutionRequirementDisplay? {
     val icon = Items.CLOCK
-    val timeRangeComponent = timeRangeRequirement.range.displayName() ?: return null
+    val timeRangeComponent = timeRangeRequirement.range.displayName()?.plainCopy() ?: return null
     val tooltip = lang("ui.pokedex.requirement.time_range.tooltip", timeRangeComponent.green())
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
@@ -445,7 +445,7 @@ fun buildTimeRangeRequirement(timeRangeRequirement: TimeRangeRequirement): DexEv
 
 fun buildUseMoveRequirement(useMoveRequirement: UseMoveRequirement): DexEvolutionRequirementDisplay {
     val icon = CobblemonItems.CHOICE_BAND
-    val tooltip = lang("ui.pokedex.requirement.use_move.tooltip", useMoveRequirement.move.displayName.green())
+    val tooltip = lang("ui.pokedex.requirement.use_move.tooltip", useMoveRequirement.move.displayName.plainCopy().green())
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
 }

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

@@ -9,9 +9,12 @@
 package com.cobblemon.mod.common.api.riding.stats
 
 import com.cobblemon.mod.common.api.cooking.Flavour
+import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.util.lang
 import net.minecraft.network.chat.Component
 import net.minecraft.network.chat.MutableComponent
+import net.minecraft.tags.TagKey
+import net.minecraft.world.item.Item
 
 /**
  * A stat that is used for riding Pokémon. The exact implementation of each of these depends on the [com.cobblemon.mod.common.api.riding.controller.RideController].
@@ -20,13 +23,14 @@ import net.minecraft.network.chat.MutableComponent
  * @since February 17th, 2025
  */
 enum class RidingStat(
-    val flavour: Flavour
+    val flavour: Flavour,
+    val powerItem: TagKey<Item>
 ) {
-    ACCELERATION(Flavour.SPICY),
-    SKILL(Flavour.DRY),
-    SPEED(Flavour.SWEET),
-    STAMINA(Flavour.SOUR),
-    JUMP(Flavour.BITTER);
+    ACCELERATION(Flavour.SPICY, CobblemonItemTags.POWER_BRACER),
+    SKILL(Flavour.DRY, CobblemonItemTags.POWER_BELT),
+    SPEED(Flavour.SWEET, CobblemonItemTags.POWER_ANKLET),
+    STAMINA(Flavour.SOUR, CobblemonItemTags.POWER_WEIGHT),
+    JUMP(Flavour.BITTER, CobblemonItemTags.POWER_BAND);
 
     companion object {
         fun getByName(name: String) = RidingStat.entries.firstOrNull { it.name.equals(name, ignoreCase = true) }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/condition/AreaSpawningCondition.kt

@@ -42,8 +42,8 @@ abstract class AreaTypeSpawningCondition<T : AreaSpawnablePosition> : SpawningCo
     override fun copyFrom(other: SpawningCondition<*>, merger: Merger) {
         super.copyFrom(other, merger)
         if (other is AreaTypeSpawningCondition) {
-            merger.mergeSingle(minHeight, other.minHeight)
-            merger.mergeSingle(maxHeight, other.maxHeight)
+            minHeight = merger.mergeSingle(minHeight, other.minHeight)
+            maxHeight = merger.mergeSingle(maxHeight, other.maxHeight)
             neededNearbyBlocks = merger.merge(neededNearbyBlocks, other.neededNearbyBlocks)?.toMutableList()
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/condition/SubmergedSpawningCondition.kt

@@ -46,7 +46,7 @@ abstract class SubmergedTypeSpawningCondition<T : SubmergedSpawnablePosition> :
         super.copyFrom(other, merger)
         if (other is SubmergedTypeSpawningCondition) {
             minDepth = merger.mergeSingle(minDepth, other.minDepth)
-            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
+            maxDepth = merger.mergeSingle(maxDepth, other.maxDepth)
             fluidIsSource = merger.mergeSingle(fluidIsSource, other.fluidIsSource)
             fluid = merger.mergeSingle(fluid, other.fluid)
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/condition/SurfaceSpawningCondition.kt

@@ -39,7 +39,7 @@ abstract class SurfaceTypeSpawningCondition<T : SurfaceSpawnablePosition> : Area
         super.copyFrom(other, merger)
         if (other is SurfaceTypeSpawningCondition) {
             minDepth = merger.mergeSingle(minDepth, other.minDepth)
-            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
+            maxDepth = merger.mergeSingle(maxDepth, other.maxDepth)
             fluid = merger.mergeSingle(fluid, other.fluid)
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/api/spawning/spawner/Spawner.kt

@@ -198,7 +198,17 @@ interface Spawner {
         val mid = chunk.getBlockState(startPos)
         val above = chunk.getBlockState(abovePos)
 
-        return above.isPathfindable(PathComputationType.AIR) && mid.isAir
+        // Above must be non-solid
+        if (!above.isPathfindable(PathComputationType.AIR)) {
+            return false
+        }
+
+        // Position must be non-air
+        if (mid.isAir) {
+            return false
+        }
+
+        return true
     }
 
     fun constrainArea(area: SpawningZoneInput): SpawningZoneInput? {

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

@@ -29,12 +29,8 @@ object CobblemonStats {
     @JvmField
     val BATTLES_WON: CobblemonStat = CobblemonStat("battles_won")
     @JvmField
-    val PVP_BATTLES_WON: CobblemonStat = CobblemonStat("pvp_battles_won")
-    @JvmField
     val BATTLES_LOST: CobblemonStat = CobblemonStat("battles_lost")
     @JvmField
-    val PVP_BATTLES_LOST: CobblemonStat = CobblemonStat("pvp_battles_lost")
-    @JvmField
     val BATTLES_FLED: CobblemonStat = CobblemonStat("battles_fled")
     @JvmField
     val BATTLES_TOTAL: CobblemonStat = CobblemonStat("battles_total")
@@ -72,9 +68,7 @@ object CobblemonStats {
         stats["evolved"] = EVOLVED
         stats["level_up"] = LEVEL_UP
         stats["battles_won"] = BATTLES_WON
-        stats["pvp_battles_won"] = PVP_BATTLES_WON
         stats["battles_lost"] = BATTLES_LOST
-        stats["pvp_battles_lost"] = PVP_BATTLES_LOST
         stats["battles_fled"] = BATTLES_FLED
         stats["battles_total"] = BATTLES_TOTAL
         stats["dex_entries"] = DEX_ENTRIES

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

@@ -10,7 +10,6 @@ package com.cobblemon.mod.common.api.storage.player
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.Cobblemon.MODID
-import com.cobblemon.mod.common.api.badges.BadgeManager
 import com.cobblemon.mod.common.api.pokedex.PokedexManager
 import com.cobblemon.mod.common.api.scheduling.ScheduledTask
 import com.cobblemon.mod.common.api.scheduling.ServerTaskTracker
@@ -77,14 +76,6 @@ open class PlayerInstancedDataStoreManager {
                 .infiniteIterations()
                 .tracker(ServerTaskTracker)
                 .build()
-
-        saveTasks[PlayerInstancedDataStoreTypes.BADGES] = ScheduledTask.Builder()
-            .execute { saveAllOfOneType(PlayerInstancedDataStoreTypes.BADGES) }
-            .delay(30F)
-            .interval(120F)
-            .infiniteIterations()
-            .tracker(ServerTaskTracker)
-            .build()
     }
 
     open fun get(playerId: UUID, dataType: PlayerInstancedDataStoreType): InstancedPlayerData {
@@ -157,9 +148,4 @@ open class PlayerInstancedDataStoreManager {
         }
         return data as TMMoveManager
     }
-
-    fun getBadgeData(player: ServerPlayer): BadgeManager = getBadgeData(player.uuid)
-
-    fun getBadgeData(playerId: UUID): BadgeManager =
-        get(playerId, PlayerInstancedDataStoreTypes.BADGES) as BadgeManager
 }

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

@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.api.storage.player
 
 import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.storage.player.client.ClientBadgeManager
 import com.cobblemon.mod.common.api.storage.player.client.ClientPokedexManager
 import com.cobblemon.mod.common.api.storage.player.client.ClientGeneralPlayerData
 import com.cobblemon.mod.common.api.storage.player.client.ClientTMMoveManager
@@ -36,12 +35,6 @@ object PlayerInstancedDataStoreTypes {
         ClientTMMoveManager::runAction,
         ClientTMMoveManager::runIncremental
     ))
-    val BADGES = register(PlayerInstancedDataStoreType(
-        cobblemonResource("badge_collection"),
-        ClientBadgeManager::decode,
-        ClientBadgeManager::runAction,
-        ClientBadgeManager::runIncremental
-    ))
 
     fun register(type: PlayerInstancedDataStoreType): PlayerInstancedDataStoreType {
         Cobblemon.LOGGER.debug("Registering PlayerInstancedDataStoreType: {}", type.id)

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

@@ -1,38 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.storage.player.adapter
-
-import com.cobblemon.mod.common.api.badges.BadgeManager
-import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import com.cobblemon.mod.common.util.adapters.CodecBackedAdapter
-import com.google.gson.GsonBuilder
-import com.google.gson.reflect.TypeToken
-import com.mongodb.client.MongoClient
-import java.util.UUID
-
-class BadgeMongoBackend(
-    mongoClient: MongoClient,
-    databaseName: String,
-    collectionName: String
-) : MongoBackedPlayerDataStoreBackend<BadgeManager>(
-    mongoClient,
-    databaseName,
-    collectionName,
-    PlayerInstancedDataStoreTypes.BADGES
-) {
-    override val gson = GsonBuilder()
-        .registerTypeAdapter(BadgeManager::class.java, CodecBackedAdapter(BadgeManager.CODEC))
-        .create()
-    override val classToken = TypeToken.get(BadgeManager::class.java)
-    override val defaultData = defaultDataFunc
-
-    companion object {
-        val defaultDataFunc = { uuid: UUID -> BadgeManager(uuid) }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/storage/player/adapter/BadgeNbtBackend.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.storage.player.adapter
-
-import com.cobblemon.mod.common.api.badges.BadgeManager
-import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import java.util.UUID
-
-class BadgeNbtBackend : NbtBackedPlayerData<BadgeManager>("badges", PlayerInstancedDataStoreTypes.BADGES) {
-    override val codec = BadgeManager.CODEC
-    override val defaultData = defaultDataFunc
-
-    companion object {
-        val defaultDataFunc = { uuid: UUID -> BadgeManager(uuid) }
-    }
-}

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

@@ -52,7 +52,7 @@ abstract class FileBasedPlayerDataStoreBackend<T : InstancedPlayerData>(
         val playerFile = filePath(uuid)
         val playerFileOld = filePath(uuid, OLD_FILE_EXTENSION)
         playerFile.parentFile.mkdirs()
-        val loadFallback: (Boolean) -> T = { primaryFileCorrupt ->
+        val loadFallback: () -> T = {
             playerFile.delete()
             if (playerFileOld.exists() && playerFileOld.length() > 0L) {
                 try {
@@ -68,9 +68,7 @@ abstract class FileBasedPlayerDataStoreBackend<T : InstancedPlayerData>(
                 }
             }
             else {
-                if (primaryFileCorrupt) {
-                    Cobblemon.LOGGER.error(".old File $subfolder for $uuid is corrupt or missing. Data is lost")
-                }
+                Cobblemon.LOGGER.error(".old File $subfolder for $uuid is corrupt or missing. Data is lost")
                 playerFileOld.delete()
                 defaultData.invoke(uuid).also(::save)
             }
@@ -82,10 +80,10 @@ abstract class FileBasedPlayerDataStoreBackend<T : InstancedPlayerData>(
             catch (e: Exception) {
                 Cobblemon.LOGGER.warn("Failed to load $subfolder for $uuid due to ${e.message}")
                 Cobblemon.LOGGER.warn(e)
-                loadFallback(true)
+                loadFallback()
             }
         } else {
-            loadFallback(false)
+            loadFallback()
         }.also { it.initialize() }
     }
 

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

@@ -1,42 +0,0 @@
-package com.cobblemon.mod.common.api.storage.player.client
-
-import com.cobblemon.mod.common.api.storage.player.PlayerInstancedDataStoreTypes
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.net.messages.client.SetClientPlayerDataPacket
-import com.cobblemon.mod.common.util.readString
-import com.cobblemon.mod.common.util.writeString
-import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.resources.ResourceLocation
-
-class ClientBadgeManager(
-    val obtainedBadges: MutableSet<ResourceLocation>
-) : ClientInstancedPlayerData {
-
-    override fun encode(buf: RegistryFriendlyByteBuf) {
-        buf.writeCollection(obtainedBadges) { _, id, -> buf.writeString(id.toString()) }
-    }
-
-    companion object {
-        fun decode(buf: RegistryFriendlyByteBuf): SetClientPlayerDataPacket {
-            val badges = buf.readCollection(
-                { mutableSetOf<ResourceLocation>() },
-                { buf.readString().let(ResourceLocation::tryParse) ?: ResourceLocation("minecraft", "empty") }
-            )
-            return SetClientPlayerDataPacket(
-                PlayerInstancedDataStoreTypes.BADGES,
-                ClientBadgeManager(badges)
-            )
-        }
-
-        fun runAction(data: ClientInstancedPlayerData) {
-            if (data !is ClientBadgeManager) return
-            CobblemonClient.clientBadgeData = data
-        }
-
-        fun runIncremental(data: ClientInstancedPlayerData) {
-            if (data !is ClientBadgeManager) return
-            CobblemonClient.clientBadgeData.obtainedBadges.addAll(data.obtainedBadges)
-        }
-    }
-
-}

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

@@ -117,6 +117,9 @@ abstract class ShowdownActionResponse(val type: ShowdownActionResponseType) {
 
 data class MoveActionResponse(var moveName: String, var targetPnx: String? = null, var gimmickID: String? = null): ShowdownActionResponse(ShowdownActionResponseType.MOVE) {
     override fun isValid(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?, forceSwitch: Boolean): Boolean {
+        // Ensure that the gimmick ID the player is sending is valid
+        gimmickID?.let { if (it !in VALID_GIMMICK_IDS) return false }
+
         if (forceSwitch || showdownMoveSet == null) {
             return false
         }
@@ -168,6 +171,10 @@ data class MoveActionResponse(var moveName: String, var targetPnx: String? = nul
         gimmickID = buffer.readNullable { buffer.readString() }
         return this
     }
+
+    companion object {
+        private val VALID_GIMMICK_IDS = ShowdownMoveset.Gimmick.entries.map { it.id }.toSet()
+    }
 }
 
 data class HealItemActionResponse(var item: String) : ShowdownActionResponse(ShowdownActionResponseType.FORCE_PASS) {
@@ -183,7 +190,8 @@ data class HealItemActionResponse(var item: String) : ShowdownActionResponse(Sho
     }
 
     override fun isValid(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?, forceSwitch: Boolean): Boolean {
-        return !forceSwitch
+        // Previously checked for !forceSwitch, excepts in the case of a forceSwitch, this couldn't legally be sent anyway.
+        return false
     }
 
     override fun toShowdownString(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?): String {

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

@@ -37,7 +37,6 @@ import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
 import com.cobblemon.mod.common.util.battleLang
 import com.cobblemon.mod.common.util.cobblemonResource
 import java.util.concurrent.CompletableFuture
-import net.minecraft.world.entity.LivingEntity
 
 /**
  * Format: |move|POKEMON|MOVE|TARGET
@@ -77,7 +76,7 @@ class MoveInstruction(
             val pokemonName = userPokemon.getName()
             ShowdownInterpreter.lastCauser[battle.battleId] = message
             // For Spread targets the message data only gives the pnx strings. So we can't know what pokemon are actually targeted until the previous messages have been interpreted
-            val spreadTargetPokemon = spreadTargets.map { battle.activePokemon.firstOrNull() { poke -> poke.getPNX() == it }?.battlePokemon }
+            val spreadTargetPokemon = spreadTargets.map { battle.activePokemon.firstOrNull { poke -> poke.getPNX() == it }?.battlePokemon }
 
             val targetPokemonEntity = targetPokemon?.entity
             if (targetPokemonEntity != null) {
@@ -137,10 +136,20 @@ class MoveInstruction(
 
             val subsequentInstructions = instructionSet.findInstructionsCausedBy(this)
             val missedTargets = subsequentInstructions.filterIsInstance<MissInstruction>().mapNotNull { it.target }
+            val faintedTargets = subsequentInstructions.filterIsInstance<FaintInstruction>().map { it.faintingPokemon }
             val failed = subsequentInstructions.any { it is FailInstruction }
             val failedTargets = subsequentInstructions.filterIsInstance<FailInstruction>().mapNotNull { it.target }
             val hitCountInstruction = subsequentInstructions.filterIsInstance<HitCountInstruction>().firstOrNull()
 
+            runtime.environment.query.addFunction("target_fainted") { params ->
+                if (params.params.size == 0) {
+                    return@addFunction DoubleValue(faintedTargets.isNotEmpty())
+                } else {
+                    val entityUUID = params.getString(0)
+                    return@addFunction DoubleValue(faintedTargets.any { it.entity?.stringUUID == entityUUID })
+                }
+            }
+
             runtime.environment.query.addFunction("missed") { params ->
                 if (params.params.size == 0) {
                     return@addFunction DoubleValue(missedTargets.isNotEmpty())

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

@@ -24,6 +24,7 @@ import net.minecraft.network.chat.Component
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.util.RandomSource
 import net.minecraft.world.InteractionResult
+import net.minecraft.world.entity.EntityType
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.player.Player
 import net.minecraft.world.item.Item
@@ -31,13 +32,9 @@ import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.TooltipFlag
 import net.minecraft.world.item.context.BlockPlaceContext
 import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.CollisionGetter
 import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.BaseEntityBlock
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.Mirror
-import net.minecraft.world.level.block.RenderShape
-import net.minecraft.world.level.block.Rotation
+import net.minecraft.world.level.block.*
 import net.minecraft.world.level.block.entity.BlockEntity
 import net.minecraft.world.level.block.entity.BlockEntityTicker
 import net.minecraft.world.level.block.entity.BlockEntityType
@@ -48,9 +45,11 @@ import net.minecraft.world.level.block.state.properties.IntegerProperty
 import net.minecraft.world.level.block.state.properties.Property
 import net.minecraft.world.level.pathfinder.PathComputationType
 import net.minecraft.world.phys.BlockHitResult
+import net.minecraft.world.phys.Vec3
 import net.minecraft.world.phys.shapes.CollisionContext
 import net.minecraft.world.phys.shapes.Shapes
 import net.minecraft.world.phys.shapes.VoxelShape
+import java.util.Optional
 
 @Suppress("DEPRECATED", "OVERRIDE_DEPRECATION")
 class HealingMachineBlock(settings: Properties) : BaseEntityBlock(settings) {
@@ -79,6 +78,14 @@ class HealingMachineBlock(settings: Properties) : BaseEntityBlock(settings) {
         const val MAX_CHARGE_LEVEL = 5
         val CHARGE_LEVEL: IntegerProperty = IntegerProperty.create("charge", 0, MAX_CHARGE_LEVEL + 1)
         val NATURAL: BooleanProperty = BooleanProperty.create("natural")
+
+        fun canSetSpawn(level: Level): Boolean {
+            return level.gameRules.getBoolean(CobblemonGameRules.HEALER_SET_SPAWN)
+        }
+
+        fun findStandUpPosition(entityType: EntityType<*>, level: CollisionGetter, pos: BlockPos): Optional<Vec3> {
+            return RespawnAnchorBlock.findStandUpPosition(entityType, level, pos) // Exists if we ever want to make something more custom, but anchor block logic should suffice
+        }
     }
 
     init {
@@ -158,7 +165,12 @@ class HealingMachineBlock(settings: Properties) : BaseEntityBlock(settings) {
         }
         val party = serverPlayerEntity.party()
         val pc = serverPlayerEntity.pc()
-        val healPC = player.level().gameRules.getBoolean(CobblemonGameRules.HEALERS_HEAL_PC);
+        val healPC = player.level().gameRules.getBoolean(CobblemonGameRules.HEALERS_HEAL_PC)
+
+        // Do spawnpoint stuff
+        if (canSetSpawn(world)) {
+            player.setRespawnPosition(world.dimension(), blockPos, player.yRot, false, true)
+        }
 
         if (party.none() && (!healPC || pc.none())) {
             player.sendSystemMessage(lang("healingmachine.nopokemon").red(), true)
@@ -183,6 +195,7 @@ class HealingMachineBlock(settings: Properties) : BaseEntityBlock(settings) {
             player.sendSystemMessage(lang("healingmachine.notenoughcharge", "${((neededCharge/party.count())*100f).toInt()}%").red(), true)
         }
         party.forEach { it.tryRecallWithAnimation() }
+
         return InteractionResult.CONSUME
     }
 

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

@@ -30,7 +30,7 @@ class OrbBlock(properties: Properties) : SixFaceRotationalBlock(properties) {
 
         val FLOOR_NORTH = Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.375, 0.6875)
         val WALL_NORTH = Shapes.box(0.3125, 0.3125, 0.625, 0.6875, 0.6875, 1.0)
-        val CEILING_NORTH = Shapes.box(0.3125, 0.625, 0.375, 0.6875, 1.0, 0.6875)
+        val CEILING_NORTH = Shapes.box(0.3125, 0.625, 0.3125, 0.6875, 1.0, 0.6875)
     }
 
     init {

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

@@ -160,8 +160,8 @@ class TypeGemClusterBlock(
             && state.getValue(STAGE) == 3) return false
 
         val supportPos = pos.relative(state.getValue(FACING).opposite)
-        val supportBlock = level.getBlockState(supportPos).block
-        return CobblemonBlocks.typeGemBlocks().containsValue(supportBlock) || (supportBlock == CobblemonBlocks.TYPE_GEM_CORE) // Cannot grow if not on any gem blocks
+        val supportState = level.getBlockState(supportPos)
+        return supportState.`is`(CobblemonBlockTags.TYPE_GEM_BLOCKS) || supportState.block == CobblemonBlocks.TYPE_GEM_CORE // Cannot grow if not on any gem blocks
     }
 
 

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

@@ -51,10 +51,20 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
                 ResourceLocation.parse("cobblemon:dragon_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_DRAGON,
                 ResourceLocation.parse("cobblemon:dark_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_DARK,
                 ResourceLocation.parse("cobblemon:steel_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_STEEL,
-                ResourceLocation.parse("cobblemon:fairy_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY
+                ResourceLocation.parse("cobblemon:fairy_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY,
+                ResourceLocation.parse("minecraft:amethyst_block") to Blocks.SMALL_AMETHYST_BUD
             )
         }
 
+        val AMETHYST_STAGES = listOf(
+            Blocks.SMALL_AMETHYST_BUD,
+            Blocks.MEDIUM_AMETHYST_BUD,
+            Blocks.LARGE_AMETHYST_BUD,
+            Blocks.AMETHYST_CLUSTER
+        )
+
+        private fun isAmethystStage(block: Block) = block in AMETHYST_STAGES
+
         fun getConnectedGemBlocks(level: BlockGetter, pos: BlockPos): List<Pair<BlockState, BlockPos>> {
             val connectedGems = mutableListOf<Pair<BlockState, BlockPos>>()
             val visited = mutableSetOf<BlockPos>()
@@ -85,12 +95,16 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
             Direction.entries.forEach {
                 if (random.nextFloat() < Cobblemon.config.typeGemGrowthChance) {
                     val faceState = level.getBlockState(pos.relative(it))
-                    val randomGrowthType = decideClusterGrowthType(level, pos)
-                    val newState = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(state.block)]?.defaultBlockState()
+                    var newState = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(state.block)]?.defaultBlockState()
                         ?.setValue(DirectionalBlock.FACING, it)
-                        ?.setValue(GROWTH_TYPE, randomGrowthType)
                         ?: return
 
+                    if (newState.hasProperty(GROWTH_TYPE)) {
+                        newState = newState.setValue(GROWTH_TYPE, decideClusterGrowthType(level, pos))
+                    } else if (getConnectedGemBlocks(level, pos).size > Cobblemon.config.typeGemMaxConnected) {
+                        return@forEach
+                    }
+
                     if (faceState.`is`(Blocks.AIR)) {
                         level.setBlock(pos.relative(it), newState, 3)
                     }
@@ -132,7 +146,7 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
                 if (!visited.add(clusterPos)) continue
 
                 val clusterState = level.getBlockState(clusterPos)
-                if (clusterState.block == expectedCluster) {
+                if (clusterState.block == expectedCluster && clusterState.hasProperty(GROWTH_TYPE)) {
                     clusters += clusterState to clusterPos
                 }
             }
@@ -178,13 +192,41 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
         Direction.entries.forEach { direction ->
             val relativePos = pos.relative(direction)
             val relativeState = level.getBlockState(relativePos)
-            val clusterBlock = relativeState.block as? TypeGemClusterBlock ?: return@forEach
-
-            if ((relativeState.getValue(DirectionalBlock.FACING) == direction &&
-                random.nextFloat() < Cobblemon.config.typeGemGrowthChance) || forceGrow
-                ) {
-                clusterBlock.advanceGrowth(relativeState, level, relativePos, random)
+            val matchesFace = relativeState.hasProperty(DirectionalBlock.FACING)
+                    && relativeState.getValue(DirectionalBlock.FACING) == direction
+            if (!(forceGrow || (matchesFace && random.nextFloat() < Cobblemon.config.typeGemGrowthChance))) {
+                return@forEach
             }
+
+            val block = relativeState.block
+            if (block is TypeGemClusterBlock) {
+                block.advanceGrowth(relativeState, level, relativePos, random)
+            } else if (isAmethystStage(block)) {
+                advanceAmethyst(relativeState, level, relativePos)
+            }
+        }
+    }
+
+    private fun advanceAmethyst(state: BlockState, level: LevelAccessor, pos: BlockPos) {
+        val facing = state.getValue(DirectionalBlock.FACING)
+        val supportState = level.getBlockState(pos.relative(facing.opposite))
+        if (!supportState.`is`(CobblemonBlockTags.TYPE_GEM_BLOCKS) && supportState.block != CobblemonBlocks.TYPE_GEM_CORE) {
+            return
+        }
+
+        if (state.block != Blocks.AMETHYST_CLUSTER) {
+            val nextStage = AMETHYST_STAGES[AMETHYST_STAGES.indexOf(state.block) + 1]
+            level.setBlock(pos, nextStage.defaultBlockState().setValue(DirectionalBlock.FACING, facing), 3)
+            return
+        }
+
+        // Fully grown clusters mature into amethyst blocks unless boxed in, mirroring stunted type gems
+        val boxedIn = Direction.entries.any { direction ->
+            direction != facing.opposite
+                    && level.getBlockState(pos.relative(direction)).`is`(CobblemonBlockTags.TYPE_GEM_BLOCKS)
+        }
+        if (!boxedIn) {
+            level.setBlock(pos, Blocks.AMETHYST_BLOCK.defaultBlockState(), 3)
         }
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperFanBlock.kt

@@ -0,0 +1,87 @@
+/*
+ * 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.appliances
+
+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.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
+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.BooleanProperty
+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
+//TODO: All the Fan appliance stuff
+//TODO: Able to place the Fan on Walls, models and hitbox are there (blockstate would need edits to support it)
+open class CopperFanBlock(settings: Properties) : HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
+
+    companion object {
+        val CODEC: MapCodec<CopperFanBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::CopperFanBlock) }
+        //val FACE = //TODO: Floor/Wall
+        val POWER = BlockStateProperties.POWER;
+        val PUSH = BooleanProperty.create("push")
+
+        val FLOOR_HITBOX = Shapes.or(
+            Shapes.box(0.0625, 0.125, 0.4375, 0.9375, 1.0, 0.5625),
+            Shapes.box(0.375, 0.0, 0.375, 0.625, 0.125, 0.625))
+        val WALL_HITBOX = Shapes.box(0.0625, 0.0625, 0.875, 0.9375, 0.9375, 1.0)
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HORIZONTAL_FACING, Direction.NORTH)
+            .setValue(WATERLOGGED, false)
+            //.setValue(FACE, AttachFace.FLOOR)
+            .setValue(POWER, 0)
+            .setValue(PUSH, true) //If True, fan pushes entities, If False, fan is cosmetic only
+        )
+    }
+
+    override fun codec(): MapCodec<CopperFanBlock> = CODEC
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HORIZONTAL_FACING, WATERLOGGED, /*FACE,*/ POWER, PUSH)
+    }
+
+    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)
+        return rotateShape(Direction.NORTH, direction, FLOOR_HITBOX)
+    }
+
+    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
+        return getCollisionShape(state, level, pos, context)
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
+        val fluidState = context.level.getFluidState(context.clickedPos)
+        return super.getStateForPlacement(context)?.setValue(HORIZONTAL_FACING, context.horizontalDirection.opposite)?.setValue(WATERLOGGED, fluidState.type === Fluids.WATER)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperFridgeBlock.kt

@@ -0,0 +1,275 @@
+/*
+ * 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.appliances
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import com.cobblemon.mod.common.util.isServerSide
+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.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.InteractionHand
+import net.minecraft.world.ItemInteractionResult
+import net.minecraft.world.entity.LivingEntity
+import net.minecraft.world.entity.item.ItemEntity
+import net.minecraft.world.entity.player.Player
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.Items
+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.LevelReader
+import net.minecraft.world.level.block.*
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityTicker
+import net.minecraft.world.level.block.entity.BlockEntityType
+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.HORIZONTAL_FACING
+import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
+import net.minecraft.world.level.block.state.properties.BooleanProperty
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+import net.minecraft.world.level.block.state.properties.EnumProperty
+import net.minecraft.world.level.material.FluidState
+import net.minecraft.world.level.material.Fluids
+import net.minecraft.world.phys.BlockHitResult
+import net.minecraft.world.phys.Vec3
+import net.minecraft.world.phys.shapes.CollisionContext
+import net.minecraft.world.phys.shapes.Shapes
+import net.minecraft.world.phys.shapes.VoxelShape
+//TODO: Oxidation/Waxing/Scraping not breaking the blocks
+//TODO: All the Fridge appliance stuff
+open class CopperFridgeBlock(settings: Properties) : BaseEntityBlock(settings), SimpleWaterloggedBlock {
+
+    fun getBlockEntity(level: ServerLevel, pos: BlockPos) = level.getBlockEntity(getBottomPos(level, pos)) as CopperFridgeBlockEntity
+
+    companion object {
+        val CODEC: MapCodec<CopperFridgeBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::CopperFridgeBlock) }
+        val HALF: EnumProperty<DoubleBlockHalf> = BlockStateProperties.DOUBLE_BLOCK_HALF
+        val POWERED = BooleanProperty.create("powered")
+        val FACING = HorizontalDirectionalBlock.FACING
+
+        val LOWER_HITBOX = Shapes.or(
+            Shapes.box(0.0625, 0.0, 0.125, 0.9375, 0.0625, 0.9375),
+            Shapes.box(0.0, 0.0625, 0.0625, 1.0, 1.0, 1.0))
+        val UPPER_HITBOX = Shapes.or(
+            Shapes.box(0.0, 0.0, 0.0625, 1.0, 1.0, 1.0),
+            Shapes.box(0.25, 0.125, 0.0, 0.375, 0.3125, 0.0625),
+            Shapes.box(0.625, 0.125, 0.0, 0.75, 0.3125, 0.0625))
+        val UPPER_COLLISSIONBOX = Shapes.box(0.0, 0.0, 0.0625, 1.0, 1.0, 1.0)
+        //The handles get ignored by entity collission, because it feels nicer, but still count as part of the hitbox
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HORIZONTAL_FACING, Direction.NORTH)
+            .setValue(HALF, DoubleBlockHalf.LOWER)
+            .setValue(WATERLOGGED, false)
+            .setValue(POWERED, false)
+        )
+    }
+
+    override fun codec(): MapCodec<CopperFridgeBlock> = CODEC
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HORIZONTAL_FACING, HALF, WATERLOGGED, POWERED)
+    }
+
+    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))
+        }
+
+        val isFridge = neighborState.`is`(this)
+        val half = state.getValue(HALF)
+        if (!isFridge && half == DoubleBlockHalf.UPPER && neighborPos == pos.below()) {
+            return Blocks.AIR.defaultBlockState()
+        } else if (!isFridge && half == DoubleBlockHalf.LOWER && neighborPos == pos.above()) {
+            return Blocks.AIR.defaultBlockState()
+        }
+        return state
+    }
+
+    override fun getCollisionShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
+        val direction = state.getValue(HORIZONTAL_FACING)
+        return if (state.getValue(HALF) == DoubleBlockHalf.LOWER) {
+            rotateShape(Direction.NORTH, direction, LOWER_HITBOX)
+        } else {
+            rotateShape(Direction.NORTH, direction, UPPER_COLLISSIONBOX)
+        }
+    }
+
+    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
+        val direction = state.getValue(HORIZONTAL_FACING)
+        return if (state.getValue(HALF) == DoubleBlockHalf.LOWER) {
+            rotateShape(Direction.NORTH, direction, LOWER_HITBOX)
+        } else {
+            rotateShape(Direction.NORTH, direction, UPPER_HITBOX)
+        }
+    }
+
+    override fun setPlacedBy(world: Level, pos: BlockPos, state: BlockState, placer: LivingEntity?, itemStack: ItemStack) {
+        world.setBlock(pos.above(),
+            state
+                .setValue(HALF, DoubleBlockHalf.UPPER)
+                .setValue(WATERLOGGED, world.getFluidState((pos.above())).type == Fluids.WATER)
+            , 3)
+        world.blockUpdated(pos, Blocks.AIR)
+        state.updateNeighbourShapes(world, pos, 3)
+    }
+
+    override fun getStateForPlacement(blockPlaceContext: BlockPlaceContext): BlockState? {
+        val abovePosition = blockPlaceContext.clickedPos.above()
+        val world = blockPlaceContext.level
+        if (world.getBlockState(abovePosition).canBeReplaced(blockPlaceContext) && !world.isOutsideBuildHeight(abovePosition)) {
+            return defaultBlockState()
+                .setValue(FACING, blockPlaceContext.horizontalDirection.opposite)
+                .setValue(HALF, DoubleBlockHalf.LOWER)
+                .setValue(WATERLOGGED, blockPlaceContext.level.getFluidState(blockPlaceContext.clickedPos).type == Fluids.WATER)
+        }
+        return null
+    }
+
+    override fun getRenderShape(state: BlockState) = RenderShape.MODEL
+
+    override fun canSurvive(state: BlockState, world: LevelReader, pos: BlockPos): Boolean {
+        val blockPos = pos.below()
+        val blockState = world.getBlockState(blockPos)
+        return if (state.getValue(HALF) == DoubleBlockHalf.LOWER) blockState.isFaceSturdy(world, blockPos, Direction.UP) else blockState.`is`(this)
+    }
+
+    override fun playerWillDestroy(world: Level, pos: BlockPos, state: BlockState, player: Player): BlockState {
+        if (!world.isClientSide && player.isCreative) {
+            var blockPos: BlockPos = BlockPos.ZERO
+            var blockState: BlockState = state
+            val half = state.getValue(HALF)
+            if (half == DoubleBlockHalf.UPPER && world.getBlockState(pos.below().also { blockPos = it }).also { blockState = it }.`is`(state.block) && blockState.getValue(
+                    HALF
+                ) == DoubleBlockHalf.LOWER) {
+                val blockState2 = if (blockState.fluidState.`is`(Fluids.WATER)) Blocks.WATER.defaultBlockState() else Blocks.AIR.defaultBlockState()
+                world.setBlock(blockPos, blockState2, UPDATE_ALL or UPDATE_SUPPRESS_DROPS)
+                world.levelEvent(player, LevelEvent.PARTICLES_DESTROY_BLOCK, blockPos, getId(blockState))
+            }
+        }
+        return super.playerWillDestroy(world, pos, state, player)
+    }
+
+    override fun useItemOn(
+        stack: ItemStack,
+        state: BlockState,
+        level: Level,
+        pos: BlockPos,
+        player: Player,
+        hand: InteractionHand,
+        hitResult: BlockHitResult
+    ): ItemInteractionResult {
+        if (level.isServerSide()) {
+            val handStack = player.getItemInHand(hand)
+            val stack = getBlockEntity(level as ServerLevel, pos).theItem
+
+            when (stack.item) {
+                Items.AIR -> {
+                    if (handStack.`is`(Items.WATER_BUCKET)) {
+                        if (!player.isCreative) player.setItemInHand(hand, Items.BUCKET.defaultInstance)
+                        getBlockEntity(level, pos).timer = 100
+                        getBlockEntity(level, pos).theItem = Items.WATER_BUCKET.defaultInstance
+                        return ItemInteractionResult.SUCCESS
+                    } else {
+                        return ItemInteractionResult.FAIL
+                    }
+                }
+
+                Items.WATER_BUCKET -> {
+                    if (handStack.`is`(Items.BUCKET)) {
+                        player.setItemInHand(hand, Items.WATER_BUCKET.defaultInstance)
+                        getBlockEntity(level, pos).theItem = Items.AIR.defaultInstance
+                        getBlockEntity(level, pos).timer = 0
+                        return ItemInteractionResult.SUCCESS
+                    } else {
+                        return ItemInteractionResult.FAIL
+                    }
+                }
+
+                Items.ICE -> {
+                    val facing = state.getValue(HORIZONTAL_FACING)
+                    val spawnPos = getBottomPos(level, pos)
+                    val itemEntity =
+                        ItemEntity(level, spawnPos.x + 0.5, spawnPos.y + 0.5, spawnPos.z + 0.5, Items.ICE.defaultInstance)
+                    itemEntity.deltaMovement = Vec3(facing.stepX.toDouble(), 0.0, facing.stepZ.toDouble()).scale(0.2)
+                    level.addFreshEntity(itemEntity)
+                    getBlockEntity(level, pos).theItem = Items.AIR.defaultInstance
+                    return ItemInteractionResult.SUCCESS
+                }
+            }
+        }
+
+        return ItemInteractionResult.SUCCESS
+    }
+
+    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
+        if (level.isClientSide) return super.getAnalogOutputSignal(state, level, pos)
+        return when (getBlockEntity(level as ServerLevel, pos).theItem.item) {
+            Items.WATER_BUCKET -> 1
+            Items.ICE -> 2
+            else -> 0
+        }
+    }
+
+    override fun tick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
+        (level.getBlockEntity(pos) as CopperFridgeBlockEntity).processTick()
+        super.tick(state, level, pos, random)
+    }
+
+    override fun newBlockEntity(pos: BlockPos, state: BlockState) = if (state.getValue(HALF) == DoubleBlockHalf.LOWER) CopperFridgeBlockEntity(pos, state) else null
+
+    override fun neighborChanged(
+        state: BlockState,
+        level: Level,
+        pos: BlockPos,
+        neighborBlock: Block,
+        neighborPos: BlockPos,
+        movedByPiston: Boolean
+    ) {
+        if (!level.isClientSide) {
+            val otherPos = if (state.getValue(HALF) == DoubleBlockHalf.LOWER) pos.above() else pos.below()
+            val powered = level.hasNeighborSignal(pos) || level.hasNeighborSignal(otherPos)
+
+            if (state.getValue(POWERED) != powered) {
+                level.setBlock(pos, state.setValue(POWERED, powered), 3)
+            }
+
+            val otherState = level.getBlockState(otherPos)
+            if (otherState.`is`(this) && otherState.getValue(POWERED) != powered) {
+                level.setBlock(otherPos, otherState.setValue(POWERED, powered), 3)
+            }
+        }
+        super.neighborChanged(state, level, pos, neighborBlock, neighborPos, movedByPiston)
+    }
+
+    override fun <T : BlockEntity> getTicker(
+        level: Level,
+        state: BlockState,
+        blockEntityType: BlockEntityType<T>
+    ): BlockEntityTicker<T>? {
+        return if (level.isClientSide)
+            null
+        else
+            createTickerHelper(blockEntityType, CobblemonBlockEntities.COPPER_FRIDGE, CopperFridgeBlockEntity.TICKER::tick)
+    }
+
+    fun getBottomPos(level: Level, pos: BlockPos) = if (level.getBlockState(pos).getValue(HALF) == DoubleBlockHalf.UPPER) pos.below() else pos
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperFridgeBlockEntity.kt

@@ -0,0 +1,48 @@
+package com.cobblemon.mod.common.block.appliances
+
+import com.cobblemon.mod.common.CobblemonBlockEntities
+import net.minecraft.core.BlockPos
+import net.minecraft.world.Container
+import net.minecraft.world.item.ItemStack
+import net.minecraft.world.item.Items
+import net.minecraft.world.level.block.entity.BlockEntity
+import net.minecraft.world.level.block.entity.BlockEntityTicker
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.ticks.ContainerSingleItem
+
+class CopperFridgeBlockEntity(val pos: BlockPos, val state: BlockState) : BlockEntity(
+    CobblemonBlockEntities.COPPER_FRIDGE, pos, state
+), ContainerSingleItem.BlockContainerSingleItem {
+
+    private var item: ItemStack = Items.AIR.defaultInstance
+    var timer: Int = -1
+
+    fun processTick() {
+        if (level == null) return
+        if (!level!!.getBlockState(pos).getValue(CopperFridgeBlock.POWERED)) return
+        if (timer > 0) timer--
+        if (timer == 0 && item.item == Items.WATER_BUCKET) {
+            item = Items.ICE.defaultInstance
+            timer = -1
+        }
+    }
+
+    override fun getContainerBlockEntity() = this
+    override fun getTheItem() = item
+
+    override fun setTheItem(item: ItemStack) {
+        this.item = item
+    }
+
+    override fun canTakeItem(target: Container, slot: Int, stack: ItemStack): Boolean {
+        return stack.item == Items.ICE
+    }
+
+    companion object {
+        internal val TICKER = BlockEntityTicker<CopperFridgeBlockEntity> { level, pos, state, entity ->
+            if (!level.isClientSide) {
+                entity.processTick()
+            }
+        }
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperMowerBlock.kt

@@ -0,0 +1,92 @@
+/*
+ * 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.appliances
+
+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.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.BooleanProperty
+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
+//TODO: All the Mower appliance stuff
+open class CopperMowerBlock(settings: Properties) : HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
+
+    companion object {
+        val CODEC: MapCodec<CopperMowerBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::CopperMowerBlock) }
+        val TRIGGERED = BooleanProperty.create("triggered")
+
+        val COLLISIONBOX = Shapes.or(
+            Shapes.box(0.1875, 0.0, 0.0, 0.8125, 0.375, 0.625),
+            Shapes.box(0.0625, 0.0, 0.625, 0.9375, 0.625, 1.0),
+            Shapes.box(0.125, 0.0, 0.1875, 0.875, 0.3125, 0.5),
+            //The next three lines are just so the handle does have collision, it feels awkward without it but it looks bad as hitbox
+            Shapes.box(0.375, 0.375, 0.375, 0.625, 0.625, 0.5625),
+            Shapes.box(0.4375, 0.5625, 0.5, 0.5625, 0.875, 0.625),
+            Shapes.box(0.25, 0.875, 0.5625, 0.75, 1.0, 0.6875)
+        )
+        val HITBOX = Shapes.or(
+            Shapes.box(0.1875, 0.0, 0.0, 0.8125, 0.375, 0.625),
+            Shapes.box(0.0625, 0.0, 0.625, 0.9375, 0.625, 1.0),
+            Shapes.box(0.125, 0.0, 0.1875, 0.875, 0.3125, 0.5)
+        )
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HORIZONTAL_FACING, Direction.NORTH)
+            .setValue(WATERLOGGED, false)
+            .setValue(TRIGGERED, false)
+        )
+    }
+
+    override fun codec(): MapCodec<CopperMowerBlock> = CODEC
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HORIZONTAL_FACING, WATERLOGGED, TRIGGERED)
+    }
+
+    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)
+        return rotateShape(Direction.NORTH, direction, COLLISIONBOX)
+    }
+
+    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
+        val direction = state.getValue(HORIZONTAL_FACING)
+        return rotateShape(Direction.NORTH, direction, HITBOX)
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
+        val fluidState = context.level.getFluidState(context.clickedPos)
+        return super.getStateForPlacement(context)?.setValue(HORIZONTAL_FACING, context.horizontalDirection.opposite)?.setValue(WATERLOGGED, fluidState.type === Fluids.WATER)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperOvenBlock.kt

@@ -0,0 +1,88 @@
+/*
+ * 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.appliances
+
+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.*
+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.BooleanProperty
+import net.minecraft.world.level.block.state.properties.EnumProperty
+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
+//TODO: All the Oven appliance stuff - Good Luck Coders
+open class CopperOvenBlock(settings: Properties) : HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
+
+    companion object {
+        val CODEC: MapCodec<CopperOvenBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::CopperOvenBlock) }
+        val EJECTING = BooleanProperty.create("ejecting")
+        val COOKING = EnumProperty.create("cooking", CookingState::class.java)
+
+        val HITBOX = Shapes.box(0.0625, 0.0, 0.3125, 0.9375, 0.625, 0.9375)
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HORIZONTAL_FACING, Direction.NORTH)
+            .setValue(WATERLOGGED, false)
+            .setValue(COOKING, CookingState.CLOSED)
+            .setValue(EJECTING, false)
+        )
+    }
+    enum class CookingState : StringRepresentable {
+        CLOSED, //Door is closed
+        OPEN, //Door is open
+        COOKING; //Door is locked closed and the light level is cranked up, as long as the block is powered by redstone. Acts as closed lid in the original Campfire Pot
+        override fun getSerializedName(): String = this.name.lowercase()
+    }
+
+    override fun codec(): MapCodec<CopperOvenBlock> = CODEC
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HORIZONTAL_FACING, WATERLOGGED, COOKING, EJECTING)
+    }
+
+    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)
+        return rotateShape(Direction.NORTH, direction, HITBOX)
+    }
+
+    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 fluidState = context.level.getFluidState(context.clickedPos)
+        return super.getStateForPlacement(context)?.setValue(HORIZONTAL_FACING, context.horizontalDirection.opposite)?.setValue(WATERLOGGED, fluidState.type === Fluids.WATER)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/CopperWasherBlock.kt

@@ -0,0 +1,78 @@
+/*
+ * 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.appliances
+
+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.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.BooleanProperty
+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
+
+open class CopperWasherBlock(settings: Properties) : HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
+
+    companion object {
+        val CODEC: MapCodec<CopperWasherBlock> = RecordCodecBuilder.mapCodec {
+            it.group(propertiesCodec()).apply(it, ::CopperWasherBlock) }
+        val POWERED = BooleanProperty.create("powered")
+
+        val HITBOX = Shapes.box(0.0625, 0.0, 0.125, 0.9375, 1.0, 1.0)
+    }
+
+    init {
+        registerDefaultState(stateDefinition.any()
+            .setValue(HORIZONTAL_FACING, Direction.NORTH)
+            .setValue(WATERLOGGED, false)
+            .setValue(POWERED, false)
+        )
+    }
+
+    override fun codec(): MapCodec<CopperWasherBlock> = CODEC
+
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(HORIZONTAL_FACING, WATERLOGGED, POWERED)
+    }
+
+    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)
+        return rotateShape(Direction.NORTH, direction, HITBOX)
+    }
+
+    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 fluidState = context.level.getFluidState(context.clickedPos)
+        return super.getStateForPlacement(context)?.setValue(HORIZONTAL_FACING, context.horizontalDirection.opposite)?.setValue(WATERLOGGED, fluidState.type === Fluids.WATER)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/WeatheringCopperFanBlock.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.appliances
+
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.level.block.WeatheringCopper
+import net.minecraft.world.level.block.state.BlockState
+
+class WeatheringCopperFanBlock(val weatherState: WeatheringCopper.WeatherState, properties: Properties) :
+    CopperFanBlock(properties), WeatheringCopper {
+
+    override fun randomTick(state: BlockState?, level: ServerLevel?, pos: BlockPos?, random: RandomSource?) {
+        this.changeOverTime(state, level, pos, random)
+    }
+
+    override fun isRandomlyTicking(state: BlockState): Boolean {
+        return WeatheringCopper.getNext(state.getBlock()).isPresent()
+    }
+
+    override fun getAge(): WeatheringCopper.WeatherState {
+        return this.weatherState
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/WeatheringCopperFridgeBlock.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.appliances
+
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.level.block.WeatheringCopper
+import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
+
+class WeatheringCopperFridgeBlock(val weatherState: WeatheringCopper.WeatherState, properties: Properties) :
+    CopperFridgeBlock(properties), WeatheringCopper {
+
+    override fun randomTick(state: BlockState, level: ServerLevel?, pos: BlockPos?, random: RandomSource?) {
+        if (state.getValue(HALF) == DoubleBlockHalf.LOWER) {
+            this.changeOverTime(state, level, pos, random)
+        }
+    }
+
+    override fun isRandomlyTicking(state: BlockState): Boolean {
+        return WeatheringCopper.getNext(state.getBlock()).isPresent()
+    }
+
+    override fun getAge(): WeatheringCopper.WeatherState {
+        return this.weatherState
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/WeatheringCopperMowerBlock.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.appliances
+
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.level.block.WeatheringCopper
+import net.minecraft.world.level.block.state.BlockState
+
+class WeatheringCopperMowerBlock(val weatherState: WeatheringCopper.WeatherState, properties: Properties) :
+    CopperMowerBlock(properties), WeatheringCopper {
+
+    override fun randomTick(state: BlockState?, level: ServerLevel?, pos: BlockPos?, random: RandomSource?) {
+        this.changeOverTime(state, level, pos, random)
+    }
+
+    override fun isRandomlyTicking(state: BlockState): Boolean {
+        return WeatheringCopper.getNext(state.getBlock()).isPresent()
+    }
+
+    override fun getAge(): WeatheringCopper.WeatherState {
+        return this.weatherState
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/WeatheringCopperOvenBlock.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.appliances
+
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.level.block.WeatheringCopper
+import net.minecraft.world.level.block.state.BlockState
+
+class WeatheringCopperOvenBlock(val weatherState: WeatheringCopper.WeatherState, properties: Properties) :
+    CopperOvenBlock(properties), WeatheringCopper {
+
+    override fun randomTick(state: BlockState?, level: ServerLevel?, pos: BlockPos?, random: RandomSource?) {
+        this.changeOverTime(state, level, pos, random)
+    }
+
+    override fun isRandomlyTicking(state: BlockState): Boolean {
+        return WeatheringCopper.getNext(state.getBlock()).isPresent()
+    }
+
+    override fun getAge(): WeatheringCopper.WeatherState {
+        return this.weatherState
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/appliances/WeatheringCopperWasherBlock.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.appliances
+
+import net.minecraft.core.BlockPos
+import net.minecraft.server.level.ServerLevel
+import net.minecraft.util.RandomSource
+import net.minecraft.world.level.block.WeatheringCopper
+import net.minecraft.world.level.block.state.BlockState
+
+class WeatheringCopperWasherBlock(val weatherState: WeatheringCopper.WeatherState, properties: Properties) :
+    CopperWasherBlock(properties), WeatheringCopper {
+
+    override fun randomTick(state: BlockState?, level: ServerLevel?, pos: BlockPos?, random: RandomSource?) {
+        this.changeOverTime(state, level, pos, random)
+    }
+
+    override fun isRandomlyTicking(state: BlockState): Boolean {
+        return WeatheringCopper.getNext(state.getBlock()).isPresent()
+    }
+
+    override fun getAge(): WeatheringCopper.WeatherState {
+        return this.weatherState
+    }
+}

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

@@ -17,12 +17,12 @@ import com.cobblemon.mod.common.CobblemonItems
 import com.cobblemon.mod.common.CobblemonMenuType
 import com.cobblemon.mod.common.api.berry.Berries
 import com.cobblemon.mod.common.api.scheduling.ClientTaskTracker
-import com.cobblemon.mod.common.api.storage.player.client.ClientBadgeManager
 import com.cobblemon.mod.common.api.storage.player.client.ClientGeneralPlayerData
 import com.cobblemon.mod.common.api.storage.player.client.ClientPokedexManager
 import com.cobblemon.mod.common.api.storage.player.client.ClientTMMoveManager
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.block.entity.TintBlockEntity
+import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
 import com.cobblemon.mod.common.client.battle.ClientBattle
 import com.cobblemon.mod.common.client.gui.PartyOverlay
 import com.cobblemon.mod.common.client.gui.PartyOverlayDataControl
@@ -101,7 +101,6 @@ object CobblemonClient {
     var clientPlayerData = ClientGeneralPlayerData()
     var clientPokedexData = ClientPokedexManager(mutableMapOf())
     var clientTMMoveData = ClientTMMoveManager(mutableSetOf())
-    var clientBadgeData = ClientBadgeManager(mutableSetOf())
 
     /** If true then we won't bother them anymore about choosing a starter even if it's a thing they can do. */
     var checkedStarterScreen = false
@@ -119,7 +118,6 @@ object CobblemonClient {
         teamData = ClientPlayerTeamData()
         clientPokedexData = ClientPokedexManager(mutableMapOf())
         clientTMMoveData = ClientTMMoveManager(mutableSetOf())
-        clientBadgeData = ClientBadgeManager(mutableSetOf())
         storage.onLogin()
 //        CobblemonDataProvider.canReload = false
     }
@@ -393,7 +391,7 @@ object CobblemonClient {
             CobblemonBlocks.X_SP_ATK,
             CobblemonBlocks.X_SP_DEF,
             CobblemonBlocks.X_SPEED,
-            CobblemonBlocks.TM_MACHINE,   
+            CobblemonBlocks.TM_MACHINE,
 
             CobblemonBlocks.GALARICA_CUFF,
             CobblemonBlocks.GALARICA_WREATH,
@@ -421,7 +419,7 @@ object CobblemonClient {
             CobblemonBlocks.MOOMOO_MILK,
             CobblemonBlocks.MEDICINAL_BREW,
             CobblemonBlocks.TERRAIN_EXTENDER,
-            
+
             CobblemonBlocks.RED_MINT_LEAF_LITTER,
             CobblemonBlocks.POTTED_RED_MINT,
             CobblemonBlocks.BLUE_MINT_LEAF_LITTER,
@@ -518,7 +516,17 @@ object CobblemonClient {
             CobblemonBlocks.POTTED_WATMEL_BERRY,
             CobblemonBlocks.POTTED_WEPEAR_BERRY,
             CobblemonBlocks.POTTED_WIKI_BERRY,
-            CobblemonBlocks.POTTED_YACHE_BERRY
+            CobblemonBlocks.POTTED_YACHE_BERRY,
+            CobblemonBlocks.SCOPE_LENS,
+
+            CobblemonBlocks.COPPER_FAN,
+            CobblemonBlocks.EXPOSED_COPPER_FAN,
+            CobblemonBlocks.WEATHERED_COPPER_FAN,
+            CobblemonBlocks.OXIDIZED_COPPER_FAN,
+            CobblemonBlocks.WAXED_COPPER_FAN,
+            CobblemonBlocks.WAXED_EXPOSED_COPPER_FAN,
+            CobblemonBlocks.WAXED_WEATHERED_COPPER_FAN,
+            CobblemonBlocks.WAXED_OXIDIZED_COPPER_FAN
         )
 
         this.createBoatModelLayers()

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

@@ -1,167 +0,0 @@
-package com.cobblemon.mod.common.client.gui.trainercard
-
-import com.cobblemon.mod.common.api.badges.Badge
-import com.cobblemon.mod.common.api.gui.blitk
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.client.gui.ScrollingWidget
-import com.cobblemon.mod.common.client.gui.pokedex.renderTooltip
-import com.cobblemon.mod.common.util.lang
-import net.minecraft.client.gui.GuiGraphics
-import net.minecraft.network.chat.Component
-import net.minecraft.network.chat.MutableComponent
-import net.minecraft.util.FastColor
-import net.minecraft.util.Mth
-
-class BadgesScrollingWidget(
-    x: Int,
-    y: Int,
-    width: Int,
-    height: Int,
-    private val columns: Int
-) : ScrollingWidget<BadgesScrollingWidget.BadgeRow>(
-    width = width,
-    height = height,
-    left = x,
-    top = y - height,
-    slotHeight = SLOT_SIZE + SLOT_SPACING
-) {
-
-    private var tooltip: MutableComponent? = null
-    private var tooltipX = 0
-    private var tooltipY = 0
-
-    companion object {
-        const val SLOT_SIZE = 16
-        const val SLOT_SPACING = 3
-        const val MAX_VISIBLE_ROWS = 2
-    }
-
-    fun createEntries(badges: List<Badge>) {
-
-        val obtainedBadgeList = badges.filter { CobblemonClient.clientBadgeData.obtainedBadges.contains(it.identifier) }
-            .sortedBy { it.order }
-        val unobtainedBadgesList = badges.filter { !obtainedBadgeList.contains(it) }
-            .sortedBy { it.order }
-        val sortedBadgeList = obtainedBadgeList.plus(unobtainedBadgesList)
-
-        sortedBadgeList.chunked(columns).forEach { listChunk ->
-            addEntry(BadgeRow(this, listChunk))
-        }
-    }
-
-    private val visibleRows: Int
-        get() = (height / itemHeight).coerceAtLeast(1)
-
-    private fun hasScrollbar(): Boolean = children().size > visibleRows
-
-    override fun getRowLeft(): Int = if (hasScrollbar()) left + 1 else left
-    override fun getScrollbarPosition(): Int = rowLeft + width - 3
-
-    override fun renderWidget(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
-        tooltip = null
-        super.renderWidget(context, mouseX, mouseY, delta)
-        tooltip?.let { renderTooltip(context, it, tooltipX, tooltipY, delta) }
-    }
-
-    fun setTooltip(text: MutableComponent, mouseX: Int, mouseY: Int) {
-        if (mouseX in left until left + width && mouseY in this.y until bottom) {
-            tooltip = text
-            tooltipX = mouseX + 20
-            tooltipY = mouseY - 10
-        }
-    }
-
-    override fun renderScrollbar(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
-        if (hasScrollbar()) {
-            val xLeft = this.scrollbarPosition
-            val xRight = xLeft + 3
-
-            val barHeight = this.bottom - this.y
-
-            var yBottom = ((barHeight * barHeight).toFloat() / this.maxPosition.toFloat()).toInt()
-            yBottom = Mth.clamp(yBottom, minOf(32, barHeight), maxOf(minOf(32, barHeight), barHeight - 8))
-            var yTop = scrollAmount.toInt() * (barHeight - yBottom) / this.maxScroll + this.y
-            if (yTop < this.y) {
-                yTop = this.y
-            }
-
-            context.fill(xLeft, this.y, xRight, this.bottom, FastColor.ARGB32.color(255, 75, 75, 75))
-            context.fill(xLeft, yTop, xRight, yTop + yBottom, FastColor.ARGB32.color(255, 141, 141, 141))
-        }
-    }
-
-    private fun renderEntry(context: GuiGraphics, mouseX: Int, mouseY: Int, index: Int, x: Int, y: Int) {
-        getEntry(index).renderRow(context, y, x, mouseX, mouseY)
-    }
-
-    override fun renderListItems(context: GuiGraphics, mouseX: Int, mouseY: Int, delta: Float) {
-        val rowX = rowLeft
-
-        for (index in 0 until this.itemCount) {
-            val rowY = this.getRowTop(index)
-            val o = this.getRowBottom(index)
-            if (o >= this.y && rowY <= this.bottom) {
-                this.renderEntry(context, mouseX, mouseY, index, rowX, rowY)
-            }
-        }
-    }
-
-    override fun mouseDragged(mouseX: Double, mouseY: Double, button: Int, dragX: Double, dragY: Double): Boolean =
-        if (hasScrollbar()) super.mouseDragged(mouseX, mouseY, button, dragX, dragY) else true
-
-    override fun mouseScrolled(mouseX: Double, mouseY: Double, scrollX: Double, scrollY: Double): Boolean =
-        if (hasScrollbar()) super.mouseScrolled(mouseX, mouseY, scrollX, scrollY) else true
-
-    class BadgeRow(
-        val parent: BadgesScrollingWidget,
-        val badgeList: List<Badge?>
-    ) : Slot<BadgeRow>() {
-
-        fun renderRow(context: GuiGraphics, y: Int, x: Int, mouseX: Int, mouseY: Int) {
-            badgeList.forEachIndexed { index, badge ->
-                val startPosX = x + ((SLOT_SPACING + SLOT_SIZE) * index)
-                val startPosY = y + SLOT_SPACING
-
-                if (badge != null) {
-                    val obtained = CobblemonClient.clientBadgeData.obtainedBadges.contains(badge.identifier)
-                    blitk(
-                        matrixStack = context.pose(),
-                        texture = badge.texture,
-                        x = startPosX,
-                        y = startPosY,
-                        width = SLOT_SIZE,
-                        height = SLOT_SIZE,
-                        red = if (obtained) 1 else 0,
-                        green = if (obtained) 1 else 0,
-                        blue = if (obtained) 1 else 0
-                    )
-                    if (mouseX in startPosX until startPosX + SLOT_SIZE &&
-                        mouseY in startPosY until startPosY + SLOT_SIZE
-                    ) {
-                        parent.setTooltip(
-                            if (obtained) Component.translatable(badge.name) else lang("badge.unobtained"),
-                            mouseX, mouseY
-                        )
-                    }
-                }
-            }
-        }
-
-        override fun getNarration(): Component? {
-            return badgeList.firstOrNull()?.let { Component.translatable(it.name) }
-        }
-
-        override fun render(
-            guiGraphics: GuiGraphics,
-            index: Int,
-            top: Int,
-            left: Int,
-            width: Int,
-            height: Int,
-            mouseX: Int,
-            mouseY: Int,
-            hovering: Boolean,
-            partialTick: Float
-        ) {}
-    }
-}

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

@@ -1,221 +0,0 @@
-package com.cobblemon.mod.common.client.gui.trainercard
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.badges.Badges
-import com.cobblemon.mod.common.api.pokedex.CaughtCount
-import com.cobblemon.mod.common.api.stats.CobblemonStats.getStat
-import com.cobblemon.mod.common.api.text.text
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.client.gui.CobblemonRenderable
-import com.cobblemon.mod.common.client.render.drawScaledText
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.lang
-import net.minecraft.client.Minecraft
-import net.minecraft.client.gui.GuiGraphics
-import net.minecraft.client.gui.components.Button
-import net.minecraft.client.gui.screens.Screen
-import net.minecraft.client.gui.screens.inventory.InventoryScreen
-import net.minecraft.client.sounds.SoundManager
-import net.minecraft.network.chat.Component
-import net.minecraft.network.protocol.game.ServerboundClientCommandPacket
-import net.minecraft.stats.Stats
-import net.minecraft.util.CommonColors
-import kotlin.math.ceil
-
-class TrainerCardMenu : Screen(
-    Component.translatable("cobblemon.ui.trainercard.title")
-), CobblemonRenderable {
-
-    private var elapsedTicks = 0
-    private var lastSyncedTimePlayed = 0
-    private var panelLeft = 0
-    private var panelTop = 0
-    private lateinit var badgeScrollList: BadgesScrollingWidget
-    private lateinit var leftPageArrow: TrainerCardPageArrow
-    private lateinit var rightPageArrow: TrainerCardPageArrow
-    private var currentPage = 0
-    private val maxPages = 3
-
-    override fun isPauseScreen(): Boolean = false
-
-    override fun init() {
-        super.init()
-        elapsedTicks = 0
-        lastSyncedTimePlayed = getTimePlayed()
-        // stats need to update when we open the menu, otherwise time played only updates when stats menu is opened
-        Minecraft.getInstance().connection?.send(
-            ServerboundClientCommandPacket(ServerboundClientCommandPacket.Action.REQUEST_STATS)
-        )
-
-        val badges = Badges.all().sortedBy { it.order }
-        val panelWidth = minOf(220, (width - 16).coerceAtLeast(1))
-        panelLeft = (width - panelWidth) / 2
-        val leftColumnWidth = panelWidth / 2
-        val badgeAreaWidth = panelWidth - leftColumnWidth - 8
-        val columns = ((badgeAreaWidth + BadgesScrollingWidget.SLOT_SPACING) /
-            (BadgesScrollingWidget.SLOT_SIZE + BadgesScrollingWidget.SLOT_SPACING)).coerceIn(1, 4)
-        val badgeWidth = columns * BadgesScrollingWidget.SLOT_SIZE +
-            (columns - 1) * BadgesScrollingWidget.SLOT_SPACING + 4
-        val rowCount = ceil(badges.size.toDouble() / columns).toInt().coerceAtLeast(1)
-        val rowHeight = BadgesScrollingWidget.SLOT_SIZE + BadgesScrollingWidget.SLOT_SPACING
-        val badgeHeight = minOf(rowCount, BadgesScrollingWidget.MAX_VISIBLE_ROWS) * rowHeight
-        val panelHeight = maxOf(92, badgeHeight + 20)
-        panelTop = ((height - panelHeight) / 2).coerceAtLeast(8)
-
-        badgeScrollList = BadgesScrollingWidget(
-            x = panelLeft + panelWidth - badgeWidth,
-            y = panelTop + 10,
-            width = badgeWidth,
-            height = badgeHeight,
-            columns = columns
-        )
-        badgeScrollList.createEntries(badges)
-        addRenderableWidget(badgeScrollList)
-
-        leftPageArrow = TrainerCardPageArrow(
-            buttonX = panelLeft - 10,
-            buttonY = panelTop,
-            width = 16,
-            height = 16,
-            onPress = {},
-            parent = this,
-            isRight = false
-        )
-        rightPageArrow = TrainerCardPageArrow(
-            buttonX = panelLeft + panelWidth + 10,
-            buttonY = panelTop,
-            width = 16,
-            height = 16,
-            onPress = {},
-            parent = this,
-            isRight = true
-        )
-
-        addRenderableWidget(leftPageArrow)
-        addRenderableWidget(rightPageArrow)
-    }
-
-    override fun tick() {
-        super.tick()
-        // make our own live playtime update, otherwise we have to send a packet a second to retrieve the playtime stat
-        val timePlayed = getTimePlayed()
-        if (timePlayed != lastSyncedTimePlayed) {
-            lastSyncedTimePlayed = timePlayed
-            elapsedTicks = 0
-        } else { elapsedTicks++ }
-    }
-
-    override fun render(context: GuiGraphics, mouseX: Int, mouseY: Int, partialTick: Float) {
-        when(currentPage) {
-            0 -> {
-                val portraitX = panelLeft
-                val portraitY = minOf(panelTop + 48, (height - 32).coerceAtLeast(0))
-                val portraitSize = 30
-                val statsTextWidth = (badgeScrollList.x - panelLeft - 8).coerceAtLeast(1)
-
-                val player = Minecraft.getInstance().player ?: return // unsure of why this would ever not return a player but if you're here maybe it's because it did
-                val entity = Minecraft.getInstance().level?.getPlayerByUUID(player.uuid) ?: return
-
-                context.enableScissor(portraitX, portraitY, portraitX + portraitSize, portraitY + portraitSize)
-                InventoryScreen.renderEntityInInventoryFollowsMouse(context,
-                    portraitX, portraitY, portraitX + portraitSize, portraitY + portraitSize, 28, 0.5f, mouseX.toFloat(), mouseY.toFloat(),
-                    entity
-                )
-
-                context.disableScissor()
-
-                val totalSeconds = (getTimePlayed() + elapsedTicks) / 20
-                val timePlayed = "%d:%02d:%02d:%02d".format(
-                    totalSeconds / 86_400, // days
-                    totalSeconds % 86_400 / 3_600, // hours
-                    totalSeconds % 3_600 / 60, // minutes
-                    totalSeconds % 60 // seconds
-                )
-
-                drawScaledText(
-                    context = context,
-                    text = lang("ui.trainermenu.timeplayed", timePlayed),
-                    x = panelLeft,
-                    y = panelTop + 4,
-                    maxCharacterWidth = statsTextWidth
-                )
-
-                drawScaledText(
-                    context = context,
-                    text = lang("ui.trainermenu.pokemon_registered",
-                        CobblemonClient.clientPokedexData.getDexCalculatedValue(cobblemonResource("national"), CaughtCount)),
-                    x = panelLeft,
-                    y = panelTop + 14,
-                    maxCharacterWidth = statsTextWidth
-                )
-
-                val playerBattlesWon = player.stats.getValue(Stats.CUSTOM.get(getStat(Cobblemon.statistics.PVP_BATTLES_WON)))
-                val playerBattlesLost = player.stats.getValue(Stats.CUSTOM.get(getStat(Cobblemon.statistics.PVP_BATTLES_LOST)))
-
-                if (playerBattlesWon > 0 || playerBattlesLost > 0) {
-                    drawScaledText(
-                        context = context,
-                        text = lang("ui.trainermenu.battle_stats",
-                            playerBattlesWon,
-                            playerBattlesLost
-                        ),
-                        x = panelLeft,
-                        y = panelTop + 24,
-                        maxCharacterWidth = statsTextWidth
-                    )
-                }
-
-                badgeScrollList.render(context, mouseX, mouseY, partialTick)
-            }
-        }
-
-        drawScaledText(
-            context = context,
-            text = Component.literal("$currentPage"),
-            x = panelLeft - 30,
-            y = panelTop
-        )
-
-        if (leftPageArrow.shouldExist()) {
-            leftPageArrow.render(context, mouseX, mouseY, partialTick)
-        }
-
-        if (rightPageArrow.shouldExist()) {
-            rightPageArrow.render(context, mouseX, mouseY, partialTick)
-        }
-
-    }
-
-    private class TrainerCardPageArrow(
-        buttonX: Int,
-        buttonY: Int, width: Int, height: Int, onPress: OnPress,
-        val parent: TrainerCardMenu,
-        val isRight: Boolean
-    ): Button(
-        buttonX, buttonY, width, height, "".text(), onPress, DEFAULT_NARRATION
-    ) {
-
-        fun shouldExist(): Boolean {
-            if (isRight && parent.currentPage == parent.maxPages - 1) return false
-            if (!isRight && parent.currentPage == 0) return false
-            return true
-        }
-
-        override fun renderWidget(context: GuiGraphics, mouseX: Int, mouseY: Int, partialTick: Float) {
-            context.fill(x, y, x + width, y + height, CommonColors.WHITE)
-        }
-
-        override fun playDownSound(handler: SoundManager) {
-            if (shouldExist()) super.playDownSound(handler)
-        }
-
-        override fun onClick(mouseX: Double, mouseY: Double) {
-            if (!shouldExist()) return
-            parent.currentPage += if (isRight) 1 else -1
-        }
-    }
-
-    private fun getTimePlayed(): Int =
-        Minecraft.getInstance().player?.stats?.getValue(Stats.CUSTOM.get(Stats.PLAY_TIME)) ?: 0
-
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/keybind/CobblemonKeyBinds.kt

@@ -39,7 +39,6 @@ object CobblemonKeyBinds {
     val PARTY_OVERLAY_UP = this.queue(UpShiftPartyBinding)
     val SEND_OUT_POKEMON = this.queue(PartySendBinding)
     val RIDING_FREELOOK = this.queue(RidingFreelookBinding)
-    val TRAINER_MENU = this.queue(TrainerMenuBinding)
 
     fun register(registrar: (KeyMapping) -> Unit) {
         this.keyBinds.forEach(registrar::invoke)

common/src/main/kotlin/com/cobblemon/mod/common/client/keybind/keybinds/TrainerMenuBinding.kt

@@ -1,29 +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.keybind.keybinds
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.client.CobblemonClient
-import com.cobblemon.mod.common.client.gui.summary.Summary
-import com.cobblemon.mod.common.client.gui.trainercard.TrainerCardMenu
-import com.cobblemon.mod.common.client.keybind.CobblemonPartyLockedKeyBinding
-import com.cobblemon.mod.common.client.keybind.KeybindCategories
-import com.mojang.blaze3d.platform.InputConstants
-import net.minecraft.client.Minecraft
-
-object TrainerMenuBinding : CobblemonPartyLockedKeyBinding(
-    "key.cobblemon.trainermenu",
-    InputConstants.Type.KEYSYM,
-    InputConstants.KEY_N,
-    KeybindCategories.COBBLEMON_CATEGORY
-) {
-    override fun onPress() {
-        Minecraft.getInstance().setScreen(TrainerCardMenu())
-    }
-}

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

@@ -34,6 +34,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.bedrock.animatio
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.ModelQuirk
 import com.cobblemon.mod.common.client.render.models.blockbench.quirk.QuirkData
+import com.cobblemon.mod.common.client.sound.instances.UIEntitySoundInstance
 import com.cobblemon.mod.common.entity.PosableEntity
 import com.cobblemon.mod.common.entity.PoseType
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
@@ -44,7 +45,6 @@ import com.mojang.brigadier.exceptions.CommandSyntaxException
 import java.util.concurrent.ConcurrentLinkedQueue
 import net.minecraft.client.Minecraft
 import net.minecraft.client.multiplayer.ClientLevel
-import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.commands.arguments.item.ItemParser
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.world.entity.Entity
@@ -289,7 +289,7 @@ abstract class PosableState : Schedulable {
                         entity.level().playLocalSound(entity, soundEvent, entity.soundSource, volume, pitch)
                     }
                 } else {
-                    Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, volume, pitch))
+                    Minecraft.getInstance().soundManager.play(UIEntitySoundInstance(soundEvent, volume, pitch))
                 }
             }
         }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/bedrock/animation/BedrockAnimation.kt

@@ -19,6 +19,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Bone
 import com.cobblemon.mod.common.client.render.models.blockbench.repository.RenderContext
 import com.cobblemon.mod.common.client.sound.instances.AlphaCrySoundInstance
+import com.cobblemon.mod.common.client.sound.instances.UIEntitySoundInstance
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.effectiveName
 import com.cobblemon.mod.common.util.genericRuntime
@@ -31,7 +32,6 @@ import net.minecraft.client.Minecraft
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.client.multiplayer.ClientLevel
 import net.minecraft.client.resources.sounds.EntityBoundSoundInstance
-import net.minecraft.client.resources.sounds.SimpleSoundInstance
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.world.entity.Entity
@@ -121,7 +121,7 @@ class BedrockSoundKeyframe(
                     }
                 }
             } else {
-                Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, 1F, 1F))
+                Minecraft.getInstance().soundManager.play(UIEntitySoundInstance(soundEvent))
             }
         }
     }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/FarfetchdGalarianModel.kt

@@ -29,8 +29,8 @@ class FarfetchdGalarianModel(root: ModelPart) : PokemonPosableModel(root), Heade
     override var portraitScale = 2.6F
     override var portraitTranslation = Vec3(-0.2, -1.0, 0.0)
 
-    override var profileScale = 1.1F
-    override var profileTranslation = Vec3(-0.1, 0.1, 0.0)
+    override var profileScale = 0.93F
+    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/FarfetchdModel.kt

@@ -28,8 +28,8 @@ class FarfetchdModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame,
     override var portraitScale = 2.6F
     override var portraitTranslation = Vec3(-0.2, -1.0, 0.0)
 
-    override var profileScale = 1.1F
-    override var profileTranslation = Vec3(-0.1, 0.1, 0.0)
+    override var profileScale = 0.93F
+    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen1/KabutoModel.kt

@@ -23,8 +23,8 @@ class KabutoModel(root: ModelPart) : PokemonPosableModel(root) {
     override var portraitScale = 3.3F
     override var portraitTranslation = Vec3(0.0, -3.3, 0.0)
 
-    override var profileScale = 1.6F
-    override var profileTranslation = Vec3(0.0, -0.6, 0.0)
+    override var profileScale = 1.25F
+    override var profileTranslation = Vec3(0.0, -0.17, 0.0)
 
     lateinit var standing: CobblemonPose
     lateinit var walk: CobblemonPose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/HoothootModel.kt

@@ -21,8 +21,8 @@ class HoothootModel (root: ModelPart) : PokemonPosableModel(root) {
 
     override var portraitScale = 2.2F
     override var portraitTranslation = Vec3(-0.25, -0.9, 0.0)
-    override var profileScale = 1.0F
-    override var profileTranslation = Vec3(0.0, 0.3, 0.0)
+    override var profileScale = 0.82F
+    override var profileTranslation = Vec3(0.0, 0.53, 0.0)
 
     lateinit var standing: Pose
     lateinit var walk: Pose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/WooperModel.kt

@@ -29,8 +29,8 @@ class WooperModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
     override var portraitScale = 2.0F
     override var portraitTranslation = Vec3(-0.15, -0.65, 0.0)
 
-    override var profileScale = 0.9F
-    override var profileTranslation = Vec3(0.0, 0.4, 0.0)
+    override var profileScale = 0.75F
+    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
 
     lateinit var shoulderLeft: Pose
     lateinit var shoulderRight: Pose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen2/WooperPaldeanModel.kt

@@ -29,8 +29,8 @@ class WooperPaldeanModel(root: ModelPart) : PokemonPosableModel(root), HeadedFra
     override var portraitScale = 2.0F
     override var portraitTranslation = Vec3(-0.15, -0.65, 0.0)
 
-    override var profileScale = 0.9F
-    override var profileTranslation = Vec3(0.0, 0.4, 0.0)
+    override var profileScale = 0.75F
+    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
 
     lateinit var shoulderLeft: Pose
     lateinit var shoulderRight: Pose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen3/DusclopsModel.kt

@@ -34,7 +34,7 @@ class DusclopsModel (root: ModelPart) : PokemonPosableModel(root) {
     lateinit var battleidle: Pose
 
     override fun registerPoses() {
-        animations["cry"] = "q.bedrock_stateful('squirtle', 'cry')".asExpressionLike()
+        animations["cry"] = "q.bedrock_stateful('dusclops', 'cry')".asExpressionLike()
 
         val blink = quirk { bedrockStateful("dusclops", "blink") }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen3/MasquerainModel.kt

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -28,6 +29,8 @@ class MasquerainModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame
     lateinit var walk: Pose
     lateinit var standing: Pose
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('masquerain', 'cry')".asExpressionLike()
+
         val blink = quirk { bedrockStateful("masquerain", "blink") }
         standing = registerPose(
             poseName = "standing",

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen3/SurskitModel.kt

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import com.cobblemon.mod.common.util.isInWater
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
@@ -36,6 +37,8 @@ class SurskitModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
     val wateroffset = -8
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('surskit', 'cry')".asExpressionLike()
+
         val blink = quirk { bedrockStateful("surskit", "blink") }
         standing = registerPose(
             poseName = "standing",

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen4/CombeeModel.kt

@@ -14,6 +14,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -36,6 +37,8 @@ class CombeeModel (root: ModelPart) : PokemonPosableModel(root) {
     val shoulderZOffset = 8
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('combee', 'cry')".asExpressionLike()
+
         val blink1 = quirk { bedrockStateful("combee", "blink_right") }
         val blink2 = quirk { bedrockStateful("combee", "blink_gender") }
         val blink3 = quirk { bedrockStateful("combee", "blink_left") }

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen4/VespiquenModel.kt

@@ -12,6 +12,7 @@ import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonP
 import com.cobblemon.mod.common.client.render.models.blockbench.PosableState
 import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
 import com.cobblemon.mod.common.entity.PoseType
+import com.cobblemon.mod.common.util.asExpressionLike
 import net.minecraft.client.model.geom.ModelPart
 import net.minecraft.world.phys.Vec3
 
@@ -30,6 +31,8 @@ class VespiquenModel (root: ModelPart) : PokemonPosableModel(root) {
     lateinit var standing: Pose
 
     override fun registerPoses() {
+        animations["cry"] = "q.bedrock_stateful('vespiquen', 'cry')".asExpressionLike()
+
         val blink1 = quirk { bedrockStateful("vespiquen", "blink") }
         val wingsleep = quirk { bedrockStateful("vespiquen", "sleep_flap") }
 

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/SerperiorModel.kt

@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SerperiorModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("serperior")
-    override val head = getPart("head_ai")
-
-    override var portraitScale = 2.5F
-    override var portraitTranslation = Vec3(-0.3, 1.25, 0.0)
-
-    override var profileScale = 0.6F
-    override var profileTranslation = Vec3(0.0, 0.8, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var sleep: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("serperior", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("serperior", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            animations = arrayOf(bedrock("serperior", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("serperior", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = PoseType.MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("serperior", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/ServineModel.kt

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BimanualFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class ServineModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BimanualFrame {
-    override val rootPart = root.registerChildWithAllChildren("servine")
-    override val head = getPart("head_ai")
-    override val rightArm = getPart("arm_right")
-    override val leftArm = getPart("arm_left")
-    override val rightLeg = getPart("leg_right")
-    override val leftLeg = getPart("leg_left")
-
-    override var portraitScale = 2.6F
-    override var portraitTranslation = Vec3(-0.15, 0.75, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("servine", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("servine", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(bedrock("servine", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("servine", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walking",
-            poseTypes =  PoseType.MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("servine", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen5/SnivyModel.kt

@@ -1,70 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen5
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BimanualFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SnivyModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BimanualFrame {
-    override val rootPart = root.registerChildWithAllChildren("snivy")
-    override val head = getPart("head_ai")
-    override val rightArm = getPart("arm_right")
-    override val leftArm = getPart("arm_left")
-    override val rightLeg = getPart("leg_right")
-    override val leftLeg = getPart("leg_left")
-
-    override var portraitScale = 2.0F
-    override var portraitTranslation = Vec3(-0.15, 0.32, 0.0)
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var sleep: Pose
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("snivy", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("snivy", "blink") }
-        sleep = registerPose(
-            poseType = PoseType.SLEEP,
-            transformTicks = 10,
-            animations = arrayOf(bedrock("snivy", "sleep"))
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("snivy", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walking",
-            poseTypes =  PoseType.MOVING_POSES,
-            transformTicks = 10,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("snivy", "ground_walk")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen6/CarbinkModel.kt

@@ -23,7 +23,7 @@ class CarbinkModel (root: ModelPart) : PokemonPosableModel(root) {
     override var portraitScale = 1.8F
     override var portraitTranslation = Vec3(0.0, 0.2, 0.0)
 
-    override var profileScale = 0.85F
+    override var profileScale = 0.68F
     override var profileTranslation = Vec3(0.0, 0.7, 0.0)
 
     lateinit var standing: CobblemonPose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen6/GourgeistModel.kt

@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen6
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class GourgeistModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("gourgeist")
-    override val head = getPart("head")
-
-    override var portraitScale = 4.0F
-    override var portraitTranslation = Vec3(-0.1, 0.6, 0.0)
-
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.55, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var hovering: Pose
-    lateinit var fly: Pose
-    lateinit var sleep: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("gourgeist", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("gourgeist", "blink") }
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.UI_POSES + PoseType.STAND,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("gourgeist", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseType = PoseType.WALK,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("gourgeist", "ground_walk")
-            )
-        )
-
-        hovering = registerPose(
-            poseName = "hovering",
-            poseType = PoseType.HOVER,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("gourgeist", "air_idle")
-            )
-        )
-
-        fly = registerPose(
-            poseName = "fly",
-            poseType = PoseType.FLY,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("gourgeist", "air_fly")
-            )
-        )
-
-        sleep = registerPose(
-            poseName = "sleep",
-            poseType = PoseType.SLEEP,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("gourgeist", "sleep")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen6/PumpkabooModel.kt

@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen6
-
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.CobblemonPose
-import com.cobblemon.mod.common.entity.PoseType
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class PumpkabooModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame {
-    override val rootPart = root.registerChildWithAllChildren("pumpkaboo")
-    override val head = getPart("head")
-
-    override var portraitScale = 3.5F
-    override var portraitTranslation = Vec3(0.0, -1.5, 0.0)
-
-    override var profileScale = 1.0F
-    override var profileTranslation = Vec3(0.0, 0.25, 0.0)
-
-    lateinit var standing: CobblemonPose
-    lateinit var walk: CobblemonPose
-    lateinit var battleidle: CobblemonPose
-    lateinit var sleep: CobblemonPose
-
-    override val cryAnimation = CryProvider { bedrockStateful("pumpkaboo", "cry") }
-
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("pumpkaboo", "blink") }
-        val quirk = quirk { bedrockStateful("pumpkaboo", "quirk_idle") }
-
-        sleep = registerPose(
-            poseName = "sleep",
-            poseType = PoseType.SLEEP,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("pumpkaboo", "sleep")
-            )
-        )
-
-        standing = registerPose(
-            poseName = "standing",
-            poseTypes = PoseType.STATIONARY_POSES + PoseType.UI_POSES,
-            quirks = arrayOf(blink, quirk),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("pumpkaboo", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            poseTypes = PoseType.MOVING_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("pumpkaboo", "ground_walk")
-            )
-        )
-
-        battleidle = registerPose(
-            poseName = "battleidle",
-            poseTypes = PoseType.STATIONARY_POSES,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                bedrock("pumpkaboo", "battle_idle")
-            )
-        )
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen6/ScatterbugModel.kt

@@ -26,8 +26,8 @@ class ScatterbugModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame
     override var portraitScale = 2.6F
     override var portraitTranslation = Vec3(-0.2, -1.9, 0.0)
 
-    override var profileScale = 1.2F
-    override var profileTranslation = Vec3(0.0, 0.05, 0.0)
+    override var profileScale = 0.98F
+    override var profileTranslation = Vec3(0.0, 0.28, 0.0)
 
     lateinit var standing: CobblemonPose
     lateinit var walk: CobblemonPose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen9/CharcadetModel.kt

@@ -36,8 +36,8 @@ class CharcadetModel(root: ModelPart) : PokemonPosableModel(root), HeadedFrame,
     override var portraitScale = 1.7F
     override var portraitTranslation = Vec3(-0.15, 0.08, 0.0)
 
-    override var profileScale = 0.8F
-    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
+    override var profileScale = 0.58F
+    override var profileTranslation = Vec3(0.0, 0.91, 0.0)
 
     lateinit var standing: CobblemonPose
     lateinit var walking: CobblemonPose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen9/QuaquavalModel.kt

@@ -35,8 +35,8 @@ class QuaquavalModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame,
     override var portraitScale = 2.3F
     override var portraitTranslation = Vec3(-0.42, 3.7, 0.0)
 
-    override var profileScale = 0.32F
-    override var profileTranslation = Vec3(0.0, 1.24, 0.0)
+    override var profileScale = 0.36F
+    override var profileTranslation = Vec3(0.0, 1.19, 0.0)
 
     lateinit var standing: CobblemonPose
     lateinit var standing2: CobblemonPose

common/src/main/kotlin/com/cobblemon/mod/common/client/render/models/blockbench/pokemon/gen9/SquawkabillyModel.kt

@@ -1,208 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.client.render.models.blockbench.pokemon.gen9
-
-import com.cobblemon.mod.common.client.render.models.blockbench.animation.WingFlapIdleAnimation
-import com.cobblemon.mod.common.client.render.models.blockbench.createTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BiWingedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.BipedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.frame.HeadedFrame
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.CryProvider
-import com.cobblemon.mod.common.client.render.models.blockbench.pokemon.PokemonPosableModel
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.ModelPartTransformation
-import com.cobblemon.mod.common.client.render.models.blockbench.pose.Pose
-import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.parabolaFunction
-import com.cobblemon.mod.common.client.render.models.blockbench.wavefunction.sineFunction
-import com.cobblemon.mod.common.entity.PoseType
-import com.cobblemon.mod.common.util.math.geometry.toRadians
-import net.minecraft.client.model.geom.ModelPart
-import net.minecraft.world.phys.Vec3
-
-class SquawkabillyModel (root: ModelPart) : PokemonPosableModel(root), HeadedFrame, BipedFrame, BiWingedFrame {
-    override val rootPart = root.registerChildWithAllChildren("squawkabilly")
-    override val head = getPart("head")
-    override val leftWing = getPart("wing_left")
-    override val rightWing = getPart("wing_right")
-    override val leftLeg = getPart("leg_left")
-    override val rightLeg = getPart("leg_right")
-    private val tail = getPart("tail")
-
-    override var portraitScale = 2.0F
-    override var portraitTranslation = Vec3(-0.2, -0.2, 0.0)
-
-    override var profileScale = 0.85F
-    override var profileTranslation = Vec3(0.0, 0.51, 0.0)
-
-    lateinit var standing: Pose
-    lateinit var walk: Pose
-    lateinit var hovering: Pose
-    lateinit var flying: Pose
-    lateinit var shoulderLeft: Pose
-    lateinit var shoulderRight: Pose
-
-    override val cryAnimation = CryProvider { bedrockStateful("squawkabilly", "cry") }
-
-    val shoulderOffsetX = -1.0
-    val shoulderOffsetY = 0
-    override fun registerPoses() {
-        val blink = quirk { bedrockStateful("squawkabilly", "blink") }
-
-        standing = registerPose(
-            poseName = "standing",
-            quirks = arrayOf(blink),
-            poseTypes = PoseType.UI_POSES + PoseType.STAND,
-            transformTicks = 10,
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("squawkabilly", "ground_idle")
-            )
-        )
-
-        walk = registerPose(
-            poseName = "walk",
-            quirks = arrayOf(blink),
-            poseType = PoseType.WALK,
-            transformTicks = 10,
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("squawkabilly", "ground_idle"),
-                rootPart.translation(
-                    function = parabolaFunction(
-                        peak = -4F,
-                        period = 0.4F
-                    ),
-                    timeVariable = { state, _, _ -> state.animationSeconds },
-                    axis = ModelPartTransformation.Y_AXIS
-                ),
-                head.translation(
-                    function = sineFunction(
-                        amplitude = (-20F).toRadians(),
-                        period = 1F,
-                        verticalShift = (-10F).toRadians()
-                    ),
-                    axis = ModelPartTransformation.X_AXIS,
-                    timeVariable = { state, _, _ -> state.animationSeconds }
-                ),
-                leftLeg.rotation(
-                    function = parabolaFunction(
-                        tightness = -20F,
-                        phaseShift = 0F,
-                        verticalShift = (30F).toRadians()
-                    ),
-                    axis = ModelPartTransformation.X_AXIS,
-                    timeVariable = { _, _, ageInTicks -> ageInTicks / 20 },
-                ),
-                rightLeg.rotation(
-                    function = parabolaFunction(
-                        tightness = -20F,
-                        phaseShift = 0F,
-                        verticalShift = (30F).toRadians()
-                    ),
-                    axis = ModelPartTransformation.X_AXIS,
-                    timeVariable = { _, _, ageInTicks -> ageInTicks / 20 },
-                ),
-                tail.rotation(
-                    function = sineFunction(
-                        amplitude = (-5F).toRadians(),
-                        period = 1F
-                    ),
-                    axis = ModelPartTransformation.X_AXIS,
-                    timeVariable = { _, _, ageInTicks -> ageInTicks / 20 },
-                ),
-                wingFlap(
-                    flapFunction = sineFunction(
-                        amplitude = (-5F).toRadians(),
-                        period = 0.4F,
-                        phaseShift = 0.00F,
-                        verticalShift = (-20F).toRadians()
-                    ),
-                    timeVariable = { state, _, _ -> state.animationSeconds },
-                    axis = ModelPartTransformation.Z_AXIS
-                ),
-                rightWing.translation(
-                    function = parabolaFunction(
-                        tightness = -10F,
-                        phaseShift = 30F,
-                        verticalShift = (25F).toRadians()
-                    ),
-                    axis = ModelPartTransformation.Y_AXIS,
-                    timeVariable = { _, _, ageInTicks -> ageInTicks / 20 },
-                ),
-                leftWing.translation(
-                    function = parabolaFunction(
-                        tightness = -10F,
-                        phaseShift = 30F,
-                        verticalShift = (25F).toRadians()
-                    ),
-                    axis = ModelPartTransformation.Y_AXIS,
-                    timeVariable = { _, _, ageInTicks -> ageInTicks / 20 },
-                ),
-            )
-        )
-
-        hovering = registerPose(
-            poseName = "hovering",
-            quirks = arrayOf(blink),
-            poseTypes = setOf(PoseType.FLOAT, PoseType.HOVER),
-            transformTicks = 10,
-            animations = arrayOf(
-                singleBoneLook(),
-                WingFlapIdleAnimation(this,
-                    flapFunction = sineFunction(verticalShift = -10F.toRadians(), period = 0.9F, amplitude = 0.9F),
-                    timeVariable = { state, _, _ -> state.animationSeconds },
-                    axis = ModelPartTransformation.Z_AXIS
-                )
-            )
-        )
-
-        flying = registerPose(
-            poseName = "flying",
-            quirks = arrayOf(blink),
-            poseTypes = setOf(PoseType.FLY, PoseType.SWIM),
-            transformTicks = 10,
-            animations = arrayOf(
-                singleBoneLook(),
-                WingFlapIdleAnimation(this,
-                    flapFunction = sineFunction(verticalShift = -14F.toRadians(), period = 0.9F, amplitude = 0.9F),
-                    timeVariable = { state, _, _ -> state.animationSeconds },
-                    axis = ModelPartTransformation.Z_AXIS
-                )
-            )
-        )
-
-        shoulderLeft = registerPose(
-            poseType = PoseType.SHOULDER_LEFT,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("squawkabilly", "ground_idle")
-            ),
-            transformedParts = arrayOf(
-                rootPart.createTransformation().addPosition(shoulderOffsetX, shoulderOffsetY, 0.0)
-            )
-        )
-
-        shoulderRight = registerPose(
-            poseType = PoseType.SHOULDER_RIGHT,
-            quirks = arrayOf(blink),
-            animations = arrayOf(
-                singleBoneLook(),
-                bedrock("squawkabilly", "ground_idle")
-            ),
-            transformedParts = arrayOf(
-                rootPart.createTransformation().addPosition(-shoulderOffsetX, shoulderOffsetY, 0.0)
-            )
-        )
-
-    }
-//    override fun getFaintAnimation(
-//        pokemonEntity: PokemonEntity,
-//        state: PosableState<PokemonEntity>
-//    ) = if (state.isNotPosedIn(sleep)) bedrockStateful("squawkabilly", "faint") else null
-}

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

@@ -322,8 +322,6 @@ object VaryingModelRepository {
         inbuilt("loudred", :: LoudredModel)
         inbuilt("exploud", :: ExploudModel)
         inbuilt("cryogonal", :: CryogonalModel)
-        inbuilt("pumpkaboo", :: PumpkabooModel)
-        inbuilt("gourgeist", :: GourgeistModel)
         inbuilt("eiscue", :: EiscueModel)
         inbuilt("wooloo", :: WoolooModel)
         inbuilt("dubwool", :: DubwoolModel)
@@ -340,9 +338,6 @@ object VaryingModelRepository {
         inbuilt("thwackey", ::ThwackeyModel)
         inbuilt("rillaboom", ::RillaboomModel)
         inbuilt("samurott", ::SamurottModel)
-        inbuilt("snivy", ::SnivyModel)
-        inbuilt("servine", ::ServineModel)
-        inbuilt("serperior", ::SerperiorModel)
         inbuilt("slugma", ::SlugmaModel)
         inbuilt("magcargo", ::MagcargoModel)
         inbuilt("slugma_shiny", ::SlugmaShinyModel)
@@ -402,7 +397,6 @@ object VaryingModelRepository {
         inbuilt("bunnelby", ::BunnelbyModel)
         inbuilt("arrokuda", ::ArrokudaModel)
         inbuilt("barraskewda", ::BarraskewdaModel)
-        inbuilt("squawkabilly", ::SquawkabillyModel)
         inbuilt("ponyta_galarian", ::PonytaGalarianModel)
         inbuilt("rapidash_galarian", ::RapidashGalarianModel)
         inbuilt("volbeat", ::VolbeatModel)

common/src/main/kotlin/com/cobblemon/mod/common/client/sound/instances/UIEntitySoundInstance.kt

@@ -0,0 +1,22 @@
+/*
+ * 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.sound.instances
+
+import net.minecraft.client.resources.sounds.SimpleSoundInstance
+import net.minecraft.client.resources.sounds.SoundInstance
+import net.minecraft.sounds.SoundEvent
+import net.minecraft.sounds.SoundSource
+
+/**
+ * Plays a sound for a Pokémon rendered in a GUI, where there is no entity to take the sound source from.
+ * Unlike [SimpleSoundInstance.forUI] this uses [SoundSource.NEUTRAL] so the Friendly Creatures slider applies.
+ */
+class UIEntitySoundInstance(sound: SoundEvent, volume: Float = 1F, pitch: Float = 1F) :
+    SimpleSoundInstance(sound.location, SoundSource.NEUTRAL, volume, pitch, SoundInstance.createUnseededRandom(),
+        false, 0, SoundInstance.Attenuation.NONE, 0.0, 0.0, 0.0, true)

common/src/main/kotlin/com/cobblemon/mod/common/command/BadgeCommand.kt

@@ -1,69 +0,0 @@
-package com.cobblemon.mod.common.command
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.permission.CobblemonPermissions
-import com.cobblemon.mod.common.command.argument.BadgeArgumentType
-import com.cobblemon.mod.common.util.permission
-import com.mojang.brigadier.Command
-import com.mojang.brigadier.CommandDispatcher
-import com.mojang.brigadier.context.CommandContext
-import net.minecraft.commands.CommandSourceStack
-import net.minecraft.commands.Commands
-import net.minecraft.commands.arguments.EntityArgument
-import net.minecraft.network.chat.Component
-import net.minecraft.server.level.ServerPlayer
-
-object BadgeCommand {
-
-    private const val NAME = "badge"
-    private const val GIVE = "give"
-    private const val REMOVE = "remove"
-    private const val PLAYER = "player"
-
-    fun register(dispatcher: CommandDispatcher<CommandSourceStack>) {
-        val command =
-            Commands.literal(NAME)
-                .permission(CobblemonPermissions.BADGE)
-                .then(Commands.literal(GIVE)
-                    .then(Commands.argument(PLAYER, EntityArgument.player())
-                        .then(Commands.argument(BADGE, BadgeArgumentType.badge())
-                            .executes { executeGive(it, EntityArgument.getPlayer(it, PLAYER)) }
-                        )
-                    )
-                )
-                .then(Commands.literal(REMOVE)
-                    .then(Commands.argument(PLAYER, EntityArgument.player())
-                        .then(Commands.argument(BADGE, BadgeArgumentType.badge())
-                            .executes { executeRemove(it, EntityArgument.getPlayer(it, PLAYER)) }
-                        )
-                    )
-                )
-        dispatcher.register(command)
-    }
-
-    private fun executeGive(context: CommandContext<CommandSourceStack>, player: ServerPlayer): Int {
-        val badge = BadgeArgumentType.getBadge(context, BADGE)
-        val changed = Cobblemon.playerDataManager.getBadgeData(player).give(badge)
-        val message = if (changed) {
-            "Gave ${badge.name} to ${player.name.string}."
-        } else {
-            "${player.name.string} already has ${badge.name}."
-        }
-        context.source.sendSuccess({ Component.literal(message) }, true)
-        return Command.SINGLE_SUCCESS
-    }
-
-    private fun executeRemove(context: CommandContext<CommandSourceStack>, player: ServerPlayer): Int {
-        val badge = BadgeArgumentType.getBadge(context, BADGE)
-        val changed = Cobblemon.playerDataManager.getBadgeData(player).remove(badge)
-        val message = if (changed) {
-            "Removed ${badge} from ${player.name.string}." // TODO move this to lang
-        } else {
-            "${player.name.string} does not have ${badge.name}."
-        }
-        context.source.sendSuccess({ Component.literal(message) }, true)
-        return Command.SINGLE_SUCCESS
-    }
-
-    private const val BADGE = "badge"
-}

common/src/main/kotlin/com/cobblemon/mod/common/command/argument/BadgeArgumentType.kt

@@ -1,51 +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.command.argument
-
-import com.cobblemon.mod.common.api.badges.Badge
-import com.cobblemon.mod.common.api.badges.Badges
-import com.cobblemon.mod.common.util.asIdentifierDefaultingNamespace
-import com.mojang.brigadier.StringReader
-import com.mojang.brigadier.arguments.ArgumentType
-import com.mojang.brigadier.context.CommandContext
-import com.mojang.brigadier.exceptions.SimpleCommandExceptionType
-import com.mojang.brigadier.suggestion.Suggestions
-import com.mojang.brigadier.suggestion.SuggestionsBuilder
-import net.minecraft.commands.SharedSuggestionProvider
-import net.minecraft.network.chat.Component
-import java.util.concurrent.CompletableFuture
-
-class BadgeArgumentType : ArgumentType<Badge> {
-
-    override fun parse(reader: StringReader): Badge {
-        val identifier = try {
-            reader.asIdentifierDefaultingNamespace()
-        } catch (exception: Exception) {
-            throw SimpleCommandExceptionType(INVALID_BADGE).createWithContext(reader)
-        }
-        return Badges.getByIdentifier(identifier)
-            ?: throw SimpleCommandExceptionType(INVALID_BADGE).createWithContext(reader)
-    }
-
-    override fun <S : Any> listSuggestions(
-        context: CommandContext<S>,
-        builder: SuggestionsBuilder
-    ): CompletableFuture<Suggestions> {
-        return SharedSuggestionProvider.suggest(Badges.all().map { it.identifier.toString() }, builder)
-    }
-
-    companion object {
-        private val INVALID_BADGE = Component.translatable("cobblemon.command.badge.invalid")
-
-        fun badge() = BadgeArgumentType()
-
-        fun <S> getBadge(context: CommandContext<S>, name: String): Badge =
-            context.getArgument(name, Badge::class.java)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/config/CobblemonConfig.kt

@@ -47,6 +47,10 @@ class CobblemonConfig {
     @IntConstraint(min = 0, max = 1000)
     var maxPokemonFriendship = 255
 
+    @CobblemonConfigField(Category.Pokemon, lang = "power_item_ride_stat_gain_interval_seconds", SERVER)
+    @IntConstraint(min = -1, max = Int.MAX_VALUE)
+    var powerItemRideStatGainIntervalSeconds = 120
+
     @CobblemonConfigField(Category.Pokemon, lang = "announce_drop_items", SERVER)
     var announceDropItems = true
     @CobblemonConfigField(Category.Pokemon, lang = "default_drop_item_method", SERVER)
@@ -164,6 +168,9 @@ class CobblemonConfig {
     @CobblemonConfigField(Category.Pokemon, lang = "experience_multiplier", SERVER)
     var experienceMultiplier = 2F
 
+    @CobblemonConfigField(Category.Pokemon, lang = "predation_chance", SERVER)
+    var predationChance = 0.05F
+
     @CobblemonConfigField(Category.Spawning, lang = "pokemon_per_chunk", SERVER)
     var pokemonPerChunk = 1F
 

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

@@ -11,7 +11,6 @@ package com.cobblemon.mod.common.data
 import com.cobblemon.mod.common.*
 import com.cobblemon.mod.common.Cobblemon.LOGGER
 import com.cobblemon.mod.common.api.abilities.Abilities
-import com.cobblemon.mod.common.api.badges.Badges
 import com.cobblemon.mod.common.api.berry.Berries
 import com.cobblemon.mod.common.api.cooking.Seasonings
 import com.cobblemon.mod.common.api.data.DataProvider
@@ -121,7 +120,6 @@ object CobblemonDataProvider : DataProvider {
         this.register(SpawnBaitEffects, reloadable = false)
         this.register(CobblemonRideSettings, reloadable = true)
         this.register(TechnicalMachines, reloadable = false)
-        this.register(Badges, reloadable = true)
         SpawnBait.Effects.setupEffects()
 
         PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe {

common/src/main/kotlin/com/cobblemon/mod/common/entity/pokemon/PokemonEntity.kt

@@ -1294,16 +1294,7 @@ open class PokemonEntity(
     }
 
     private fun showInteractionWheel(player: ServerPlayer, itemStack: ItemStack) {
-         val canRide = ifRidingAvailableSupply(false) { behaviour, settings, state ->
-            if (platform != PlatformType.NONE) return@ifRidingAvailableSupply false
-            if (tethering != null) return@ifRidingAvailableSupply false;
-            if (seats.isEmpty()) return@ifRidingAvailableSupply false;
-            if ((owner as? ServerPlayer)?.isInBattle() == true) return@ifRidingAvailableSupply false;
-            if (this.owner != player && this.passengers.isEmpty()) return@ifRidingAvailableSupply false;
-            if(pokemon.effectiveScale < Cobblemon.config.minimumRidingScale) return@ifRidingAvailableSupply false;
-            if(beamMode == 3) return@ifRidingAvailableSupply false;
-            return@ifRidingAvailableSupply behaviour.isActive(settings, state, this);
-        }
+        val canRide = isRideableFor(player)
         if (pokemon.getOwnerPlayer() == player) {
             val cosmeticItemDefinition = CobblemonCosmeticItems.findValidCosmeticForPokemonAndItem(
                 player.level().registryAccess(),
@@ -1325,6 +1316,18 @@ open class PokemonEntity(
         }
     }
 
+    fun isRideableFor(player: ServerPlayer): Boolean = ifRidingAvailableSupply(false) canRide@{ behaviour, settings, state ->
+        if (!player.canInteractWithEntity(this, player.entityInteractionRange())) return@canRide false
+        if (platform != PlatformType.NONE) return@canRide false
+        if (tethering != null) return@canRide false
+        if (seats.isEmpty()) return@canRide false
+        if ((owner as? ServerPlayer)?.isInBattle() == true) return@canRide false
+        if (this.owner != player && this.passengers.isEmpty()) return@canRide false
+        if (pokemon.effectiveScale < Cobblemon.config.minimumRidingScale) return@canRide false
+        if (beamMode == 3) return@canRide false
+        return@canRide behaviour.isActive(settings, state, this)
+    }
+
     override fun getDimensions(pose: Pose): EntityDimensions {
         val scale = effects.mockEffect?.scale ?: (form.baseScale * pokemon.effectiveScale)
         var result = this.exposedForm.hitbox.scale(scale)
@@ -1606,9 +1609,8 @@ open class PokemonEntity(
                 || stack.`is`(CobblemonItemTags.WHITELISTED_ITEMS_TO_HOLD)
 
     fun tryRidingPokemon(player: ServerPlayer): Boolean {
-        if (pokemon.effectiveScale < Cobblemon.config.minimumRidingScale) {
-            return false
-        }
+        if (!isRideableFor(player)) return false
+
         val event = RidePokemonEvent.Pre(player, this)
         CobblemonEvents.RIDE_EVENT_PRE.post(event)
         if (!event.isCanceled) {
@@ -2742,4 +2744,9 @@ open class PokemonEntity(
     }
 
     fun hasRider() = this.passengers.any { it is LivingEntity }
-}
+
+    override fun playStepSound(pos: BlockPos, state: BlockState) {
+        if (this.pokemon.species.silenceStepSounds) return
+        super.playStepSound(pos, state)
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/entity/pokemon/PokemonServerDelegate.kt

@@ -22,6 +22,7 @@ import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.feature.TickingSpeciesFeature
 import com.cobblemon.mod.common.api.pokemon.status.Statuses
+import com.cobblemon.mod.common.api.riding.stats.RidingStat
 import com.cobblemon.mod.common.api.spawning.fishing.FishingSpawnCause.Companion.DROPS_REROLL_ASPECT
 import com.cobblemon.mod.common.api.tags.CobblemonItemTags
 import com.cobblemon.mod.common.battles.BattleRegistry
@@ -46,10 +47,15 @@ import kotlin.math.*
 
 /** Handles purely server logic for a Pokémon */
 class PokemonServerDelegate : PokemonSideDelegate {
+    companion object {
+        private const val RIDE_STAT_GAIN_AMOUNT = 1F
+    }
+
     lateinit var entity: PokemonEntity
     var acknowledgedHPValue = -1
     var acknowledgedLevel = -1
     val passengerOffsets = mutableMapOf<Int, Vec3>()
+    private var rideStatGainAnchor: Vec3? = null
 
     /** Mocked properties exposed to the client [PokemonEntity]. */
     private val mock: PokemonProperties?
@@ -355,9 +361,30 @@ class PokemonServerDelegate : PokemonSideDelegate {
             }
         }
 
+        val rideStatGainIntervalSeconds = Cobblemon.config.powerItemRideStatGainIntervalSeconds
+        if (rideStatGainIntervalSeconds > 0) {
+            val rideStatGainIntervalTicks = rideStatGainIntervalSeconds * 20L
+            if (entity.level().gameTime % rideStatGainIntervalTicks == 0L) {
+                trainRideStats()
+            }
+        }
+
         updateTrackedValues()
     }
 
+    private fun trainRideStats() {
+        val position = entity.position()
+        val anchor = rideStatGainAnchor
+        rideStatGainAnchor = position
+        if (anchor == null || anchor == position || entity.passengers.isEmpty()) return
+
+        val heldItem = entity.pokemon.heldItemNoCopy()
+        if (heldItem.isEmpty) return
+
+        val stat = RidingStat.entries.firstOrNull { heldItem.`is`(it.powerItem) } ?: return
+        entity.pokemon.addRideBoost(stat, RIDE_STAT_GAIN_AMOUNT)
+    }
+
     fun updateShownItem() {
         val trackedShownItem = when {
             // Show Hand Item if Held item is hidden

common/src/main/kotlin/com/cobblemon/mod/common/events/StatHandler.kt

@@ -78,21 +78,10 @@ object StatHandler : EventHandler {
 
     fun onWinBattle(event : BattleVictoryEvent) {
         if (!event.wasWildCapture) {
-            if(event.battle.isPvP) {
-                event.winners
-                    .flatMap { it.getPlayerUUIDs().mapNotNull(UUID::getPlayer) }
-                    .forEach { player -> player.awardStat(getStat(Cobblemon.statistics.PVP_BATTLES_WON)) }
-                event.losers
-                    .flatMap { it.getPlayerUUIDs().mapNotNull(UUID::getPlayer) }
-                    .forEach { player -> player.awardStat(getStat(Cobblemon.statistics.PVP_BATTLES_LOST)) }
-            }
             if (event.battle.isPvW) {
                 event.winners
                     .flatMap { it.getPlayerUUIDs().mapNotNull(UUID::getPlayer) }
                     .forEach { player -> player.awardStat(getStat(Cobblemon.statistics.BATTLES_WON)) }
-                event.losers
-                    .flatMap { it.getPlayerUUIDs().mapNotNull(UUID::getPlayer) }
-                    .forEach { player -> player.awardStat(getStat(Cobblemon.statistics.BATTLES_LOST)) }
             }
         }
     }

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

@@ -570,6 +570,47 @@ object CobblemonItemGroups {
         entries.accept(CobblemonItems.PINK_PLAQUE)
 
         CobblemonItems.campfire_pots.forEach(entries::accept)
+
+        entries.accept(CobblemonItems.COPPER_OVEN)
+        entries.accept(CobblemonItems.COPPER_WASHER)
+        entries.accept(CobblemonItems.COPPER_FAN)
+        entries.accept(CobblemonItems.COPPER_MOWER)
+        entries.accept(CobblemonItems.COPPER_FRIDGE)
+        entries.accept(CobblemonItems.EXPOSED_COPPER_OVEN)
+        entries.accept(CobblemonItems.EXPOSED_COPPER_WASHER)
+        entries.accept(CobblemonItems.EXPOSED_COPPER_FAN)
+        entries.accept(CobblemonItems.EXPOSED_COPPER_MOWER)
+        entries.accept(CobblemonItems.EXPOSED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.WEATHERED_COPPER_OVEN)
+        entries.accept(CobblemonItems.WEATHERED_COPPER_WASHER)
+        entries.accept(CobblemonItems.WEATHERED_COPPER_FAN)
+        entries.accept(CobblemonItems.WEATHERED_COPPER_MOWER)
+        entries.accept(CobblemonItems.WEATHERED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.OXIDIZED_COPPER_OVEN)
+        entries.accept(CobblemonItems.OXIDIZED_COPPER_WASHER)
+        entries.accept(CobblemonItems.OXIDIZED_COPPER_FAN)
+        entries.accept(CobblemonItems.OXIDIZED_COPPER_MOWER)
+        entries.accept(CobblemonItems.OXIDIZED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.WAXED_COPPER_OVEN)
+        entries.accept(CobblemonItems.WAXED_COPPER_WASHER)
+        entries.accept(CobblemonItems.WAXED_COPPER_FAN)
+        entries.accept(CobblemonItems.WAXED_COPPER_MOWER)
+        entries.accept(CobblemonItems.WAXED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.WAXED_EXPOSED_COPPER_OVEN)
+        entries.accept(CobblemonItems.WAXED_EXPOSED_COPPER_WASHER)
+        entries.accept(CobblemonItems.WAXED_EXPOSED_COPPER_FAN)
+        entries.accept(CobblemonItems.WAXED_EXPOSED_COPPER_MOWER)
+        entries.accept(CobblemonItems.WAXED_EXPOSED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.WAXED_WEATHERED_COPPER_OVEN)
+        entries.accept(CobblemonItems.WAXED_WEATHERED_COPPER_WASHER)
+        entries.accept(CobblemonItems.WAXED_WEATHERED_COPPER_FAN)
+        entries.accept(CobblemonItems.WAXED_WEATHERED_COPPER_MOWER)
+        entries.accept(CobblemonItems.WAXED_WEATHERED_COPPER_FRIDGE)
+        entries.accept(CobblemonItems.WAXED_OXIDIZED_COPPER_OVEN)
+        entries.accept(CobblemonItems.WAXED_OXIDIZED_COPPER_WASHER)
+        entries.accept(CobblemonItems.WAXED_OXIDIZED_COPPER_FAN)
+        entries.accept(CobblemonItems.WAXED_OXIDIZED_COPPER_MOWER)
+        entries.accept(CobblemonItems.WAXED_OXIDIZED_COPPER_FRIDGE)
     }
 
     private fun consumableEntries(displayContext: ItemDisplayParameters, entries: Output) {

common/src/main/kotlin/com/cobblemon/mod/common/item/interactive/PonigiriItem.kt

@@ -9,6 +9,7 @@
 package com.cobblemon.mod.common.item.interactive
 
 import com.cobblemon.mod.common.CobblemonItemComponents
+import com.cobblemon.mod.common.item.components.FoodComponent
 import net.minecraft.network.chat.Component
 import net.minecraft.sounds.SoundEvent
 import net.minecraft.sounds.SoundEvents
@@ -23,10 +24,15 @@ import net.minecraft.world.level.Level
 class PonigiriItem : Item(
         Properties().stacksTo(64)
                 .food(FoodProperties.Builder()
-                        .nutrition(2)
-                        .saturationModifier(0.55f)
+                        .nutrition(NUTRITION)
+                        .saturationModifier(SATURATION_MODIFIER)
                         .build())
 ) {
+    companion object {
+        const val NUTRITION = 2
+        const val SATURATION_MODIFIER = 0.55f
+    }
+
     override fun getName(stack: ItemStack): Component {
 
         val ingredients = stack.get(CobblemonItemComponents.INGREDIENT)
@@ -59,4 +65,9 @@ class PonigiriItem : Item(
     override fun getEatingSound(): SoundEvent {
         return SoundEvents.GENERIC_EAT
     }
-}
+
+    fun getFoodValues(stack: ItemStack): Pair<Int, Float> {
+        val (hunger, saturation) = stack.getOrDefault(CobblemonItemComponents.FOOD, FoodComponent(NUTRITION, SATURATION_MODIFIER))
+        return hunger to saturation
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/net/messages/client/data/BadgeRegistrySyncPacket.kt

@@ -1,47 +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.net.messages.client.data
-
-import com.cobblemon.mod.common.api.badges.Badge
-import com.cobblemon.mod.common.api.badges.Badges
-import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.readIdentifier
-import com.cobblemon.mod.common.util.readString
-import com.cobblemon.mod.common.util.writeIdentifier
-import com.cobblemon.mod.common.util.writeString
-import net.minecraft.network.RegistryFriendlyByteBuf
-
-class BadgeRegistrySyncPacket(badges: List<Badge>) : DataRegistrySyncPacket<Badge, BadgeRegistrySyncPacket>(badges) {
-    companion object {
-        val ID = cobblemonResource("badges")
-        fun decode(buffer: RegistryFriendlyByteBuf) = BadgeRegistrySyncPacket(emptyList()).apply { decodeBuffer(buffer) }
-    }
-
-
-    override val id = ID
-    override fun encodeEntry(buffer: RegistryFriendlyByteBuf, entry: Badge) {
-        buffer.writeIdentifier(entry.identifier)
-        buffer.writeString(entry.name)
-        buffer.writeResourceLocation(entry.texture)
-        buffer.writeInt(entry.order)
-    }
-
-    override fun decodeEntry(buffer: RegistryFriendlyByteBuf): Badge {
-        return Badge(
-            order = buffer.readInt(),
-            texture = buffer.readResourceLocation(),
-            name = buffer.readString(),
-            identifier = buffer.readIdentifier()
-        )
-    }
-
-    override fun synchronizeDecoded(entries: Collection<Badge>) {
-        Badges.reload(entries.associateBy { it.identifier })
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/net/serverhandling/battle/BattleSelectActionsHandler.kt

@@ -8,9 +8,12 @@
 
 package com.cobblemon.mod.common.net.serverhandling.battle
 
+import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.net.ServerNetworkPacketHandler
 import com.cobblemon.mod.common.api.text.red
 import com.cobblemon.mod.common.battles.BattleRegistry
+import com.cobblemon.mod.common.battles.HealItemActionResponse
+import com.cobblemon.mod.common.battles.MoveActionResponse
 import com.cobblemon.mod.common.exception.IllegalActionChoiceException
 import com.cobblemon.mod.common.net.messages.client.battle.BattleMakeChoicePacket
 import com.cobblemon.mod.common.net.messages.client.battle.BattleQueueRequestPacket
@@ -25,6 +28,27 @@ object BattleSelectActionsHandler : ServerNetworkPacketHandler<BattleSelectActio
         if (!actor.mustChoose) {
             return
         }
+
+        // Battle command injection attempt detection
+        packet.showdownActionResponses.asSequence()
+            .flatMap {
+                when (it) {
+                    is MoveActionResponse -> sequenceOf(it.moveName, it.targetPnx, it.gimmickID)
+                    is HealItemActionResponse -> sequenceOf(it.item)
+                    else -> emptySequence()
+                }
+            }
+            .filterNotNull()
+            .firstOrNull { field -> field.any(Char::isISOControl) }
+            ?.let {
+                // Escapes control chars as \uXXXX to prevent forging logs.
+                val printable = it.replace(Regex("\\p{Cc}")) { "\\u%04x".format(it.value[0].code) }
+                Cobblemon.LOGGER.warn("Blocked battle command injection from ${player.name.string}: $printable")
+                actor.sendUpdate(BattleQueueRequestPacket(actor.request!!))
+                actor.sendUpdate(BattleMakeChoicePacket())
+                return
+            }
+
         try {
             actor.setActionResponses(packet.showdownActionResponses)
         } catch (e: IllegalActionChoiceException) {

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/Species.kt

@@ -173,6 +173,7 @@ class Species : ShowdownIdentifiable {
         .addStandardFunctions()
         .addSpeciesFunctions(this)
 
+    var silenceStepSounds = false
 
     fun initialize() {
         Cobblemon.statProvider.provide(this)
@@ -256,6 +257,7 @@ class Species : ShowdownIdentifiable {
         }
 
         this.riding.encode(buffer)
+        buffer.writeBoolean(this.silenceStepSounds)
     }
 
     fun decode(buffer: RegistryFriendlyByteBuf) {
@@ -299,6 +301,7 @@ class Species : ShowdownIdentifiable {
             }
         }
         this.riding = RidingProperties.decode(buffer)
+        this.silenceStepSounds = buffer.readBoolean()
         this.initialize()
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/pokemon/properties/PropertiesCompletionProvider.kt

@@ -135,17 +135,18 @@ internal object PropertiesCompletionProvider : DataRegistry {
     private fun addDefaults() {
         this.inject(setOf("level", "lvl", "l"), setOf("1", "${Cobblemon.config.maxPokemonLevel}") )
         this.inject(setOf("shiny", "s"), setOf("yes", "no"))
+        this.inject(setOf("alpha", "is_alpha"), setOf("yes", "no"))
         this.inject(setOf("gender"), Gender.entries.map { it.name.lowercase() })
         this.inject(setOf("friendship"), setOf("0", Cobblemon.config.maxPokemonFriendship.toString()))
         this.inject(setOf("fullness"), setOf("0", "255"))
         this.inject(setOf("pokeball"), PokeBalls.all().map { it.name.simplify() })
         this.inject(setOf("nature"), Natures.all().map { it.name.simplify() })
         this.inject(setOf("ability"), Abilities.all().map { if (it.name.asIdentifierDefaultingNamespace().namespace == Cobblemon.MODID) it.name.asIdentifierDefaultingNamespace().path else it.name })
-        this.inject(setOf("dmax"), setOf("0", Cobblemon.config.maxDynamaxLevel.toString()))
-        this.inject(setOf("gmax"), setOf("yes", "no"))
+        this.inject(setOf("dmax_level", "dmax"), setOf("0", Cobblemon.config.maxDynamaxLevel.toString()))
+        this.inject(setOf("gmax_factor", "gmax"), setOf("yes", "no"))
         this.inject(setOf("type", "elemental_type"), ElementalTypes.all().map { it.name })
         this.inject(setOf("tera_type", "tera"), TeraTypes.map { it.id.simplify() })
-        this.inject(setOf("tradeable"), setOf("yes", "no"))
+        this.inject(setOf("tradeable", "tradable"), setOf("yes", "no"))
         this.inject(setOf("originaltrainer", "ot"), setOf(""))
         this.inject(setOf("originaltrainertype", "ottype"), setOf("None", "Player", "NPC"))
         this.inject(setOf("nickname", "nick"), setOf(""))

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

@@ -234,11 +234,11 @@ fun Entity.isDusk(): Boolean {
 }
 
 fun Entity.isStandingOn(blocks: Set<String>, depth: Int = 2): Boolean {
-    for (currentDepth in 1..depth) {
-        val bellowBlockPos = blockPosition().below(currentDepth)
+    for (currentDepth in 0..depth) {
+        val bellowBlockPos = blockPosBelowThatAffectsMyMovement.below(currentDepth)
         val blockState = level().getBlockState(bellowBlockPos)
 
-        if (blockState.isAir || !blockState.isCollisionShapeFullBlock(level(), bellowBlockPos)) continue
+        if (blockState.isAir) continue
 
         val elementOrTags = ExtraCodecs.TAG_OR_ELEMENT_ID.listOf().decode(JavaOps.INSTANCE, blocks.toList()).result().get().first
         elementOrTags.forEach {

common/src/main/kotlin/com/cobblemon/mod/common/world/gamerules/CobblemonGameRules.kt

@@ -26,5 +26,8 @@ object CobblemonGameRules {
     val SHINY_STARTERS: GameRules.Key<GameRules.BooleanValue> = Cobblemon.implementation.registerGameRule("doShinyStarters", GameRules.Category.MISC, BooleanRuleInvoker.`cobblemon$create`(false))
     @JvmField
     val HEALERS_HEAL_PC: GameRules.Key<GameRules.BooleanValue> = Cobblemon.implementation.registerGameRule("healersHealPC", GameRules.Category.MISC, BooleanRuleInvoker.`cobblemon$create`(false))
-
+    @JvmField
+    val HEALER_SET_SPAWN: GameRules.Key<GameRules.BooleanValue> = Cobblemon.implementation.registerGameRule("healersSetSpawn", GameRules.Category.MISC, BooleanRuleInvoker.`cobblemon$create`(false))
+    @JvmField
+    val DO_POKEMON_PREDATION: GameRules.Key<GameRules.BooleanValue> = Cobblemon.implementation.registerGameRule("doPokemonPredation", GameRules.Category.MOBS, BooleanRuleInvoker.`cobblemon$create`(true))
 }

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_actor.particle.json

@@ -0,0 +1,90 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_actor",
+			"basic_render_parameters": {
+				"material": "particles_blend",
+				"texture": "textures/particles/moves/watershuriken"
+			}
+		},
+		"curves": {
+			"variable.rsize": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [0, 1, 1, 1, 1, 1, 1, 1]
+			}
+		},
+		"events": {
+			"trail": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_actortrail",
+					"type": "particle"
+				}
+			},
+			"hit": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_target",
+					"type": "particle"
+				}
+			}
+		},
+		"components": {
+			"minecraft:emitter_initialization": {
+				"creation_expression": "v.target_deltaz=5;"
+			},
+			"minecraft:emitter_rate_instant": {
+				"num_particles": 1
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 0.25
+			},
+			"minecraft:emitter_shape_disc": {
+				"offset": [0, 0.02, 0.1],
+				"radius": 0.5,
+				"direction": "outwards"
+			},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": 0.35
+			},
+			"minecraft:particle_lifetime_events": {
+				"timeline": {
+					"0.00": "trail",
+					"0.06": "trail",
+					"0.12": "trail",
+					"0.18": "trail",
+					"0.24": "trail",
+					"0.30": "trail",
+					"0.34": "hit"
+				}
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.random_integer(0,3)*90"
+			},
+			"minecraft:particle_motion_parametric": {
+				"relative_position": ["-v.target_deltax*(v.particle_age / v.particle_lifetime)", "(v.target_deltay*(v.particle_age / v.particle_lifetime))", "-v.target_deltaz*(v.particle_age / v.particle_lifetime)"]
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.4*v.rsize", "0.4*v.rsize"],
+				"facing_camera_mode": "lookat_direction",
+				"direction": {
+					"mode": "custom",
+					"custom_direction": [0, 0, -1]
+				},
+				"uv": {
+					"texture_width": 60,
+					"texture_height": 15,
+					"flipbook": {
+						"base_UV": [0, 0],
+						"size_UV": [15, 15],
+						"step_UV": [15, 0],
+						"frames_per_second": 24,
+						"max_frame": 4,
+						"loop": true
+					}
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_actoralt.particle.json

@@ -0,0 +1,91 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_actoralt",
+			"basic_render_parameters": {
+				"material": "particles_blend",
+				"texture": "textures/particles/moves/watershuriken"
+			}
+		},
+		"curves": {
+			"variable.rsize": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [0, 1, 1, 1, 1, 1, 1, 1]
+			}
+		},
+		"events": {
+			"trail": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_actortrail",
+					"type": "particle"
+				}
+			},
+			"hit": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_target",
+					"type": "particle"
+				}
+			}
+		},
+		"components": {
+			"minecraft:emitter_initialization": {
+				"creation_expression": "v.target_deltaz=5;"
+			},
+			"minecraft:emitter_rate_steady": {
+				"spawn_rate": 7,
+				"max_particles": 3
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 0.4
+			},
+			"minecraft:emitter_shape_disc": {
+				"offset": [0, 0.02, 0.1],
+				"radius": 0.5,
+				"direction": "outwards"
+			},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": 0.35
+			},
+			"minecraft:particle_lifetime_events": {
+				"timeline": {
+					"0.00": "trail",
+					"0.06": "trail",
+					"0.12": "trail",
+					"0.18": "trail",
+					"0.24": "trail",
+					"0.30": "trail",
+					"0.34": "hit"
+				}
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.random_integer(0,3)*90"
+			},
+			"minecraft:particle_motion_parametric": {
+				"relative_position": ["-(v.target_deltax+((v.particle_random_1-0.5)*1.33))*(v.particle_age / v.particle_lifetime)", "(v.target_deltay+((v.particle_random_2-0.5)*1.33))*(v.particle_age / v.particle_lifetime)", "-v.target_deltaz*(v.particle_age / v.particle_lifetime)"]
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.4*v.rsize", "0.4*v.rsize"],
+				"facing_camera_mode": "lookat_direction",
+				"direction": {
+					"mode": "custom",
+					"custom_direction": [0, 0, -1]
+				},
+				"uv": {
+					"texture_width": 60,
+					"texture_height": 15,
+					"flipbook": {
+						"base_UV": [0, 0],
+						"size_UV": [15, 15],
+						"step_UV": [15, 0],
+						"frames_per_second": 24,
+						"max_frame": 4,
+						"loop": true
+					}
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_actorhor.particle.json

@@ -0,0 +1,86 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_actorhor",
+			"basic_render_parameters": {
+				"material": "particles_blend",
+				"texture": "textures/particles/moves/watershuriken"
+			}
+		},
+		"curves": {
+			"variable.rsize": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [0, 1, 1, 1, 1, 1, 1, 1]
+			}
+		},
+		"events": {
+			"trail": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_actortrail",
+					"type": "particle"
+				}
+			},
+			"hit": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_target",
+					"type": "particle"
+				}
+			}
+		},
+		"components": {
+			"minecraft:emitter_initialization": {
+				"creation_expression": "v.target_deltaz=5;"
+			},
+			"minecraft:emitter_rate_instant": {
+				"num_particles": 1
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 0.25
+			},
+			"minecraft:emitter_shape_disc": {
+				"offset": [0, 0.02, 0.1],
+				"radius": 0.5,
+				"direction": "outwards"
+			},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": 0.35
+			},
+			"minecraft:particle_lifetime_events": {
+				"timeline": {
+					"0.00": "trail",
+					"0.06": "trail",
+					"0.12": "trail",
+					"0.18": "trail",
+					"0.24": "trail",
+					"0.30": "trail",
+					"0.34": "hit"
+				}
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.random_integer(0,3)*90"
+			},
+			"minecraft:particle_motion_parametric": {
+				"relative_position": ["-v.target_deltax*(v.particle_age / v.particle_lifetime)", "(v.target_deltay*(v.particle_age / v.particle_lifetime))", "-v.target_deltaz*(v.particle_age / v.particle_lifetime)"]
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.4*v.rsize", "0.4*v.rsize"],
+				"facing_camera_mode": "emitter_transform_xz",
+				"uv": {
+					"texture_width": 60,
+					"texture_height": 15,
+					"flipbook": {
+						"base_UV": [0, 0],
+						"size_UV": [15, 15],
+						"step_UV": [15, 0],
+						"frames_per_second": 24,
+						"max_frame": 4,
+						"loop": true
+					}
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_actortrail.particle.json

@@ -0,0 +1,63 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_actortrail",
+			"basic_render_parameters": {
+				"material": "particles_alpha",
+				"texture": "textures/particles/generic/impact/impact_water"
+			}
+		},
+		"curves": {
+			"variable.scale": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [1, 0]
+			}
+		},
+		"components": {
+			"minecraft:emitter_rate_instant": {
+				"num_particles": 1
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 1
+			},
+			"minecraft:emitter_shape_point": {
+				"direction": ["v.particle_random_1-0.5", "v.particle_random_2-0.25", -3]
+			},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": "math.random(0.3, 0.6)"
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.round(v.particle_random_4*3)*90"
+			},
+			"minecraft:particle_initial_speed": 8,
+			"minecraft:particle_motion_dynamic": {
+				"linear_acceleration": [0, -5, 0],
+				"linear_drag_coefficient": 8
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.22 * variable.scale", "0.22 * variable.scale"],
+				"facing_camera_mode": "rotate_xyz",
+				"uv": {
+					"texture_width": 8,
+					"texture_height": 56,
+					"flipbook": {
+						"base_UV": [0, 24],
+						"size_UV": [8, 8],
+						"step_UV": [0, 8],
+						"frames_per_second": 16,
+						"max_frame": 4
+					}
+				}
+			},
+			"minecraft:particle_motion_collision": {
+				"collision_radius": 0.02
+			},
+			"minecraft:particle_appearance_tinting": {
+				"color": [0.61176, 0.87451, 1, 1]
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_actorvert.particle.json

@@ -0,0 +1,86 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_actorvert",
+			"basic_render_parameters": {
+				"material": "particles_blend",
+				"texture": "textures/particles/moves/watershuriken"
+			}
+		},
+		"curves": {
+			"variable.rsize": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [0, 1, 1, 1, 1, 1, 1, 1]
+			}
+		},
+		"events": {
+			"trail": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_actortrail",
+					"type": "particle"
+				}
+			},
+			"hit": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_target",
+					"type": "particle"
+				}
+			}
+		},
+		"components": {
+			"minecraft:emitter_initialization": {
+				"creation_expression": "v.target_deltaz=5;"
+			},
+			"minecraft:emitter_rate_instant": {
+				"num_particles": 1
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 0.25
+			},
+			"minecraft:emitter_shape_disc": {
+				"offset": [0, 0.02, 0.1],
+				"radius": 0.5,
+				"direction": "outwards"
+			},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": 0.35
+			},
+			"minecraft:particle_lifetime_events": {
+				"timeline": {
+					"0.00": "trail",
+					"0.06": "trail",
+					"0.12": "trail",
+					"0.18": "trail",
+					"0.24": "trail",
+					"0.30": "trail",
+					"0.34": "hit"
+				}
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.random_integer(0,3)*90"
+			},
+			"minecraft:particle_motion_parametric": {
+				"relative_position": ["-v.target_deltax*(v.particle_age / v.particle_lifetime)", "(v.target_deltay*(v.particle_age / v.particle_lifetime))", "-v.target_deltaz*(v.particle_age / v.particle_lifetime)"]
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.4*v.rsize", "0.4*v.rsize"],
+				"facing_camera_mode": "emitter_transform_yz",
+				"uv": {
+					"texture_width": 60,
+					"texture_height": 15,
+					"flipbook": {
+						"base_UV": [0, 0],
+						"size_UV": [15, 15],
+						"step_UV": [15, 0],
+						"frames_per_second": 24,
+						"max_frame": 4,
+						"loop": true
+					}
+				}
+			}
+		}
+	}
+}

common/src/main/resources/assets/cobblemon/bedrock/particles/moves/watershuriken/watershuriken_target.particle.json

@@ -0,0 +1,69 @@
+{
+	"format_version": "1.10.0",
+	"particle_effect": {
+		"description": {
+			"identifier": "cobblemon:watershuriken_target",
+			"basic_render_parameters": {
+				"material": "particles_alpha",
+				"texture": "textures/particles/generic/impact/impact_water"
+			}
+		},
+		"curves": {
+			"variable.scale": {
+				"type": "linear",
+				"input": "v.particle_age",
+				"horizontal_range": "v.particle_lifetime",
+				"nodes": [1, 0]
+			}
+		},
+		"events": {
+			"event": {
+				"particle_effect": {
+					"effect": "cobblemon:watershuriken_targetspark",
+					"type": "particle"
+				}
+			}
+		},
+		"components": {
+			"minecraft:emitter_rate_steady": {
+				"spawn_rate": 240,
+				"max_particles": 14
+			},
+			"minecraft:emitter_lifetime_once": {
+				"active_time": 0.1
+			},
+			"minecraft:emitter_lifetime_events": {
+				"creation_event": "event"
+			},
+			"minecraft:emitter_shape_point": {},
+			"minecraft:particle_lifetime_expression": {
+				"max_lifetime": "math.random(0.3, 0.6)"
+			},
+			"minecraft:particle_initial_spin": {
+				"rotation": "math.round(v.particle_random_4*3)*90"
+			},
+			"minecraft:particle_initial_speed": "math.random(9,17)",
+			"minecraft:particle_motion_dynamic": {
+				"linear_drag_coefficient": 5
+			},
+			"minecraft:particle_appearance_billboard": {
+				"size": ["0.3 * variable.scale", "0.3 * variable.scale"],
+				"facing_camera_mode": "rotate_xyz",
+				"uv": {
+					"texture_width": 8,
+					"texture_height": 56,
+					"flipbook": {
+						"base_UV": [0, 16],
+						"size_UV": [8, 8],
+						"step_UV": [0, 8],
+						"frames_per_second": 16,
+						"max_frame": 5
+					}
+				}
+			},
+			"minecraft:particle_appearance_tinting": {
+				"color": [0.61176, 0.87451, 1, 1]
+			}
+		}
+	}
+}