page buttons

CHANGELOG.md

@@ -1,30 +1,55 @@
 # Changelog
-## [1.8.5 (MONTH xth, 2026)](#1-8-5)
+## [1.8.3 (MONTH xth, 2026)](#1-8-3)
 
 ### Additions
-- 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.
-- Added the Copper Oven, Copper Fridge, Copper Washer, Copper Fan, and Copper Mower.
+
+### 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
 
 ### Changes
-- 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
+- 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
 
 ### Fixes
-- Fixed Ponigiri food values for AppleSkin integration
-- Fixed errors emitted by typos in Parched Peat bog structure files
+- 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
 
 ### 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
-- `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
+- 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
 
 ### Localization
 - Updated translations for:

Rotom Notes.txt

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

changelogs/CHANGELOG-1.8.3.md

@@ -1,107 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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,7 +15,6 @@ 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;
@@ -23,14 +22,10 @@ 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;
@@ -38,9 +33,6 @@ import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Optional;
 
 @Mixin(ServerPlayer.class)
 public abstract class ServerPlayerMixin implements PlayerSpawnerAccessor {
@@ -150,17 +142,4 @@ 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(ordinal = 1) Map<RecipeBookCategories, List<RecipeCollection>> map2) {
+    private void addCustomAggregateCategories(Iterable<RecipeHolder<?>> recipes, RegistryAccess registryAccess, CallbackInfo ci, @Local(name = "map2") 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(type = RecipeBookCategories.class))
+    @Definition(id = "recipeBookCategories", local = @Local(name = "recipeBookCategories"))
     @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 RecipeBookCategories recipeBookCategories) {
+    private boolean notCookingPotSearch(boolean original, @Local(name = "recipeBookCategories") RecipeBookCategories recipeBookCategories) {
         return original && recipeBookCategories != CobblemonRecipeCategories.COOKING_POT_SEARCH.toVanillaCategory();
     }
 }

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

@@ -60,6 +60,8 @@ 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
@@ -391,10 +393,13 @@ 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)
@@ -425,10 +430,15 @@ 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.")
@@ -613,6 +623,7 @@ 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,9 +8,6 @@
 
 package com.cobblemon.mod.common
 
-import com.cobblemon.mod.common.block.appliances.CopperFridgeBlockEntity
-import com.cobblemon.mod.common.block.appliances.CopperMowerBlockEntity
-import com.cobblemon.mod.common.block.appliances.CopperWasherBlockEntity
 import com.cobblemon.mod.common.block.entity.*
 import com.cobblemon.mod.common.block.habitat.HabitatBlockEntity
 import com.cobblemon.mod.common.block.multiblock.FossilMultiblockBuilder
@@ -129,49 +126,4 @@ 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)
-    )
-
-    @JvmField
-    val COPPER_WASHER: BlockEntityType<CopperWasherBlockEntity> = this.create(
-        "copper_washer",
-        BlockEntityType.Builder.of(::CopperWasherBlockEntity,
-            CobblemonBlocks.COPPER_WASHER,
-            CobblemonBlocks.EXPOSED_COPPER_WASHER,
-            CobblemonBlocks.WEATHERED_COPPER_WASHER,
-            CobblemonBlocks.OXIDIZED_COPPER_WASHER,
-            CobblemonBlocks.WAXED_COPPER_WASHER,
-            CobblemonBlocks.WAXED_EXPOSED_COPPER_WASHER,
-            CobblemonBlocks.WAXED_WEATHERED_COPPER_WASHER,
-            CobblemonBlocks.WAXED_OXIDIZED_COPPER_WASHER
-        ).build(null)
-    )
-
-    @JvmField
-    val COPPER_MOWER: BlockEntityType<CopperMowerBlockEntity> = this.create(
-        "copper_mower",
-        BlockEntityType.Builder.of(::CopperMowerBlockEntity,
-            CobblemonBlocks.COPPER_MOWER,
-            CobblemonBlocks.EXPOSED_COPPER_MOWER,
-            CobblemonBlocks.WEATHERED_COPPER_MOWER,
-            CobblemonBlocks.OXIDIZED_COPPER_MOWER,
-            CobblemonBlocks.WAXED_COPPER_MOWER,
-            CobblemonBlocks.WAXED_EXPOSED_COPPER_MOWER,
-            CobblemonBlocks.WAXED_WEATHERED_COPPER_MOWER,
-            CobblemonBlocks.WAXED_OXIDIZED_COPPER_MOWER
-        ).build(null)
-    )
 }

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

@@ -12,7 +12,6 @@ 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
@@ -29,7 +28,12 @@ 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.*
+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.platform.PlatformRegistry
 import com.cobblemon.mod.common.util.cobblemonResource
 import net.minecraft.core.BlockPos
@@ -788,9 +792,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val RESTORATION_TANK = create("restoration_tank", RestorationTankBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.GLASS).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).noOcclusion()))
 
-    @JvmField
-    val ROTOM_MONITOR = create("rotom_data_monitor", RotomMonitorBlock(BlockBehaviour.Properties.ofFullCopy(MONITOR)))
-
     @JvmField
     val HEALING_MACHINE = create("healing_machine", HealingMachineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if (it.getValue(HealingMachineBlock.CHARGE_LEVEL) >= HealingMachineBlock.MAX_CHARGE_LEVEL) 12 else 5 }))
 
@@ -820,94 +821,6 @@ 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(
-        CobblemonSounds.APPLIANCE_BLOCK_SOUNDS).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(CobblemonSounds.APPLIANCE_BLOCK_SOUNDS).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(CobblemonSounds.APPLIANCE_BLOCK_SOUNDS).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(CobblemonSounds.APPLIANCE_BLOCK_SOUNDS).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(CobblemonSounds.APPLIANCE_BLOCK_SOUNDS).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)))
@@ -936,6 +849,7 @@ 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
@@ -1013,57 +927,6 @@ 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,6 +73,7 @@ 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

@@ -454,8 +454,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val DAMAGED_MONITOR = blockItem("damaged_monitor", CobblemonBlocks.DAMAGED_MONITOR)
     @JvmField
-    val ROTOM_MONITOR = blockItem("rotom_data_monitor", CobblemonBlocks.ROTOM_MONITOR)
-    @JvmField
     val HEALING_MACHINE = blockItem("healing_machine", CobblemonBlocks.HEALING_MACHINE, Rarity.UNCOMMON)
     @JvmField
     val PC = blockItem("pc", CobblemonBlocks.PC)
@@ -1519,87 +1517,6 @@ 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,6 +432,7 @@ 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/CobblemonRecipeSerializers.kt

@@ -12,7 +12,6 @@ package com.cobblemon.mod.common
 import com.cobblemon.mod.common.item.crafting.CookingPotRecipe
 import com.cobblemon.mod.common.item.crafting.CookingPotShapelessRecipe
 import com.cobblemon.mod.common.item.crafting.brewingstand.BrewingStandRecipe
-import com.cobblemon.mod.common.item.crafting.washer.WasherRecipe
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
 import net.minecraft.core.registries.BuiltInRegistries
@@ -27,9 +26,7 @@ object CobblemonRecipeSerializers : PlatformRegistry<Registry<RecipeSerializer<*
     val COOKING_POT_SHAPELESS: RecipeSerializer<*> = register("cobblemon:cooking_pot_shapeless", CookingPotShapelessRecipe.Serializer())
 
     val BREWING_STAND: RecipeSerializer<*> = register("cobblemon:brewing_stand", BrewingStandRecipe.Serializer())
-
-    val WASHER: RecipeSerializer<*> = register("cobblemon:washer", WasherRecipe.Serializer())
-
+    
     override val registry: Registry<RecipeSerializer<*>>
         get() = BuiltInRegistries.RECIPE_SERIALIZER
     override val resourceKey: ResourceKey<Registry<RecipeSerializer<*>>>

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

@@ -12,7 +12,6 @@ package com.cobblemon.mod.common
 import com.cobblemon.mod.common.item.crafting.CookingPotRecipe
 import com.cobblemon.mod.common.item.crafting.CookingPotShapelessRecipe
 import com.cobblemon.mod.common.item.crafting.brewingstand.BrewingStandRecipe
-import com.cobblemon.mod.common.item.crafting.washer.WasherRecipe
 import com.cobblemon.mod.common.platform.PlatformRegistry
 import net.minecraft.core.Registry
 import net.minecraft.core.registries.BuiltInRegistries
@@ -27,9 +26,7 @@ object CobblemonRecipeTypes : PlatformRegistry<Registry<RecipeType<*>>, Resource
     val COOKING_POT_SHAPELESS: RecipeType<CookingPotShapelessRecipe> = register("cobblemon:cooking_pot_shapeless")
 
     val BREWING_STAND: RecipeType<BrewingStandRecipe> = register("cobblemon:brewing_stand")
-
-    val WASHER: RecipeType<WasherRecipe> = register("cobblemon:washer")
-
+    
     override val registry: Registry<RecipeType<*>>
         get() = BuiltInRegistries.RECIPE_TYPE
     override val resourceKey: ResourceKey<Registry<RecipeType<*>>>

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

@@ -404,25 +404,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val IMPACT_WATER = this.create("impact.water")
 
-    @JvmField
-    val APPLIANCE_STEP = this.create("block.appliance.roto_appliance_step")
-    @JvmField
-    val APPLIANCE_PLACE = this.create("block.appliance.roto_appliance_place")
-    @JvmField
-    val APPLIANCE_HIT = this.create("block.appliance.roto_appliance_hit")
-    @JvmField
-    val APPLIANCE_BREAK = this.create("block.appliance.roto_appliance_break")
-    @JvmField
-    val MOWER_CUT = this.create("block.appliance.roto_mower_cut")
-    @JvmField
-    val WASHER_WASH = this.create("block.appliance.roto_washer_wash")
-    @JvmField
-    val FAN_BLOW = this.create("block.appliance.roto_fan_blow")
-    @JvmField
-    val FAN_START = this.create("block.appliance.roto_fan_start")
-    @JvmField
-    val FAN_STOP = this.create("block.appliance.roto_fan_stop")
-
     // Note to self or whoever's peeking, block sounds have to be at 1.1f pitch
     // For some reason, the game pitches them down and compensating for it here returns them to normal
     @JvmField
@@ -443,15 +424,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         TUMBLESTONE_STEP
     )
 
-    @JvmField
-    val APPLIANCE_BLOCK_SOUNDS = SoundType(1f, 1.1f,
-        APPLIANCE_BREAK,
-        APPLIANCE_STEP,
-        APPLIANCE_PLACE,
-        APPLIANCE_HIT,
-        APPLIANCE_STEP
-        )
-
     @JvmField
     val TYPE_GEM_BLOCK_BREAK = this.create("block.type_gem_block.break")
     @JvmField

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

@@ -9,7 +9,6 @@
 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
@@ -18,7 +17,6 @@ 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
@@ -36,8 +34,6 @@ 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(
@@ -47,44 +43,24 @@ class HateEntityTaskConfig : SingleTaskConfig {
         val range = range.resolveFloat(behaviourConfigurationContext.runtime)
         behaviourConfigurationContext.addMemories(
             MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES,
-            MemoryModuleType.ANGRY_AT,
-            MemoryModuleType.ATTACK_TARGET
+            MemoryModuleType.ANGRY_AT
         )
         behaviourConfigurationContext.addSensors(SensorType.NEAREST_LIVING_ENTITIES)
         return BehaviorBuilder.create { instance ->
             instance.group(
                 instance.present(MemoryModuleType.NEAREST_VISIBLE_LIVING_ENTITIES),
-                instance.registered(MemoryModuleType.ANGRY_AT),
-                instance.registered(MemoryModuleType.ATTACK_TARGET),
-            ).apply(instance) { entities, angryAt, attackTarget ->
+                instance.registered(MemoryModuleType.ANGRY_AT)
+            ).apply(instance) { entities, angryAt ->
                 Trigger { world, entity, _ ->
-                    // 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())
+                    val target = instance.get(entities).findClosest {
+                        mainThreadRuntime.withQueryValue("entity", entity.asMostSpecificMoLangValue())
                         return@findClosest mainThreadRuntime.resolveBoolean(entityCondition)
                     }.orElse(null)
 
-                    var shouldTrigger = false
                     if (target != null && target.distanceTo(entity) <= range) {
-                        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
-                        }
+                        angryAt.set(target.uuid)
                     }
-                    return@Trigger shouldTrigger
+                    return@Trigger true
                 }
             }
         }

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

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

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

@@ -0,0 +1,64 @@
+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,10 +239,6 @@ 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,6 +145,8 @@ 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.plainCopy().green()) }
+            ?.let { lang("ui.pokedex.evolution.trade.tooltip.with_species", it.translatedName.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().plainCopy().green()
+    val moonPhaseComponent = moonPhaseRequirement.moonPhase.displayName().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.plainCopy().green())
+    val tooltip = lang("ui.pokedex.requirement.has_move.tooltip", moveSetRequirement.move.displayName.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.plainCopy().green())
+    val tooltip = lang("ui.pokedex.requirement.has_move_type.tooltip", moveTypeRequirement.type.displayName.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()?.plainCopy() ?: return null
+    val timeRangeComponent = timeRangeRequirement.range.displayName() ?: 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.plainCopy().green())
+    val tooltip = lang("ui.pokedex.requirement.use_move.tooltip", useMoveRequirement.move.displayName.green())
 
     return CobblemonDexEvolutionRequirementDisplay(icon, tooltip)
 }

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

@@ -9,12 +9,9 @@
 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].
@@ -23,14 +20,13 @@ import net.minecraft.world.item.Item
  * @since February 17th, 2025
  */
 enum class RidingStat(
-    val flavour: Flavour,
-    val powerItem: TagKey<Item>
+    val flavour: Flavour
 ) {
-    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);
+    ACCELERATION(Flavour.SPICY),
+    SKILL(Flavour.DRY),
+    SPEED(Flavour.SWEET),
+    STAMINA(Flavour.SOUR),
+    JUMP(Flavour.BITTER);
 
     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) {
-            minHeight = merger.mergeSingle(minHeight, other.minHeight)
-            maxHeight = merger.mergeSingle(maxHeight, other.maxHeight)
+            merger.mergeSingle(minHeight, other.minHeight)
+            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(maxDepth, other.maxDepth)
+            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
             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(maxDepth, other.maxDepth)
+            maxDepth = merger.mergeSingle(minDepth, other.minDepth)
             fluid = merger.mergeSingle(fluid, other.fluid)
         }
     }

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

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

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

@@ -29,8 +29,12 @@ 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")
@@ -68,7 +72,9 @@ 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,6 +10,7 @@ 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
@@ -76,6 +77,14 @@ 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 {
@@ -148,4 +157,9 @@ 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,6 +9,7 @@
 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
@@ -35,6 +36,12 @@ 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

@@ -0,0 +1,38 @@
+/*
+ * 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

@@ -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.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: () -> T = {
+        val loadFallback: (Boolean) -> T = { primaryFileCorrupt ->
             playerFile.delete()
             if (playerFileOld.exists() && playerFileOld.length() > 0L) {
                 try {
@@ -68,7 +68,9 @@ abstract class FileBasedPlayerDataStoreBackend<T : InstancedPlayerData>(
                 }
             }
             else {
-                Cobblemon.LOGGER.error(".old File $subfolder for $uuid is corrupt or missing. Data is lost")
+                if (primaryFileCorrupt) {
+                    Cobblemon.LOGGER.error(".old File $subfolder for $uuid is corrupt or missing. Data is lost")
+                }
                 playerFileOld.delete()
                 defaultData.invoke(uuid).also(::save)
             }
@@ -80,10 +82,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()
+                loadFallback(true)
             }
         } else {
-            loadFallback()
+            loadFallback(false)
         }.also { it.initialize() }
     }
 

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

@@ -0,0 +1,42 @@
+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,9 +117,6 @@ 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
         }
@@ -171,10 +168,6 @@ 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) {
@@ -190,8 +183,7 @@ data class HealItemActionResponse(var item: String) : ShowdownActionResponse(Sho
     }
 
     override fun isValid(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?, forceSwitch: Boolean): Boolean {
-        // Previously checked for !forceSwitch, excepts in the case of a forceSwitch, this couldn't legally be sent anyway.
-        return false
+        return !forceSwitch
     }
 
     override fun toShowdownString(activeBattlePokemon: ActiveBattlePokemon, showdownMoveSet: ShowdownMoveset?): String {

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

@@ -37,6 +37,7 @@ 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
@@ -76,7 +77,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) {
@@ -136,20 +137,10 @@ 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,7 +24,6 @@ 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
@@ -32,9 +31,13 @@ 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.*
+import net.minecraft.world.level.block.BaseEntityBlock
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.HorizontalDirectionalBlock
+import net.minecraft.world.level.block.Mirror
+import net.minecraft.world.level.block.RenderShape
+import net.minecraft.world.level.block.Rotation
 import net.minecraft.world.level.block.entity.BlockEntity
 import net.minecraft.world.level.block.entity.BlockEntityTicker
 import net.minecraft.world.level.block.entity.BlockEntityType
@@ -45,11 +48,9 @@ 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) {
@@ -78,14 +79,6 @@ 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 {
@@ -165,12 +158,7 @@ class HealingMachineBlock(settings: Properties) : BaseEntityBlock(settings) {
         }
         val party = serverPlayerEntity.party()
         val pc = serverPlayerEntity.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)
-        }
+        val healPC = player.level().gameRules.getBoolean(CobblemonGameRules.HEALERS_HEAL_PC);
 
         if (party.none() && (!healPC || pc.none())) {
             player.sendSystemMessage(lang("healingmachine.nopokemon").red(), true)
@@ -195,7 +183,6 @@ 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/MonitorBlock.kt

@@ -35,7 +35,6 @@ 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.HORIZONTAL_FACING
-import net.minecraft.world.level.block.state.properties.BooleanProperty
 import net.minecraft.world.level.block.state.properties.EnumProperty
 import net.minecraft.world.level.pathfinder.PathComputationType
 import net.minecraft.world.phys.BlockHitResult
@@ -47,10 +46,7 @@ class MonitorBlock(settings: Properties) : MultiblockBlock(settings) {
     init {
         registerDefaultState(stateDefinition.any()
             .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(SCREEN, MonitorScreen.OFF)
-            .setValue(NATURAL, false)
-        )
-
+            .setValue(SCREEN, MonitorScreen.OFF))
     }
 
     override fun createMultiBlockEntity(
@@ -114,7 +110,6 @@ class MonitorBlock(settings: Properties) : MultiblockBlock(settings) {
     override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
         builder.add(HORIZONTAL_FACING)
         builder.add(SCREEN)
-        builder.add(NATURAL)
     }
 
     override fun hasAnalogOutputSignal(state: BlockState): Boolean {
@@ -168,7 +163,6 @@ class MonitorBlock(settings: Properties) : MultiblockBlock(settings) {
 
         //0 is off
         val SCREEN = EnumProperty.create("screen", MonitorScreen::class.java)
-        val NATURAL = BooleanProperty.create("natural")
         val HITBOX_SOUTH = Shapes.or(
             Shapes.box(0.0625, 0.0, 0.0625, 0.9375, 0.375, 0.9375),
             Shapes.box(0.0625, 0.875, 0.0625, 0.9375, 1.0, 0.9375),

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.3125, 0.6875, 1.0, 0.6875)
+        val CEILING_NORTH = Shapes.box(0.3125, 0.625, 0.375, 0.6875, 1.0, 0.6875)
     }
 
     init {

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

@@ -1,161 +0,0 @@
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.Cobblemon
-import com.cobblemon.mod.common.api.pokemon.PokemonProperties
-import com.cobblemon.mod.common.api.scheduling.afterOnServer
-import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
-import com.cobblemon.mod.common.util.math.FloatRange
-import com.cobblemon.mod.common.util.party
-import com.cobblemon.mod.common.util.toVec3d
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.sounds.SoundEvent
-import net.minecraft.sounds.SoundSource
-import net.minecraft.util.RandomSource
-import net.minecraft.world.InteractionResult
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.phys.Vec3
-
-/**
- * A block that can transform into a [PokemonEntity].
- * Call [spawnPokemon] to spawn.
- *
- * @author whatsy
- */
-interface PokemonDisguiseBlock {
-
-    private val facingToYaw: HashMap<Direction, Float>
-        get() = hashMapOf(
-            Direction.NORTH to -179.0F,
-            Direction.WEST to 90.0F,
-            Direction.SOUTH to 0.0F,
-            Direction.EAST to -90.0F
-        )
-
-    /**
-     * An [IntRange] representing the possible level of the spawned Pokémon.
-     */
-    val levelRange: IntRange
-
-    /**
-     * A [String] representing the [PokemonProperties] of the spawned Pokémon.
-     * Do not include level, scale, shiny, or alpha;
-     * Those are defined using [levelRange], [scaleRange], [shinyRate] and [alphaRate] respectively.
-     */
-    val pokemonArgs: String
-
-    /**
-     * The chance of the spawned Pokémon being a shiny.
-     * Leave null if impossible.
-     * Defaults to [Cobblemon.config.shinyRate]
-     */
-    val shinyRate: Float?
-        get() = Cobblemon.config.shinyRate
-
-    /**
-     * The chance of the spawned Pokémon being an Alpha.
-     * Leave null if impossible.
-     * Defaults to null
-     */
-    val alphaRate: Float?
-        get() = null
-
-    /**
-     * The [BlockState] to replace the block with on interaction.
-     * Defaults to [Blocks.AIR]
-     * Leave null to leave the block unaltered.
-     *
-     * @param originalState The [BlockState] of the block being interacted with. Use to transfer properties to a new block.
-     */
-    fun getReplacementBlock(originalState: BlockState): BlockState? = Blocks.AIR.defaultBlockState()
-
-    /**
-     * Whether or not a battle should be initiated when the Pokémon spawns.
-     * Defaults to true.
-     * Does not affect players in creative mode.
-     */
-    val shouldInitiateBattle: Boolean
-        get() = true
-
-    /**
-     * The [SoundEvent], if any, to play when the Pokémon spawns.
-     * Defaults to null.
-     */
-    val spawnSound: SoundEvent?
-        get() = null
-
-    /**
-     * A [FloatRange] representing the possible scale of the spawned Pokémon.
-     * Defaults to config values.
-     */
-    val scaleRange: FloatRange
-        get() = FloatRange(Cobblemon.config.pokemonIntrinsicSizeMin, Cobblemon.config.pokemonIntrinsicSizeMax)
-
-    /**
-     * Defines a [Vec3] offset for where the Pokémon will spawn.
-     * Defaults to 0, 0, 0
-     */
-    val offset: Vec3
-        get() = Vec3(0.0, 0.0, 0.0)
-
-    /**
-     * Returns the direction the Pokémon should be facing upon spawning.
-     * Defaults to the
-     */
-    fun getPokemonFacing(state: BlockState): Direction
-
-    /**
-     * Spawn a Pokémon from this block.
-     *
-     * @param level The [Level] to spawn this Pokémon in.
-     * @param pos The [BlockPos] to spawn this Pokémon at.
-     * @param state The [BlockState] of the block at time of spawning.
-     * @param player The [ServerPlayer] to initiate the battle against.
-     */
-    fun spawnPokemon(level: Level, pos: BlockPos, state: BlockState, player: ServerPlayer): InteractionResult {
-        val random = RandomSource.create()
-        val isShiny = shinyRate?.let { random.nextInt(it.toInt()) == 0 } ?: false
-        val isAlpha = alphaRate?.let { random.nextInt(it.toInt()) == 0 } ?: false
-        val properties = "$pokemonArgs lvl=${levelRange.random()} scale_modifier=${scaleRange.random()} alpha=${isAlpha} shiny=${isShiny}"
-        val pokemon = PokemonProperties.parse(properties)
-        val entity = pokemon.createEntity(level)
-
-        // The yaw based on the block's facing direction
-        val yaw = facingToYaw[getPokemonFacing(state)] ?: 0.0F
-
-        entity.entityData.set(PokemonEntity.SPAWN_DIRECTION, yaw)
-        val offsetDir = state.getValue(HorizontalDirectionalBlock.FACING)
-        val vec = pos.toVec3d()
-            .add(offsetDir.stepX * 0.1 + 0.5, 0.0, offsetDir.stepZ * 0.1 + 0.5)
-            .add(offset)
-        entity.moveTo(vec.x, vec.y, vec.z, yaw, entity.xRot)
-        entity.yBodyRot = yaw
-        entity.yBodyRotO = yaw
-        entity.yHeadRot = yaw
-        entity.yHeadRotO = yaw
-        level.addFreshEntity(entity)
-
-        if (getReplacementBlock(state) == Blocks.AIR) {
-            level.removeBlock(pos, false)
-        } else {
-            getReplacementBlock(state)?.let {
-                level.setBlockAndUpdate(pos, it)
-            }
-        }
-        afterOnServer(seconds = 0.1F) {
-            if (player !in player.level().players()) {
-                return@afterOnServer
-            }
-            if (!player.isCreative && shouldInitiateBattle) {
-                entity.forceBattle(player)
-            } else {
-                spawnSound?.let { level.playSound(null, pos, it, SoundSource.NEUTRAL) }
-            }
-        }
-        return InteractionResult.SUCCESS
-    }
-}

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

@@ -1,91 +0,0 @@
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.CobblemonBlocks
-import com.cobblemon.mod.common.CobblemonSounds
-import com.cobblemon.mod.common.block.DamagedMonitorBlock.BrokenMonitorScreen
-import com.cobblemon.mod.common.block.DamagedMonitorBlock.Companion.HITBOX_EAST
-import com.cobblemon.mod.common.block.DamagedMonitorBlock.Companion.HITBOX_NORTH
-import com.cobblemon.mod.common.block.DamagedMonitorBlock.Companion.HITBOX_SOUTH
-import com.cobblemon.mod.common.block.DamagedMonitorBlock.Companion.HITBOX_WEST
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerPlayer
-import net.minecraft.world.InteractionResult
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.state.BlockBehaviour
-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.phys.BlockHitResult
-import net.minecraft.world.phys.Vec3
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class RotomMonitorBlock(settings: Properties) : Block(settings), PokemonDisguiseBlock {
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HorizontalDirectionalBlock.FACING, Direction.NORTH)
-            .setValue(MonitorBlock.SCREEN, MonitorBlock.MonitorScreen.OFF)
-        )
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        return defaultBlockState().setValue(HorizontalDirectionalBlock.FACING, context.horizontalDirection)
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block?, BlockState?>) {
-        builder.add(HorizontalDirectionalBlock.FACING)
-        builder.add(MonitorBlock.SCREEN)
-    }
-
-    override fun playerWillDestroy(level: Level, pos: BlockPos, state: BlockState, player: Player): BlockState? {
-        if (!level.isClientSide) {
-            spawnPokemon(level, pos, state, player as ServerPlayer)
-        }
-        return super.playerWillDestroy(level, pos, state, player)
-    }
-
-    override fun getShape(
-        state: BlockState,
-        level: BlockGetter,
-        pos: BlockPos,
-        context: CollisionContext
-    ): VoxelShape {
-        return when (state.getValue(HorizontalDirectionalBlock.FACING)) {
-            Direction.WEST -> HITBOX_WEST
-            Direction.EAST -> HITBOX_EAST
-            Direction.SOUTH -> HITBOX_SOUTH
-            else -> HITBOX_NORTH
-        }
-    }
-
-    override fun useWithoutItem(
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        player: Player,
-        hitResult: BlockHitResult
-    ): InteractionResult {
-        return if (player is ServerPlayer) {
-            spawnPokemon(level, pos, state, player)
-        } else {
-            InteractionResult.SUCCESS
-        }
-    }
-
-    override val levelRange = 35..60
-    override val pokemonArgs = "rotom"
-    override val spawnSound = CobblemonSounds.MONITOR_BREAK
-    override val offset = Vec3(0.0, 1.0, 0.0)
-    override fun getReplacementBlock(originalState: BlockState): BlockState =
-        CobblemonBlocks.MONITOR.defaultBlockState()
-            .setValue(HorizontalDirectionalBlock.FACING, originalState.getValue(HorizontalDirectionalBlock.FACING))
-            .setValue(MonitorBlock.NATURAL, true)
-    override fun getPokemonFacing(state: BlockState): Direction = state.getValue(HORIZONTAL_FACING).opposite
-}

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 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
+        val supportBlock = level.getBlockState(supportPos).block
+        return CobblemonBlocks.typeGemBlocks().containsValue(supportBlock) || (supportBlock == CobblemonBlocks.TYPE_GEM_CORE) // Cannot grow if not on any gem blocks
     }
 
 

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

@@ -51,20 +51,10 @@ 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("minecraft:amethyst_block") to Blocks.SMALL_AMETHYST_BUD
+                ResourceLocation.parse("cobblemon:fairy_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_FAIRY
             )
         }
 
-        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>()
@@ -95,16 +85,12 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
             Direction.entries.forEach {
                 if (random.nextFloat() < Cobblemon.config.typeGemGrowthChance) {
                     val faceState = level.getBlockState(pos.relative(it))
-                    var newState = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(state.block)]?.defaultBlockState()
+                    val randomGrowthType = decideClusterGrowthType(level, pos)
+                    val 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)
                     }
@@ -146,7 +132,7 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
                 if (!visited.add(clusterPos)) continue
 
                 val clusterState = level.getBlockState(clusterPos)
-                if (clusterState.block == expectedCluster && clusterState.hasProperty(GROWTH_TYPE)) {
+                if (clusterState.block == expectedCluster) {
                     clusters += clusterState to clusterPos
                 }
             }
@@ -192,41 +178,13 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
         Direction.entries.forEach { direction ->
             val relativePos = pos.relative(direction)
             val relativeState = level.getBlockState(relativePos)
-            val matchesFace = relativeState.hasProperty(DirectionalBlock.FACING)
-                    && relativeState.getValue(DirectionalBlock.FACING) == direction
-            if (!(forceGrow || (matchesFace && random.nextFloat() < Cobblemon.config.typeGemGrowthChance))) {
-                return@forEach
+            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 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

@@ -1,179 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.appliances
-
-import com.cobblemon.mod.common.CobblemonSounds
-import com.cobblemon.mod.common.client.sound.BlockEntitySoundTracker
-import com.cobblemon.mod.common.client.sound.instances.CancellableSoundInstance
-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.sounds.SoundEvents
-import net.minecraft.sounds.SoundSource
-import net.minecraft.util.RandomSource
-import net.minecraft.world.InteractionResult
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.block.*
-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.entity.EntityTypeTest
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.AABB
-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: 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 useWithoutItem(
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        player: Player,
-        hitResult: BlockHitResult
-    ): InteractionResult {
-        if (!level.isClientSide) {
-            level.setBlockAndUpdate(pos, state.setValue(PUSH, !state.getValue(PUSH)))
-            if (state.getValue(PUSH)) {
-                level.playSound(null, pos, CobblemonSounds.FAN_START, SoundSource.BLOCKS)
-            } else {
-                level.playSound(null, pos, CobblemonSounds.FAN_STOP, SoundSource.BLOCKS)
-            }
-        }
-        return InteractionResult.SUCCESS
-    }
-
-    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 neighborChanged(
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        neighborBlock: Block,
-        neighborPos: BlockPos,
-        movedByPiston: Boolean
-    ) {
-        val power = level.getBestNeighborSignal(pos)
-        if (power != state.getValue(POWER)) {
-            level.setBlock(pos, state.setValue(POWER, power), UPDATE_CLIENTS)
-            if (power > 0) {
-                level.scheduleTick(pos, this, 1)
-            }
-        }
-    }
-
-    override fun tick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        val facing = state.getValue(HORIZONTAL_FACING)
-        val power = state.getValue(POWER)
-
-        if (power == 0) {
-            if (BlockEntitySoundTracker.isActive(pos, CobblemonSounds.FAN_BLOW.location)) {
-                BlockEntitySoundTracker.stop(pos, CobblemonSounds.FAN_BLOW.location)
-            }
-            return
-        }
-
-        val sound = CancellableSoundInstance(
-            sound = CobblemonSounds.FAN_BLOW,
-            pos = pos,
-            repeat = true
-        )
-
-        if (!BlockEntitySoundTracker.isActive(pos, CobblemonSounds.FAN_BLOW.location)) {
-                BlockEntitySoundTracker.play(pos, sound)
-        }
-
-        if (state.getValue(PUSH)) {
-            val area = AABB(pos.relative(facing)).expandTowards(
-                facing.stepX.toDouble() * (power - 1),
-                0.0,
-                facing.stepZ.toDouble() * (power - 1)
-            )
-            val entities = level.getEntities(null, area)
-            val pushForce = 0.05
-            entities.forEach { entity ->
-                val motion = entity.deltaMovement
-                entity.setDeltaMovement(
-                    motion.x + facing.stepX * pushForce,
-                    motion.y,
-                    motion.z + facing.stepZ * pushForce
-                )
-                entity.hurtMarked = true
-            }
-        }
-
-        level.scheduleTick(pos, this, 1)
-    }
-
-    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

@@ -1,283 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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.sounds.SoundEvents
-import net.minecraft.sounds.SoundSource
-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.block is CopperFridgeBlock
-        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 hasAnalogOutputSignal(state: BlockState) = true
-
-    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
-                        level.playSound(null, pos, SoundEvents.BUCKET_EMPTY, SoundSource.BLOCKS, 1.0f, 1.0f)
-                        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
-                        level.playSound(null, pos, SoundEvents.BUCKET_FILL, SoundSource.BLOCKS, 1.0f, 1.0f)
-                        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
-                }
-            }
-        } else {
-            return if (stack.`is`(Items.WATER_BUCKET)) ItemInteractionResult.SUCCESS
-            else ItemInteractionResult.PASS_TO_DEFAULT_BLOCK_INTERACTION
-        }
-        return ItemInteractionResult.SUCCESS // should not be reachable, but intellij doesnt like that its not there
-    }
-
-    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
-        if (level.isClientSide) return 0
-        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

@@ -1,81 +0,0 @@
-package com.cobblemon.mod.common.block.appliances
-
-import com.cobblemon.mod.common.CobblemonBlockEntities
-import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
-import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
-import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerLevel
-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.phys.Vec3
-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
-    private var spawnedReadyParticle = false
-    var timer: Int = -1
-
-    fun processTick() {
-        val serverLevel = level as? ServerLevel ?: return
-
-        if (item.`is`(Items.ICE) && !spawnedReadyParticle) {
-            val facing = state.getValue(CopperFridgeBlock.FACING)
-            val particlePosition = Vec3(
-                pos.x + 0.5,
-                pos.y + 1.5,
-                pos.z + 0.5
-            )
-            val rotation = when (facing) {
-                Direction.NORTH -> 180F
-                Direction.EAST -> 90F
-                Direction.SOUTH -> 0F
-                Direction.WEST -> 270F
-                else -> 0F
-            }
-            val packet = SpawnSnowstormParticlePacket(cobblemonResource("rotomfridge_doorready"), particlePosition, rotation)
-
-            serverLevel.players()
-                .filter { it.distanceToSqr(particlePosition.x, particlePosition.y, particlePosition.z) <= 32.0 * 32.0 }
-                .forEach { it.sendPacket(packet) }
-            spawnedReadyParticle = true
-        } else if (!item.`is`(Items.ICE)) {
-            spawnedReadyParticle = false
-        }
-
-        if (!serverLevel.getBlockState(pos).getValue(CopperFridgeBlock.POWERED)) return
-        if (timer > 0) timer--
-        if (timer == 0 && item.item == Items.WATER_BUCKET) {
-            theItem = Items.ICE.defaultInstance
-            timer = -1
-        }
-    }
-
-    override fun getContainerBlockEntity() = this
-    override fun getTheItem() = item
-
-    override fun setTheItem(item: ItemStack) {
-        this.item = item
-        level?.updateNeighborsAt(pos, state.block)
-    }
-
-    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

@@ -1,168 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.appliances
-
-import com.cobblemon.mod.common.CobblemonSounds
-import com.cobblemon.mod.common.util.cobblemonResource
-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.core.registries.BuiltInRegistries
-import net.minecraft.core.registries.Registries
-import net.minecraft.resources.ResourceKey
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.sounds.SoundSource
-import net.minecraft.util.RandomSource
-import net.minecraft.world.entity.item.ItemEntity
-import net.minecraft.world.item.BlockItem
-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.block.*
-import net.minecraft.world.level.block.entity.BlockEntity
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.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.level.storage.loot.LootParams
-import net.minecraft.world.level.storage.loot.LootTable
-import net.minecraft.world.level.storage.loot.parameters.LootContextParam
-import net.minecraft.world.level.storage.loot.parameters.LootContextParamSets
-import net.minecraft.world.level.storage.loot.parameters.LootContextParams
-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: 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 neighborChanged(
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        sourceBlock: Block,
-        sourcePos: BlockPos,
-        notify: Boolean
-    ) {
-        val powered = level.hasNeighborSignal(pos) || level.hasNeighborSignal(pos.above())
-        val triggered = state.getValue(TRIGGERED)
-
-        if (powered && !triggered) {
-            level.setBlock(pos, state.setValue(TRIGGERED, true), UPDATE_CLIENTS)
-            level.scheduleTick(pos, this, 1)
-        } else if (!powered && triggered) {
-            level.setBlock(pos, state.setValue(TRIGGERED, false), UPDATE_CLIENTS)
-        }
-    }
-
-    override fun hasAnalogOutputSignal(state: BlockState) = true
-
-    override fun tick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        val blockKey = BuiltInRegistries.BLOCK.getKey(level.getBlockState(pos.below()).block)
-        val tableKey = ResourceKey.create(Registries.LOOT_TABLE, cobblemonResource("mower/${blockKey.path}"))
-        val lootTable = level.server.reloadableRegistries().getLootTable(tableKey)
-        if (lootTable == LootTable.EMPTY) return
-        val params = LootParams.Builder(level)
-            .withParameter(LootContextParams.ORIGIN, Vec3.atCenterOf(pos.below()))
-            .withParameter(LootContextParams.BLOCK_STATE, level.getBlockState(pos.below()))
-            .withParameter(LootContextParams.TOOL, ItemStack.EMPTY)
-            .create(LootContextParamSets.BLOCK)
-
-        val result = lootTable.getRandomItems(params, random)
-        val block = result.getOrNull(0)?.item as? BlockItem
-        val item = result.getOrNull(1)
-
-        if (block == null || block == Blocks.AIR) {
-            level.destroyBlock(pos.below(), false)
-        } else {
-            level.setBlockAndUpdate(pos.below(), block.block.defaultBlockState())
-        }
-        item?.let {
-            val facing = state.getValue(HORIZONTAL_FACING).opposite
-            val itemEntity =
-                ItemEntity(level,
-                    pos.x + 0.5, pos.y + 0.5, pos.z + 0.5,
-                    it
-                )
-            itemEntity.deltaMovement = Vec3(facing.stepX.toDouble(), 0.0, facing.stepZ.toDouble()).scale(0.2)
-            level.addFreshEntity(itemEntity)
-        }
-        level.playSound(null, pos, CobblemonSounds.MOWER_CUT, SoundSource.BLOCKS)
-    }
-
-    override fun getRenderShape(state: BlockState) = RenderShape.MODEL
-
-    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/CopperMowerBlockEntity.kt

@@ -1,12 +0,0 @@
-package com.cobblemon.mod.common.block.appliances
-
-import com.cobblemon.mod.common.CobblemonBlockEntities
-import net.minecraft.core.BlockPos
-import net.minecraft.world.level.block.entity.BlockEntity
-import net.minecraft.world.level.block.state.BlockState
-
-class CopperMowerBlockEntity(val pos: BlockPos, val state: BlockState) : BlockEntity(
-    CobblemonBlockEntities.COPPER_MOWER,
-    pos, state
-) {
-}

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

@@ -1,88 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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

@@ -1,133 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.appliances
-
-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.sounds.SoundEvents
-import net.minecraft.sounds.SoundSource
-import net.minecraft.world.InteractionHand
-import net.minecraft.world.ItemInteractionResult
-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.block.*
-import net.minecraft.world.level.block.entity.BlockEntity
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.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.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
-
-open class CopperWasherBlock(settings: Properties) : BaseEntityBlock(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)
-    }
-
-    override fun newBlockEntity(pos: BlockPos, state: BlockState) = CopperWasherBlockEntity(pos, state)
-
-    override fun getRenderShape(state: BlockState) = RenderShape.MODEL
-
-    override fun hasAnalogOutputSignal(state: BlockState) = true
-
-    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
-        return if ((level.getBlockEntity(pos) as CopperWasherBlockEntity).theItem != ItemStack.EMPTY) 1 else 0
-    }
-
-    override fun useItemOn(
-        stack: ItemStack,
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        player: Player,
-        hand: InteractionHand,
-        hitResult: BlockHitResult
-    ): ItemInteractionResult {
-        val entity = level.getBlockEntity(pos) as CopperWasherBlockEntity
-        val item = entity.theItem
-        if (item == ItemStack.EMPTY) {
-            if (level.isServerSide()) {
-                entity.theItem = stack.copyWithCount(1)
-                if (!player.isCreative) stack.shrink(1)
-                entity.craft()
-            }
-            return ItemInteractionResult.SUCCESS
-        } else {
-            if (level.isServerSide()) {
-                val facing = state.getValue(HORIZONTAL_FACING)
-                val itemEntity =
-                    ItemEntity(level, pos.x + 0.5, pos.y + 0.5, pos.z + 0.5, entity.theItem)
-                itemEntity.deltaMovement = Vec3(facing.stepX.toDouble(), 0.0, facing.stepZ.toDouble()).scale(0.2)
-                level.addFreshEntity(itemEntity)
-                entity.theItem = ItemStack.EMPTY
-                level.playSound(null, pos, SoundEvents.ITEM_FRAME_REMOVE_ITEM, SoundSource.BLOCKS)
-            }
-            return ItemInteractionResult.SUCCESS
-        }
-    }
-}

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

@@ -1,43 +0,0 @@
-package com.cobblemon.mod.common.block.appliances
-
-import com.cobblemon.mod.common.CobblemonBlockEntities
-import com.cobblemon.mod.common.CobblemonRecipeTypes
-import com.cobblemon.mod.common.CobblemonSounds
-import com.cobblemon.mod.common.item.crafting.washer.WasherInput
-import com.cobblemon.mod.common.util.isServerSide
-import net.minecraft.core.BlockPos
-import net.minecraft.sounds.SoundSource
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.level.block.entity.BlockEntity
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.ticks.ContainerSingleItem
-
-class CopperWasherBlockEntity(val pos: BlockPos, val state: BlockState): BlockEntity(
-    CobblemonBlockEntities.COPPER_WASHER,
-    pos, state
-), ContainerSingleItem.BlockContainerSingleItem {
-
-    private var item: ItemStack = ItemStack.EMPTY
-
-    override fun getContainerBlockEntity() = this
-    override fun getTheItem() = item
-    override fun setTheItem(item: ItemStack) {
-        this.item = item
-        level?.updateNeighborsAt(pos, state.block)
-    }
-
-    fun craft() {
-        val level = level ?: return
-        if (level.isClientSide || theItem.isEmpty) return
-
-        val input = WasherInput(theItem.copyWithCount(1))
-        val recipe = level.recipeManager
-            .getRecipeFor(CobblemonRecipeTypes.WASHER, input, level)
-            .orElse(null) ?: return
-
-        theItem = recipe.value().assemble(input, level.registryAccess())
-        setChanged()
-        level.playSound(null, pos, CobblemonSounds.WASHER_WASH, SoundSource.BLOCKS)
-        level.sendBlockUpdated(worldPosition, blockState, blockState, 3)
-    }
-}

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

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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

@@ -1,58 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.appliances
-
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.RandomSource
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.WeatheringCopper
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.properties.BlockStateProperties
-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 changeOverTime(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        val upperPos = pos.above()
-        val upperState = level.getBlockState(upperPos)
-        if (upperState.block != this || upperState.getValue(HALF) != DoubleBlockHalf.UPPER) {
-            return
-        }
-
-        if (random.nextFloat() < 0.05688889F) {
-            getNextState(state, level, pos, random).ifPresent { nextState ->
-                val nextLowerState = nextState.setValue(HALF, DoubleBlockHalf.LOWER)
-                val nextUpperState = nextState
-                    .setValue(HALF, DoubleBlockHalf.UPPER)
-                    .setValue(FACING, upperState.getValue(FACING))
-                    .setValue(BlockStateProperties.WATERLOGGED, upperState.getValue(BlockStateProperties.WATERLOGGED))
-                    .setValue(POWERED, upperState.getValue(POWERED))
-
-                level.setBlock(pos, nextLowerState, UPDATE_CLIENTS)
-                level.setBlock(upperPos, nextUpperState, UPDATE_ALL)
-            }
-        }
-    }
-
-    override fun isRandomlyTicking(state: BlockState): Boolean {
-        return WeatheringCopper.getNext(state.block).isPresent
-    }
-
-    override fun getAge(): WeatheringCopper.WeatherState {
-        return this.weatherState
-    }
-}

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

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.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/block/chest/GildedChestBlock.kt

@@ -11,11 +11,9 @@ package com.cobblemon.mod.common.block.chest
 import com.cobblemon.mod.common.CobblemonSounds
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.scheduling.afterOnServer
-import com.cobblemon.mod.common.block.PokemonDisguiseBlock
 import com.cobblemon.mod.common.block.entity.GildedChestBlockEntity
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.cobblemonResource
-import com.cobblemon.mod.common.util.math.FloatRange
 import com.cobblemon.mod.common.util.party
 import com.cobblemon.mod.common.util.toVec3d
 import com.mojang.serialization.MapCodec
@@ -27,7 +25,6 @@ import net.minecraft.network.chat.MutableComponent
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.server.level.ServerPlayer
-import net.minecraft.sounds.SoundEvent
 import net.minecraft.sounds.SoundSource
 import net.minecraft.util.RandomSource
 import net.minecraft.util.StringRepresentable
@@ -57,7 +54,7 @@ import net.minecraft.world.phys.shapes.VoxelShape
 
 @Suppress("OVERRIDE_DEPRECATION")
 class GildedChestBlock(settings: Properties, val type: Type = Type.RED) : BaseEntityBlock(settings),
-    SimpleWaterloggedBlock, PokemonDisguiseBlock {
+    SimpleWaterloggedBlock {
 
     init {
         registerDefaultState(stateDefinition.any()
@@ -73,6 +70,9 @@ class GildedChestBlock(settings: Properties, val type: Type = Type.RED) : BaseEn
             ).apply(it, ::GildedChestBlock)
         }
 
+        val POKEMON_ARGS = "gimmighoul"
+        val LEVEL_RANGE = 5..30
+
         val SOUTH_OUTLINE = Shapes.or(
             Shapes.box(0.0, 0.0, 0.25, 1.0, 1.0, 0.9375)
         )
@@ -127,6 +127,13 @@ class GildedChestBlock(settings: Properties, val type: Type = Type.RED) : BaseEn
         builder.add(WATERLOGGED)
     }
 
+    private val facingToYaw: HashMap<Direction, Float> = hashMapOf(
+        Direction.NORTH to -179.0F,
+        Direction.WEST to 90.0F,
+        Direction.SOUTH to 0.0F,
+        Direction.EAST to -90.0F
+    )
+
     override fun getName(): MutableComponent {
         return if (isFake()) Component.translatable("block.cobblemon.gilded_chest") else super.getName()
     }
@@ -142,6 +149,35 @@ class GildedChestBlock(settings: Properties, val type: Type = Type.RED) : BaseEn
         return super.playerWillDestroy(world, pos, state, player)
     }
 
+    private fun spawnPokemon(world: Level, pos: BlockPos, state: BlockState, player: ServerPlayer): InteractionResult {
+        val properties = "$POKEMON_ARGS lvl=${LEVEL_RANGE.random()}"
+        val pokemon = PokemonProperties.parse(properties)
+        val entity = pokemon.createEntity(world)
+
+        // The yaw based on the block's facing direction
+        val yaw = facingToYaw[state.getValue(HorizontalDirectionalBlock.FACING)] ?: 0.0F
+
+        entity.entityData.set(PokemonEntity.SPAWN_DIRECTION, yaw)
+        val offsetDir = state.getValue(HorizontalDirectionalBlock.FACING)
+        val vec = pos.toVec3d().add(offsetDir.stepX * 0.1 + 0.5, 0.0, offsetDir.stepZ * 0.1 + 0.5)
+        entity.moveTo(vec.x, vec.y, vec.z, yaw, entity.xRot)
+        world.addFreshEntity(entity)
+
+        world.removeBlock(pos, false)
+        afterOnServer(seconds = 0.1F) {
+            if (player !in player.level().players()) {
+                return@afterOnServer
+            }
+            val party = player.party()
+            if (!player.isCreative) {
+                entity.forceBattle(player)
+            } else {
+                world.playSound(null, pos, CobblemonSounds.GIMMIGHOUL_REVEAL, SoundSource.NEUTRAL)
+            }
+        }
+        return InteractionResult.SUCCESS
+    }
+
     override fun useWithoutItem(
         state: BlockState,
         world: Level,
@@ -254,10 +290,4 @@ class GildedChestBlock(settings: Properties, val type: Type = Type.RED) : BaseEn
         blockEntity.tick()
     }
 
-    override val levelRange = 5..30
-    override val pokemonArgs = "gimmighoul"
-    override val spawnSound = CobblemonSounds.GIMMIGHOUL_REVEAL
-    override val scaleRange = FloatRange(1f, 1f)
-    override fun getPokemonFacing(state: BlockState): Direction = state.getValue(HORIZONTAL_FACING)
-    override val shinyRate = null
 }

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

@@ -11,11 +11,8 @@ package com.cobblemon.mod.common.block.dispenser
 import com.cobblemon.mod.common.block.SaccharineLeafBlock
 import com.cobblemon.mod.common.block.SaccharineLogBlock
 import com.cobblemon.mod.common.block.SaccharineLogSlatheredBlock
-import com.cobblemon.mod.common.block.appliances.CopperFridgeBlock
 import com.cobblemon.mod.common.mixin.accessor.DispenserBlockAccessor
 import net.minecraft.core.dispenser.DispenseItemBehavior
-import net.minecraft.sounds.SoundEvents
-import net.minecraft.sounds.SoundSource
 import net.minecraft.world.item.Item
 import net.minecraft.world.item.Items
 import net.minecraft.world.item.alchemy.PotionContents
@@ -89,30 +86,5 @@ object DispenserBehaviorRegistry {
                 ).item
             )
         )
-        register(
-            { dispenseWaterBucketIntoFridge() },
-            items = listOf(Items.WATER_BUCKET)
-        )
     }
-
-    private fun dispenseWaterBucketIntoFridge(): DispenseItemBehavior =
-        DispenseItemBehavior { source, stack ->
-            val level = source.level
-            val pos = source.pos.relative(source.state.getValue(DispenserBlock.FACING))
-            val fridge = level.getBlockState(pos).block as? CopperFridgeBlock
-
-            if (fridge == null) {
-                stack
-            } else {
-                val fridgeEntity = fridge.getBlockEntity(level, pos)
-                if (!fridgeEntity.theItem.isEmpty) {
-                    stack
-                } else {
-                    fridgeEntity.theItem = Items.WATER_BUCKET.defaultInstance
-                    fridgeEntity.timer = 100
-                    level.playSound(null, pos, SoundEvents.BUCKET_EMPTY, SoundSource.BLOCKS, 1.0f, 1.0f)
-                    Items.BUCKET.defaultInstance
-                }
-            }
-        }
 }

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

@@ -41,7 +41,6 @@ import net.minecraft.world.Containers
 import net.minecraft.world.InteractionResult
 import net.minecraft.world.ItemInteractionResult
 import net.minecraft.world.InteractionHand
-import net.minecraft.world.entity.LightningBolt
 import net.minecraft.world.entity.LivingEntity
 import net.minecraft.world.entity.Pose
 import net.minecraft.world.entity.item.ItemEntity
@@ -618,14 +617,11 @@ open class FossilMultiblockEntity(
     }
 
     companion object {
-        val TICKER = BlockEntityTicker<FossilMultiblockEntity> { level, _, _, blockEntity ->
-            val serverLevel = level as? ServerLevel ?: return@BlockEntityTicker
-
-            if (blockEntity.checkLightning(serverLevel)) return@BlockEntityTicker
+        val TICKER = BlockEntityTicker<FossilMultiblockEntity> {level, _, _, blockEntity ->
             if (blockEntity.multiblockStructure != null) return@BlockEntityTicker
-            if (blockEntity.porygonProcess == PorygonProcessType.INACTIVE) return@BlockEntityTicker
+            if(blockEntity.porygonProcess == PorygonProcessType.INACTIVE) return@BlockEntityTicker
 
-            blockEntity.tickPorygon(serverLevel)
+            blockEntity.tickPorygon(level)
         }
     }
 
@@ -701,29 +697,4 @@ open class FossilMultiblockEntity(
         //Fallback: If no safe location is found, just spawn it directly in front of the monitor
         return origin.relative(facing)
     }
-
-    private var lastLightningBolt: UUID? = null
-
-    fun checkLightning(level: ServerLevel): Boolean {
-        val bolt = level.getEntitiesOfClass(
-            LightningBolt::class.java,
-            AABB.ofSize(blockPos.center, 1.0, 4.0, 1.0)
-        ).firstOrNull {
-            (it.blockPosition() == blockPos || it.blockPosition().below() == blockPos) &&
-                    it.uuid != lastLightningBolt
-        } ?: return false
-
-        lastLightningBolt = bolt.uuid
-
-        level.setBlockAndUpdate(
-            blockPos,
-            CobblemonBlocks.ROTOM_MONITOR.defaultBlockState()
-                .setValue(
-                    HorizontalDirectionalBlock.FACING,
-                    level.getBlockState(blockPos).getValue(HorizontalDirectionalBlock.FACING)
-                )
-        )
-        return true
-    }
-
 }

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,6 +101,7 @@ 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
@@ -118,6 +119,7 @@ object CobblemonClient {
         teamData = ClientPlayerTeamData()
         clientPokedexData = ClientPokedexManager(mutableMapOf())
         clientTMMoveData = ClientTMMoveManager(mutableSetOf())
+        clientBadgeData = ClientBadgeManager(mutableSetOf())
         storage.onLogin()
 //        CobblemonDataProvider.canReload = false
     }
@@ -391,7 +393,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,
@@ -419,7 +421,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,
@@ -516,17 +518,7 @@ object CobblemonClient {
             CobblemonBlocks.POTTED_WATMEL_BERRY,
             CobblemonBlocks.POTTED_WEPEAR_BERRY,
             CobblemonBlocks.POTTED_WIKI_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
+            CobblemonBlocks.POTTED_YACHE_BERRY
         )
 
         this.createBoatModelLayers()

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

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

@@ -0,0 +1,221 @@
+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,6 +39,7 @@ 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

@@ -0,0 +1,29 @@
+/*
+ * 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/net/effect/SpawnSnowstormParticleHandler.kt

@@ -13,7 +13,6 @@ import com.cobblemon.mod.common.client.particle.BedrockParticleOptionsRepository
 import com.cobblemon.mod.common.client.particle.ParticleStorm
 import com.cobblemon.mod.common.client.render.MatrixWrapper
 import com.cobblemon.mod.common.net.messages.client.effect.SpawnSnowstormParticlePacket
-import com.mojang.math.Axis
 import net.minecraft.client.Minecraft
 import com.mojang.blaze3d.vertex.PoseStack
 
@@ -21,7 +20,6 @@ object SpawnSnowstormParticleHandler : ClientNetworkPacketHandler<SpawnSnowstorm
     override fun handle(packet: SpawnSnowstormParticlePacket, client: Minecraft) {
         val wrapper = MatrixWrapper()
         val matrix = PoseStack()
-        matrix.mulPose(Axis.YP.rotationDegrees(packet.rotation))
         wrapper.updateMatrix(matrix.last().pose())
         wrapper.updatePosition(packet.position)
         val world = Minecraft.getInstance().level ?: return

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

@@ -34,7 +34,6 @@ 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
@@ -45,6 +44,7 @@ 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(UIEntitySoundInstance(soundEvent, volume, pitch))
+                    Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, volume, pitch))
                 }
             }
         }

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

@@ -19,7 +19,6 @@ 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
@@ -32,6 +31,7 @@ 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(UIEntitySoundInstance(soundEvent))
+                Minecraft.getInstance().soundManager.play(SimpleSoundInstance.forUI(soundEvent, 1F, 1F))
             }
         }
     }

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 = 0.93F
-    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
+    override var profileScale = 1.1F
+    override var profileTranslation = Vec3(-0.1, 0.1, 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 = 0.93F
-    override var profileTranslation = Vec3(-0.1, 0.36, 0.0)
+    override var profileScale = 1.1F
+    override var profileTranslation = Vec3(-0.1, 0.1, 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.25F
-    override var profileTranslation = Vec3(0.0, -0.17, 0.0)
+    override var profileScale = 1.6F
+    override var profileTranslation = Vec3(0.0, -0.6, 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 = 0.82F
-    override var profileTranslation = Vec3(0.0, 0.53, 0.0)
+    override var profileScale = 1.0F
+    override var profileTranslation = Vec3(0.0, 0.3, 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.75F
-    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
+    override var profileScale = 0.9F
+    override var profileTranslation = Vec3(0.0, 0.4, 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.75F
-    override var profileTranslation = Vec3(0.0, 0.6, 0.0)
+    override var profileScale = 0.9F
+    override var profileTranslation = Vec3(0.0, 0.4, 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('dusclops', 'cry')".asExpressionLike()
+        animations["cry"] = "q.bedrock_stateful('squirtle', '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,7 +12,6 @@ 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
 
@@ -29,8 +28,6 @@ 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,7 +14,6 @@ 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
@@ -37,8 +36,6 @@ 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,7 +14,6 @@ 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
 
@@ -37,8 +36,6 @@ 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,7 +12,6 @@ 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
 
@@ -31,8 +30,6 @@ 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

@@ -0,0 +1,62 @@
+/*
+ * 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

@@ -0,0 +1,70 @@
+/*
+ * 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

@@ -0,0 +1,70 @@
+/*
+ * 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.68F
+    override var profileScale = 0.85F
     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

@@ -0,0 +1,85 @@
+/*
+ * 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

@@ -0,0 +1,77 @@
+/*
+ * 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 = 0.98F
-    override var profileTranslation = Vec3(0.0, 0.28, 0.0)
+    override var profileScale = 1.2F
+    override var profileTranslation = Vec3(0.0, 0.05, 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.58F
-    override var profileTranslation = Vec3(0.0, 0.91, 0.0)
+    override var profileScale = 0.8F
+    override var profileTranslation = Vec3(0.0, 0.6, 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.36F
-    override var profileTranslation = Vec3(0.0, 1.19, 0.0)
+    override var profileScale = 0.32F
+    override var profileTranslation = Vec3(0.0, 1.24, 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

@@ -0,0 +1,208 @@
+/*
+ * 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,6 +322,8 @@ 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)
@@ -338,6 +340,9 @@ 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)
@@ -397,6 +402,7 @@ 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

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

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

@@ -0,0 +1,51 @@
+/*
+ * 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,10 +47,6 @@ 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)
@@ -168,9 +164,6 @@ 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,6 +11,7 @@ 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
@@ -120,6 +121,7 @@ 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,7 +1294,16 @@ open class PokemonEntity(
     }
 
     private fun showInteractionWheel(player: ServerPlayer, itemStack: ItemStack) {
-        val canRide = isRideableFor(player)
+         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);
+        }
         if (pokemon.getOwnerPlayer() == player) {
             val cosmeticItemDefinition = CobblemonCosmeticItems.findValidCosmeticForPokemonAndItem(
                 player.level().registryAccess(),
@@ -1316,18 +1325,6 @@ 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)
@@ -1609,8 +1606,9 @@ open class PokemonEntity(
                 || stack.`is`(CobblemonItemTags.WHITELISTED_ITEMS_TO_HOLD)
 
     fun tryRidingPokemon(player: ServerPlayer): Boolean {
-        if (!isRideableFor(player)) return false
-
+        if (pokemon.effectiveScale < Cobblemon.config.minimumRidingScale) {
+            return false
+        }
         val event = RidePokemonEvent.Pre(player, this)
         CobblemonEvents.RIDE_EVENT_PRE.post(event)
         if (!event.isCanceled) {
@@ -2744,9 +2742,4 @@ 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,7 +22,6 @@ 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
@@ -47,15 +46,10 @@ 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?
@@ -361,30 +355,9 @@ 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,10 +78,21 @@ 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/crafting/washer/WasherInput.kt

@@ -1,16 +0,0 @@
-package com.cobblemon.mod.common.item.crafting.washer
-
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.item.crafting.Ingredient
-import net.minecraft.world.item.crafting.RecipeInput
-
-class WasherInput(
-    val item: ItemStack = ItemStack.EMPTY
-) : RecipeInput {
-
-    override fun getItem(index: Int): ItemStack? {
-        return if (index == 0) item else null
-    }
-
-    override fun size() = 1
-}

common/src/main/kotlin/com/cobblemon/mod/common/item/crafting/washer/WasherRecipe.kt

@@ -1,79 +0,0 @@
-package com.cobblemon.mod.common.item.crafting.washer
-
-import com.cobblemon.mod.common.CobblemonRecipeSerializers
-import com.cobblemon.mod.common.CobblemonRecipeTypes
-import com.mojang.serialization.Codec
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.component.DataComponents
-import net.minecraft.core.HolderLookup
-import net.minecraft.network.RegistryFriendlyByteBuf
-import net.minecraft.network.codec.StreamCodec
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.item.crafting.Ingredient
-import net.minecraft.world.item.crafting.Recipe
-import net.minecraft.world.item.crafting.RecipeSerializer
-import net.minecraft.world.level.Level
-
-class WasherRecipe(
-    val input: Ingredient,
-    val result: ItemStack,
-    val preserveInputComponents: Boolean = false,
-    val removeDyedColor: Boolean = false
-) : Recipe<WasherInput> {
-
-    override fun getType() = CobblemonRecipeTypes.WASHER
-    override fun canCraftInDimensions(width: Int, height: Int) = true
-    override fun assemble(input: WasherInput, registries: HolderLookup.Provider): ItemStack {
-        val output = if (preserveInputComponents) {
-            input.item.transmuteCopy(result.item, result.count)
-        } else {
-            result.copy()
-        }
-        if (removeDyedColor) {
-            output.remove(DataComponents.DYED_COLOR)
-        }
-        return output
-    }
-    override fun getSerializer() = CobblemonRecipeSerializers.WASHER
-    override fun getResultItem(registries: HolderLookup.Provider): ItemStack = result.copy()
-    override fun matches(input: WasherInput, level: Level) =
-        this.input.test(input.item) && (!removeDyedColor || input.item.has(DataComponents.DYED_COLOR))
-
-    class Serializer : RecipeSerializer<WasherRecipe> {
-        companion object {
-            val CODEC: MapCodec<WasherRecipe> = RecordCodecBuilder.mapCodec { instance ->
-                instance.group(
-                    Ingredient.CODEC.fieldOf("input").forGetter { recipe -> recipe.input },
-                    ItemStack.STRICT_CODEC.fieldOf("result").forGetter { recipe -> recipe.result },
-                    Codec.BOOL.optionalFieldOf("preserve_input_components", false)
-                        .forGetter { recipe -> recipe.preserveInputComponents },
-                    Codec.BOOL.optionalFieldOf("remove_dyed_color", false)
-                        .forGetter { recipe -> recipe.removeDyedColor }
-                ).apply(instance, ::WasherRecipe)
-            }
-        }
-
-        val STREAM_CODEC: StreamCodec<RegistryFriendlyByteBuf, WasherRecipe> =
-            StreamCodec.of(::toNetwork, ::fromNetwork)
-
-        private fun fromNetwork(buffer: RegistryFriendlyByteBuf): WasherRecipe {
-            val input = Ingredient.CONTENTS_STREAM_CODEC.decode(buffer)
-            val result = ItemStack.STREAM_CODEC.decode(buffer)
-            val preserveInputComponents = buffer.readBoolean()
-            val removeDyedColor = buffer.readBoolean()
-            return WasherRecipe(input, result, preserveInputComponents, removeDyedColor)
-        }
-
-        private fun toNetwork(buffer: RegistryFriendlyByteBuf, recipe: WasherRecipe) {
-            Ingredient.CONTENTS_STREAM_CODEC.encode(buffer, recipe.input)
-            ItemStack.STREAM_CODEC.encode(buffer, recipe.result)
-            buffer.writeBoolean(recipe.preserveInputComponents)
-            buffer.writeBoolean(recipe.removeDyedColor)
-        }
-
-        override fun codec() = CODEC
-        override fun streamCodec() = STREAM_CODEC
-    }
-
-}