feature: display an alpha icon after Pokemon names in battle

.gitignore

@@ -45,3 +45,6 @@ common/.fabric
 # MacOS
 .DS_Store
 /common/config/*
+
+# Temp Files
+/temp/

.gitlab-ci.yml

@@ -157,9 +157,6 @@ build:
     paths:
       - neoforge/build/libs
       - fabric/build/libs
-    exclude:
-      - neoforge/build/libs/*-dev-shadow.jar
-      - fabric/build/libs/*-dev-shadow.jar
 
 publish:
   stage: deploy

CHANGELOG.md

@@ -1,194 +1,60 @@
 # Changelog
-## [1.8.2 (MONTH xth, 2026)](#1-8-2)
+## [1.8.1 (MONTH Xth, 2026)](#1-8-1)
 
 ### Additions
-- The following items can now be placed on the ground as blocks:
-  - King's Rock, Galarica Cuff, Unremarkable Teacup, Masterpiece Teacup, Chipped Pot, Cracked Pot, Sachet, Metal Powder, Quick Powder, Bright Powder, Soft Sand, Electirizer, Magmarizer, Icy Rock, Heat Rock, Smooth Rock, Damp Rock, Destiny Knot, Luminous Moss, Never-Melt Ice, Wide Lens, Scope Lens, and Zoom Lens.
-  - Iron Ball, Metal Coat, Throat Spray, Terrain Extender, Medicinal Brew, Moomoo Milk, HP Up, Protein, Iron, Carbos, Calcium, Zinc, PP Up, PP Max, Upgrade, Dubious Disc, and Loaded Dice.
-- The following items can now be placed on various surfaces:
-  - Galarica Wreath, Magnet, Flame Orb, Life Orb, Toxic Orb, Light Ball, and Smoke Ball.
-- The following items can now be placed as blocks and have additional functionality:
-  - Ring Target, Metronome, and Eject Button.
-- The following items can now be worn by Players and Pokémon:
-  - Galarica Wreath, Cleanse Tag, Spell Tag, Sharp Beak, Covert Cloak, Shell Helmet, and Never-Melt Ice.
-- Wearable items can now be equipped by a player by holding it and right-clicking (or rebound use/interact)
-  - Wearable items that can be placed down are exempt from this behaviour.
-- Mint Leaves can now be placed on the ground as Leaf Litter, or in Flower Pots
-- Added Oricorio Flowers
-- Added Terrain Plants
-- Berries can now be placed in Flower Pots
-- The evolution tree can now be viewed on the Pokédex, showing a Pokémon's full family line and what's needed to evolve into each stage.
-- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders and dice.
-- New Cosmetic Item for Pikachu: Paper
-- Burmy changes its cloak after a battle it took part in, based on the biome: Trash Cloak in the Deep Dark, Nether and End, Plant Cloak in lush biomes such as forests, jungles, plains and swamps, and Sandy Cloak in sandy biomes, beaches and caves.
-- The evolution tree can now be viewed on the Pokédex, showing a Pokémon's full family line and what's needed to evolve into each stage.
-- Added custom sounds to a bunch of items that can be placed as blocks: liquid bottles, pill bottles, powders and dice.
 
-### Fixes
-- Fixed #updateMovesOnFormChange not properly initializing a form-swapped Pokemon's non-form_change moves.
-### TEST
+### New rideable Pokémon
+
 ### Pokémon Added
-#### Generation 4
-- Snover
-- Abomasnow
-- Burmy
-- Wormadam
-- Mothim
-
-#### Generation 5
-- Tympole
-- Palpitoad
-- Seismitoad
-
-#### Generation 6
-- Helioptile
-- Heliolisk
-
-#### Generation 7
-- Grubbin
-- Charjabug
-- Vikavolt
-- Minior
-
-#### Generation 8
-- Eternatus
-
-#### Generation 9
-- Greavard
-- Houndstone
 
 ### Model updates for the following Pokémon
-- Sudowoodo
-- Spheal
-- Cacnea
-- Cacturne
-- Binacle
-- Barbaracle
-- Glimmet
-- Glimmora
-- Deerling
-- Sawsbuck (All forms)
-- Absol
-- Poliwag
-- Politoed
-- Ekans
-- Oddish
-- Gloom
-- Vileplume
-- Bellossom
-- Shroomish
-- Chespin
-- Quilladin
-- Chesnaught
-- Fennekin
-- Braixen
-- Delphox
-- Froakie
-- Frogadier
-- Greninja
-- Shinx
-- Luxio
-- Luxray
-- Slakoth
-- Riolu
-- Lucario
 
 ### Animation updates for the following Pokémon
-- Treecko (New Shoulder Mount!)
-- Bonsly (New Shoulder Mount!)
-- Sudowoodo
-- Cacnea
-- Cacturne
-- Ekans
-- Arbok
-- Oddish
-- Gloom
-- Vileplume
-- Bellossom
-- Pichu
-- Pikachu
-- Raichu (+ Alolan)
-- Greninja
-- Slakoth
 
 ### Changes
-- Terrain Seeds can now be planted
-- Terrain Seeds are now consumed during PvP and NPC battles
-- Glow Item Frames can be crafted using Bright Powder as an alternative to Glow Ink Sacs
-- Bright Powder can be used on Signs and Hanging Signs to make text glow, as an alternative to Glow Ink Sacs
-- Updated various recipes to display in Recipe Groups within the Recipe Book
-- Updated most recipes to display more logically/consistently within the Recipe Book's categories
-- Updated the following recipes
-  - Never-Melt Ice, Focus Sash, Blunder Policy, Weakness Policy, Blank TM
-- Make ride rotations less jittery in multiplayer.
-- Changes Disc Shelf TMs to use textures instead of tinting and overlays to line up with item display
-- Blank TM can now be inserted into the Disc Shelf
-- Added TM creative tab
-- Recall animation now renders ball in hand with the player arm raised.
-- Made regional and Vivillon split-evo locations now mutually exclusive
-- Vivillon's patterns are now viewable as forms with form names and unique Pokedex entries displayed.
-- Item evolutions now unlock **all** locked evolutions whose requirements are met instead of stopping after the first.
-  - Exceptions being "forced" evolutions which will continue to stop after the first one
-- Removed Mega Drain as a TM
-- Vivillon's patterns are now viewable as forms with form names and unique Pokedex entries displayed.
-- Slowed the speed of Type Gem growth, and revamped their generation to grow in a more crystal-like shape
-- PokeSnacks (and other area spawns) will now start the vertical offset checking from the center rather than base coordinate
-  - This will help PokeSnacks to work inside caves or tighter spaces better
 
 ### Fixes
-- Correctly grants "They're Minerals!" advancement when planting a type gem
-- Shoulder mounted Pokémon now follow player body animations, improving their positioning with custom player animations and default actions.
-- Shoulder mounted Pokémon now sit slightly higher with chest armor equipped for better alignment, with a configurable blacklist.
-- Type Gem Blocks now have advancements to give you the recipe in the recipe book (the data for the advancements were inside the recipes somehow??)
-- Some other recipes without advancements have also been corrected
-- Corrected the TM Recipes for Charge Beam and Payday
-- Type Gem blocks now properly generate clusters off of the block.
-- Starter Screen Categories will no longer stop rendering if they are bigger than the viewport, and you are not viewing top or bottom edges
-- Random Starter option now properly handled in height calculation, so now it won't run off into other categories or be un-accessible due to scroll limits if it causes a new row
-- Mochi and Feathers no longer drop glass bottles on use
-- Fixed a rare set of concurrency bugs related to reloading packs on NeoForge; fixes a ModernFix issue
-- Removed unnecessary conditions for Mimikyu's standing pose. Hopefully fixes the rare instance of it using its shoulder animations during battle in multiplayer scenarios.
-- Fixed Rockruff line not blinking
-- Fixed Flygon sometimes using its running animation instead of walking
-- Fixed Bramblin always sleeping outside of battle
-- Fixed Dragonair using its battle idle as a normal idle
+- Fixed the `stat_compare` and `stat_equal` evolution requirements crashing the game when given `special_attack` or `special_defence`, and made them treat any non-permanent stat as a failed requirement instead of crashing.
+- Fixed the Beast Ball not applying its 0.1× penalty to Pokémon that are not Ultra Beasts.
+- Fixed the Moon Ball reading the world's total elapsed time instead of the time of day, so its bonus applied during the day instead.
+- Fixed the Love Ball never awarding its 2.5× opposite gender bonus, and matching species by display name instead of identifier.
+- Fixed the Timer Ball being weaker than a regular Poké Ball on early turns and only reaching 4× on turn 14 instead of turn 10.
+- Fixed the Luxury Ball only doubling Friendship gains of 1, leaving level up and berry gains unaffected.
+- Fixed NPCs getting their own TM progress file.
+- Fixed the TM Machine refusing move selections that the `unlockAllMoveDexMovesByDefault` config had made visible, leaving the move slot blank and the craft button unresponsive.
+- Fixed Rufflet, Braviary, and Hisuian Braviary flooding logs with errors about missing sound events.
+- Fixed Pokémon property typos in Pangoro and Dedenne herd spawn files.
+- Fixed form typo in Rockruff dusk spawn entry.
+- Fixed a potential world gen stall with the Type Gem clusters.
+- Fixed Rowap and Jacoba berries not correctly altering Pokémon sizes when used as bait
+- Fixed Ampharos' eyes not emitting particles
+- Fixed Alolan Raticate's cry not playing
+- Fixed unintentional watermelon cosmetic for Hisuian Electrode. 
+- Fixed Blastoise having an unintentional passenger seat
+- Fixed odd NeoForge crash due to a dependency being outdated. It will now flag the dependency for being outdated correctly.
+- Fixed form typo in Rockruff-Dusk spawn, preventing it from being able to spawn.
+- Fixed a potential world gen stall caused by Type Gem clusters.
+- Fixed Rowap and Jacoba berries not correctly altering Pokémon sizes when used as bait.
+- Fixed Ampharos' eyes not emitting particles.
+- Fixed Alolan Raticate's cry not playing.
+- Fixed odd NeoForge crash due to a dependency being outdated. It will now correctly flag the dependency for being outdated.
+- Fixed several incorrect light-based spawning conditions for ghosts and bugs. 
+- Removed unused, placeholder habitat pools.
+- Fixed Mantyke, Mantine, and Quaxly getting stuck in a recoil 'expression' during battles due to a having an expression mistakenly assigned as a recoil animation. 
+- Fixed Pokémon on shoulders not animating if they are visibly holding a held item.
+- Fixed Mantyke, Mantine, and Quaxly getting stuck in a recoil 'expression' during battles due to a having an expression mistakenly assigned as a recoil animation.
 - Fixed Lycanroc's head movement
 - Added head movement to Archaludon
-- Fixed Duraludon line not having any sleep animations
+- Fixed Duraludon line not having their sleep animations
 - Fixed Diglett line not having their faint animations
 - Fixed Kingambit moving its legs while walking
-- Fixed Alolan Diglett's cry not playing
-- Fixed shiny alpha Snorlax using the non-shiny texture
-- Various Structure fixes
-- Fixed shiny Pokémon under certain circumstances forgetting taught TMs
-- Fixed certain Pokémon sounds sometimes being doubled when played at specific times in their animations
-- Fixed ball capture beam origin coming from behind the ball.
-- Fixed Safari Ball catch rate outside of battle
-- Fixed alpha eye (and other) particles not respecting client particle density setting in video options
+
 
 ### Developer
-- Evolution requirements can now set `pokedexIcon` and `pokedexTooltip` directly in their JSON to control how they're shown on the Pokédex's evolution tree, for example:
-  ```json
-  {
-    "variant": "attack_defence_ratio",
-    "pokedexIcon": "minecraft:diamond_sword",
-    "pokedexTooltip": "cobblemon.ui.pokedex.requirement.attack_defence_ratio.tooltip"
-  }
-  ```
-- Fixed wrong order of operations in the code flow prior to the `FOSSIL_REVIVED` event causing pokemon to appear without entity link
-- Fixed TestPartySlot command not correctly comparing the provided spec with the target Pokémon
 
 ### Molang & Datapacks
-- A new `negate` variant for evolution requirements has been added, which will negate (invert) the provided inner condition.
-- Added Molang functions for individual Pokédex ids, wherein a subdex is passed in as a string to `dex_caught_count` etc.
-- Added a `battle_ended` callback, backed by the new `BATTLE_ENDED` event, which fires whenever a battle ends for any reason, alongside a multitude of flags not previously covered by `BATTLE_VICTORY`.
-- Added `battle_pokemon` to battle actor structs and `has_faced_opponents` to battle Pokémon structs.
-- Added the `cobblemon:form_change/bagworm_cloak/plant_cloak`, `sandy_cloak` and `trash_cloak` biome tags, which control Burmy's cloak after battle.
-- Added a `battlingEyeHeight` field to set the eye height of a Pokémon while battling
 
 ### Particles
 
-#### New Move Animations
-
 ### Localization
-- Updated translations for:
+- Updated translations for:

alpha-pokemon-todo

@@ -0,0 +1,9 @@
+- Some kind of particle effect for them? they're meant to have glowing eyes, so maybe some red particles on the eye locator
+--- global posers? stacked posers?
+--- red texture seems to be what some people wanted.
+
+/- shoulder mounts part of it
+- omni boost
+- roar when player comes within reach, adjust levels
+
+- Riding settings to control what the min scale is for a pokemon to be ridable.

build.gradle.kts

@@ -1,6 +1,3 @@
-import utilities.gitBranch
-import utilities.gitShortCommit
-
 plugins {
     id("cobblemon.root-conventions")
 }
@@ -9,6 +6,6 @@ version = "${project.property("mod_version")}+${project.property("mc_version")}"
 
 val isSnapshot = project.property("snapshot")?.equals("true") == true
 if (isSnapshot) {
-    val fixedBranchName = gitBranch().substringAfter("/")
-    version = "$version-${fixedBranchName}-${gitShortCommit()}"
+    val fixedBranchName = versioning.info.branch.substringAfter("/")
+    version = "$version-${fixedBranchName}-${versioning.info.build}"
 }

changelogs/CHANGELOG-1.8.1.md

@@ -1,41 +0,0 @@
-# Changelog
-## [1.8.1 (September 13th, 2026)](#1-8-1)
-
-### Animation updates for the following Pokémon
-- Flapple, Appletun, Dipplin, Hydrapple (placeholder animations only).
-
-### Fixes
-- Fixed a potential world generation stall caused by Type Gem clusters.
-- Fixed Pokémon on shoulders not animating if they are visibly holding a held item.
-- Fixed NPCs getting their own TM progress file.
-- Fixed odd NeoForge crash due to a dependency being outdated. It will now correctly flag the dependency for being outdated.
-- Fixed the TM Machine refusing move selections that the `unlockAllMoveDexMovesByDefault` config had made visible, leaving the move slot blank and the craft button unresponsive.
-- Fixed the Beast Ball not applying its 0.1× penalty to Pokémon that are not Ultra Beasts.
-- Fixed the Moon Ball reading the world's total elapsed time instead of the time of day, so its bonus applied during the day instead.
-- Fixed the Love Ball never awarding its 2.5× opposite gender bonus, and matching species by display name instead of identifier.
-- Fixed the Timer Ball being weaker than a regular Poké Ball on early turns and only reaching 4× on turn 14 instead of turn 10.
-- Fixed the Luxury Ball only doubling Friendship gains of 1, leaving level up and berry gains unaffected.
-- Fixed Rufflet, Braviary, and Hisuian Braviary flooding logs with errors about missing sound events.
-- Fixed Pokémon property typos in Pangoro and Dedenne herd spawn files.
-- Fixed unintentional watermelon cosmetic for Hisuian Electrode. 
-- Fixed Blastoise having an unintentional passenger seat.
-- Fixed form typo in Rockruff-Dusk spawn, preventing it from being able to spawn.
-- Fixed the `stat_compare` and `stat_equal` evolution requirements crashing the game when given `special_attack` or `special_defence`, and made them treat any non-permanent stat as a failed requirement instead of crashing.
-- Fixed Rowap and Jacoba berries not correctly altering Pokémon sizes when used as bait.
-- Fixed Ampharos' eyes not emitting particles.
-- Fixed Alolan Raticate's cry not playing.
-- Fixed several incorrect light-based spawning conditions for ghosts and bugs. 
-- Removed unused, placeholder habitat pools.
-- Fixed Mantyke, Mantine, and Quaxly getting stuck in a recoil 'expression' during battles due to having an expression assigned as a recoil animation. 
-- Fixed Lucario's aura particles not emitting.
-- Fixed Lycanroc's head movement.
-- Added head movement to Archaludon.
-- Fixed Duraludon line not having their sleep animations.
-- Fixed Diglett line not having their faint animations.
-- Fixed Kingambit moving its legs while walking.
-
-### Localization
-- Updated translations for:
-  - Brazilian Portuguese
-  - Simplified Chinese
-  - Japanese

common/build.gradle.kts

@@ -1,8 +1,9 @@
 
 import utilities.isSnapshot
 import utilities.version
-import utilities.gitBranch
-import utilities.gitCommit
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import java.time.format.DateTimeFormatter
 
 /*
  *
@@ -71,14 +72,6 @@ tasks.withType<Test> {
     }
 }
 
-// Git info lives in its own output dir (not processResources) so a new commit only rewrites this one file.
-val writeGitInfo by tasks.registering(WriteProperties::class) {
-    destinationFile = layout.buildDirectory.file("generated/gitInfo/cobblemon-git.properties")
-    property("commit", gitCommit())
-    property("branch", gitBranch())
-}
-sourceSets.main { output.dir(mapOf("builtBy" to writeGitInfo), layout.buildDirectory.dir("generated/gitInfo")) }
-
 tasks.processResources {
     exclude("data/**/README.md")
 }
@@ -105,13 +98,11 @@ sourceSets {
                 property("modid", "cobblemon")
                 property("version", project.version())
                 property("isSnapshot", if(rootProject.isSnapshot()) "true" else "false")
+                property("gitCommit", versioning.info.commit)
+                property("branch", versioning.info.branch)
                 System.getProperty("buildNumber")?.let { property("buildNumber", it) }
+                property("timestamp", OffsetDateTime.now(ZoneOffset.UTC).format(DateTimeFormatter.ofPattern("MM/dd/yyyy hh:mm:ss")) + " UTC")
             }
         }
     }
 }
-
-// The platform jars are built from :common:jar, so the remapped common jars are only needed by `publish`
-tasks.assemble {
-    setDependsOn(dependsOn.filterNot { (it as? TaskProvider<*>)?.name in setOf("remapJar", "remapSourcesJar") })
-}

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

@@ -15,7 +15,6 @@ import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import com.mojang.serialization.MapCodec;
 import java.util.Optional;
 import java.util.function.Supplier;
-import net.minecraft.SharedConstants;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.IntTag;
 import net.minecraft.resources.ResourceKey;
@@ -46,24 +45,4 @@ public class ChunkStorageMixin {
         int curVersion = vanillaFixed.contains(VERSION_KEY) ? vanillaFixed.getInt(VERSION_KEY) : 0;
         return DataFixTypes.CHUNK.update(CobblemonSchemas.getDATA_FIXER(), vanillaFixed, curVersion, CobblemonSchemas.DATA_VERSION);
     }
-
-    // Our update on the same MC version still needs its own fixes so run them here in that case.
-    @Inject(
-        method = "upgradeChunkTag(Lnet/minecraft/resources/ResourceKey;Ljava/util/function/Supplier;Lnet/minecraft/nbt/CompoundTag;Ljava/util/Optional;)Lnet/minecraft/nbt/CompoundTag;",
-        at = @At("HEAD"),
-        cancellable = true
-    )
-    private void cobblemon$doChunkFixOnCurrentVersion(
-        ResourceKey<Level> levelKey,
-        Supplier<DimensionDataStorage> storage,
-        CompoundTag chunkData,
-        Optional<ResourceKey<MapCodec<? extends ChunkGenerator>>> chunkGeneratorKey,
-        CallbackInfoReturnable<CompoundTag> cir
-    ) {
-        if (ChunkStorage.getVersion(chunkData) != SharedConstants.getCurrentVersion().getDataVersion().getVersion()) {
-            return;
-        }
-        int curVersion = chunkData.contains(VERSION_KEY) ? chunkData.getInt(VERSION_KEY) : 0;
-        cir.setReturnValue(DataFixTypes.CHUNK.update(CobblemonSchemas.getDATA_FIXER(), chunkData, curVersion, CobblemonSchemas.DATA_VERSION));
-    }
 }

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

@@ -10,13 +10,11 @@ package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.OrientationControllable;
 import com.cobblemon.mod.common.client.render.player.MountedPlayerRenderer;
-import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker;
 import com.cobblemon.mod.common.duck.RidePassenger;
 import com.cobblemon.mod.common.entity.pokemon.PokemonEntity;
 import net.minecraft.client.model.HumanoidModel;
 import net.minecraft.client.model.geom.ModelPart;
 import net.minecraft.client.player.AbstractClientPlayer;
-import net.minecraft.util.Mth;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.LivingEntity;
 import org.spongepowered.asm.mixin.Final;
@@ -98,14 +96,4 @@ public class HumanoidModelMixin {
             MountedPlayerRenderer.INSTANCE.animate((HumanoidModel<AbstractClientPlayer>)(Object)this, pokemonEntity, player, netHeadYaw, headPitch, ageInTicks, limbSwing, limbSwingAmount);
         }
     }
-
-    @Inject(method = "setupAnim*", at = @At("TAIL"))
-    public void cobblemon$poseRecallArm(LivingEntity entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch, CallbackInfo ci) {
-        if (!(entity instanceof AbstractClientPlayer) || entity.getVehicle() instanceof PokemonEntity) return;
-        float raise = RecallArmAnimationTracker.INSTANCE.raiseFactor(entity.getUUID());
-        if (raise <= 0f) return;
-        this.rightArm.xRot = Mth.lerp(raise, this.rightArm.xRot, (float) (-Math.PI / 2.0));
-        this.rightArm.yRot = Mth.lerp(raise, this.rightArm.yRot, 0f);
-        this.rightArm.zRot = Mth.lerp(raise, this.rightArm.zRot, 0f);
-    }
 }

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

@@ -1,32 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.mixin.client;
-
-import com.cobblemon.mod.common.client.render.player.RecallArmAnimationTracker;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.entity.layers.ItemInHandLayer;
-import net.minecraft.world.entity.HumanoidArm;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.item.ItemDisplayContext;
-import net.minecraft.world.item.ItemStack;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
-
-@Mixin(ItemInHandLayer.class)
-public class ItemInHandLayerMixin {
-    @Inject(method = "renderArmWithItem", at = @At("HEAD"), cancellable = true)
-    private void cobblemon$hideRecallHandItem(LivingEntity entity, ItemStack itemStack, ItemDisplayContext itemDisplayContext, HumanoidArm humanoidArm, PoseStack poseStack, MultiBufferSource multiBufferSource, int light, CallbackInfo ci) {
-        if (humanoidArm == HumanoidArm.RIGHT && RecallArmAnimationTracker.INSTANCE.isRecalling(entity.getUUID())) {
-            ci.cancel();
-        }
-    }
-}

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

@@ -9,7 +9,6 @@
 package com.cobblemon.mod.common.mixin.client;
 
 import com.cobblemon.mod.common.OrientationControllable;
-import com.cobblemon.mod.common.client.render.player.FirstPersonRecallBallRenderer;
 import com.cobblemon.mod.common.item.PokedexItem;
 import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Minecraft;
@@ -32,9 +31,6 @@ public class ItemInHandRendererMixin {
         if (abstractClientPlayer.isUsingItem() && abstractClientPlayer.getUseItem().getItem() instanceof PokedexItem) {
             ci.cancel();
         }
-        else if (interactionHand == InteractionHand.MAIN_HAND && FirstPersonRecallBallRenderer.INSTANCE.render(poseStack, multiBufferSource, j, f)) {
-            ci.cancel();
-        }
         else if (abstractClientPlayer instanceof OrientationControllable controllable && controllable.getOrientationController().isActive()) {
 
         }

common/src/main/kotlin-templates/CobblemonBuildDetails.kt.peb

@@ -8,12 +8,8 @@ object CobblemonBuildDetails {
     const val VERSION = "{{ version }}"
     const val SNAPSHOT = {{ isSnapshot }}
 
-    // Read at runtime rather than templated in, so a new commit doesn't invalidate compiled code.
-    private val git = java.util.Properties().apply {
-        CobblemonBuildDetails::class.java.getResourceAsStream("/cobblemon-git.properties")?.use(::load)
-    }
-    @JvmField val GIT_COMMIT: String = git.getProperty("commit", "Not Specified")
-    @JvmField val BRANCH: String = git.getProperty("branch", "Not Specified")
+    const val GIT_COMMIT = "{{ gitCommit | default("Not Specified") }}"
+    const val BRANCH = "{{ branch | default("Not Specified") }}"
 
     fun smallCommitHash(): String {
         return this.GIT_COMMIT.substring(0, 7)

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common
 
+import com.cobblemon.mod.common.battles.TeamPreviewManager
+
 import com.cobblemon.mod.common.CobblemonBuildDetails.smallCommitHash
 import com.cobblemon.mod.common.api.Priority
 import com.cobblemon.mod.common.api.SeasonResolver
@@ -254,6 +256,7 @@ object Cobblemon {
         }
         PlatformEvents.SERVER_PLAYER_LOGOUT.subscribe {
             PCLinkManager.removeLink(it.player.uuid)
+            TeamPreviewManager.remove(it.player)
             BattleRegistry.onPlayerDisconnect(it.player)
             storage.onPlayerDisconnect(it.player)
             playerDataManager.onPlayerDisconnect(it.player)
@@ -450,6 +453,7 @@ object Cobblemon {
         }
 
         PlatformEvents.SERVER_STOPPED.subscribe {
+            TeamPreviewManager.clear()
             storage.unregisterAll(it.server.registryAccess())
             playerDataManager.saveAllStores()
             playerDataManager.saveExecutor.shutdown()

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

@@ -109,21 +109,4 @@ object CobblemonBlockEntities : PlatformRegistry<Registry<BlockEntityType<*>>, R
         "poke_snack",
         BlockEntityType.Builder.of(::PokeSnackBlockEntity, CobblemonBlocks.POKE_SNACK, CobblemonBlocks.POKE_CAKE).build(null)
     )
-
-    @JvmField
-    val TERRAIN_PLANT: BlockEntityType<TerrainPlantBlockEntity> = this.create(
-        "terrain_plant",
-        BlockEntityType.Builder.of(::TerrainPlantBlockEntity,
-            CobblemonBlocks.VOLTACONIA,
-            CobblemonBlocks.LUCIBELL,
-            CobblemonBlocks.VERDROOT
-        ).build(null)
-    )
-    @JvmField
-    val MISTLEAF_FLOWER: BlockEntityType<MistleafFlowerBlockEntity> = this.create(
-        "mistleaf",
-        BlockEntityType.Builder.of(::MistleafFlowerBlockEntity,
-            CobblemonBlocks.MISTLEAF
-        ).build(null)
-    )
 }

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

@@ -16,7 +16,6 @@ import com.cobblemon.mod.common.block.MintBlock.MintType
 import com.cobblemon.mod.common.block.campfirepot.CampfireBlock
 import com.cobblemon.mod.common.block.campfirepot.CampfirePotBlock
 import com.cobblemon.mod.common.block.chest.GildedChestBlock
-import com.cobblemon.mod.common.block.decor.*
 import com.cobblemon.mod.common.block.general.BaleBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationCarpetBlock
 import com.cobblemon.mod.common.block.general.HorizontalRotationalBlock
@@ -27,7 +26,6 @@ import com.cobblemon.mod.common.block.sign.CobblemonSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallHangingSignBlock
 import com.cobblemon.mod.common.block.sign.CobblemonWallSignBlock
 import com.cobblemon.mod.common.block.tmmachine.TMMachineBlock
-import com.cobblemon.mod.common.block.general.MintLitterBlock
 import com.cobblemon.mod.common.mixin.invoker.BlocksInvoker
 import com.cobblemon.mod.common.mixin.invoker.DoorBlockInvoker
 import com.cobblemon.mod.common.mixin.invoker.FireBlockInvoker
@@ -623,131 +621,37 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val WEAKNESS_POLICY = create("weakness_policy", WallAttachedDirectionalShapeBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_PAPER_LARGE_SOUNDS).mapColor(MapColor.NONE).noOcclusion().noCollission(), 14, 12, 1))
 
     @JvmField
-    val RING_TARGET = create("ring_target", RingTargetBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOD).mapColor(MapColor.NONE).noOcclusion().strength(0.125f)))
+    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val MAGNET = create("magnet", MagnetBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion().strength(0.075f)))
+    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
     @JvmField
-    val GALARICA_WREATH = create("galarica_wreath", GalaricaWreathBlock(BlockBehaviour.Properties.of().sound(SoundType.AZALEA_LEAVES).mapColor(MapColor.NONE).noOcclusion().noCollission()))
+    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
+    @JvmField
+    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
 
     @JvmField
-    val FLAME_ORB = create("flame_orb", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel{15}))
+    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val TOXIC_ORB = create("toxic_orb", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion()))
+    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val LIFE_ORB = create("life_orb", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel{7}))
+    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
     @JvmField
-    val LIGHT_BALL = create("light_ball", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().lightLevel{13}))
-    @JvmField
-    val SMOKE_BALL = create("smoke_ball", OrbBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion()))
+    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
 
     @JvmField
-    val KINGS_ROCK = create("kings_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.TUMBLESTONE_BLOCK_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.CENTERED_6x))
-
+    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val GALARICA_CUFF = create("galarica_cuff", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.AZALEA_LEAVES).mapColor(MapColor.NONE).noCollission().noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_10x4))
+    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val UNREMARKABLE_TEACUP = create("unremarkable_teacup", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEACUP))
+    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
     @JvmField
-    val MASTERPIECE_TEACUP = create("masterpiece_teacup", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEACUP))
+    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
     @JvmField
-    val CHIPPED_POT = create("chipped_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
-    @JvmField
-    val CRACKED_POT = create("cracked_pot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DECORATED_POT).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.TEAPOT))
-    @JvmField
-    val ELECTIRIZER = create("electirizer", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.IZER))
-    @JvmField
-    val MAGMARIZER = create("magmarizer", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.IZER))
-
-    @JvmField
-    val SACHET = create("sachet", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val METAL_POWDER = create("metal_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val QUICK_POWDER = create("quick_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val BRIGHT_POWDER = create("bright_powder", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion().lightLevel{3}, DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-    @JvmField
-    val SOFT_SAND = create("soft_sand", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_POWDER_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.POUCH))
-
-    @JvmField
-    val NEVER_MELT_ICE = create("never_melt_ice", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.GLASS).mapColor(MapColor.NONE).noOcclusion().friction(0.989F), DecorativeItemBlock.DecorativeItemBlockType.NEVERMELT))
-    @JvmField
-    val SCOPE_LENS = create("scope_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.SCOPE))
-    @JvmField
-    val WIDE_LENS = create("wide_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.WIDE))
-    @JvmField
-    val ZOOM_LENS = create("zoom_lens", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.COPPER).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.ZOOM))
-
-    @JvmField
-    val ICY_ROCK = create("icy_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val HEAT_ROCK = create("heat_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val SMOOTH_ROCK = create("smooth_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x4))
-    @JvmField
-    val DAMP_ROCK = create("damp_rock", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.DEEPSLATE).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.FLATTENED_8x6))
-    @JvmField
-    val DESTINY_KNOT = create("destiny_knot", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.WOOL).mapColor(MapColor.NONE).noOcclusion(), DecorativeItemBlock.DecorativeItemBlockType.KNOT))
-    @JvmField
-    val LUMINOUS_MOSS = create("luminous_moss", DecorativeItemBlock(BlockBehaviour.Properties.of().sound(SoundType.MOSS).mapColor(MapColor.NONE).noOcclusion().lightLevel{5}, DecorativeItemBlock.DecorativeItemBlockType.CENTERED_8x))
-
-    @JvmField
-    val METRONOME = create("metronome", ActivatableDecorationBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion(), ActivatableDecorationBlock.ActivatableDecorationBlockType.METRONOME))
-    @JvmField
-    val EJECT_BUTTON = create("eject_button", EjectButtonBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).pushReaction(PushReaction.DESTROY).noOcclusion().strength(0.125f), 40))
-
-    @JvmField
-    val LOADED_DICE = create("loaded_dice", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_DICE_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.DICE))
-    @JvmField
-    val IRON_BALL = create("iron_ball", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.IRON_BALL))
-    @JvmField
-    val METAL_COAT = create("metal_coat", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.METAL).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.METAL_COAT))
-    @JvmField
-    val UPGRADE = create("upgrade", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.UPGRADE))
-    @JvmField
-    val DUBIOUS_DISC = create("dubious_disc", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.UPGRADE))
-
-    @JvmField
-    val THROAT_SPRAY = create("throat_spray", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.THROAT_SPRAY))
-    @JvmField
-    val TERRAIN_EXTENDER = create("terrain_extender", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_METAL_CAN_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.EXTENDER))
-    @JvmField
-    val MOOMOO_MILK = create("moomoo_milk", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_JAR_GLASS_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.GLASS_BOTTLE))
-    @JvmField
-    val MEDICINAL_BREW = create("medicinal_brew", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_JAR_GLASS_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.GLASS_BOTTLE))
-
-    @JvmField
-    val FULL_HEAL = create("full_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val ANTIDOTE = create("antidote", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val AWAKENING = create("awakening", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val BURN_HEAL = create("burn_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val ICE_HEAL = create("ice_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-    @JvmField
-    val PARALYZE_HEAL = create("paralyze_heal", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.STATUS_RESTORE))
-
-    @JvmField
-    val ETHER = create("ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val MAX_ETHER = create("max_ether", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val ELIXIR = create("elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-    @JvmField
-    val MAX_ELIXIR = create("max_elixir", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.ETHER))
-
-    @JvmField
-    val POTION = create("potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val SUPER_POTION = create("super_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val HYPER_POTION = create("hyper_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.POTION))
-    @JvmField
-    val MAX_POTION = create("max_potion", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
-    @JvmField
-    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
+    val FULL_RESTORE = create("full_restore", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.MAX_POTION))
 
     @JvmField
     val DIRE_HIT = create("dire_hit", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
@@ -766,23 +670,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val X_SPEED = create("x_${Stats.SPEED.identifier.path}", StackableItemBlock(BlockBehaviour.Properties.of().sound(SoundType.CANDLE).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.BATTLE_ITEM))
 
-    @JvmField
-    val HP_UP = create("hp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PROTEIN = create("protein", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val IRON = create("iron", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val CARBOS = create("carbos", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val CALCIUM = create("calcium", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val ZINC = create("zinc", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PP_UP = create("pp_up", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-    @JvmField
-    val PP_MAX = create("pp_max", StackableItemBlock(BlockBehaviour.Properties.of().sound(CobblemonSounds.ITEM_BLOCK_BOTTLE_PILLS_SOUNDS).mapColor(MapColor.NONE).noOcclusion(), StackableItemBlock.StackableItemBlockType.VITAMIN))
-
     @JvmField
     val MONITOR = create("monitor", MonitorBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).requiresCorrectToolForDrops().strength(5.0F, 6.0F).lightLevel { if (it.getValue(MonitorBlock.SCREEN) != MonitorBlock.MonitorScreen.OFF) 13 else 0 }))
     @JvmField
@@ -798,7 +685,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val PC = create("pc", PCBlock(BlockBehaviour.Properties.of().mapColor(MapColor.METAL).sound(SoundType.METAL).pushReaction(PushReaction.BLOCK).strength(2F).noOcclusion().lightLevel { if ((it.getValue(PCBlock.ON) as Boolean) && (it.getValue(PCBlock.PART) == PCBlock.PCPart.TOP)) 13 else 0 }))
 
-    @JvmField
     val TM_MACHINE = create(
             "tm_machine",
         TMMachineBlock(
@@ -827,7 +713,7 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
 
     @JvmField
     val PASTURE = create("pasture", PastureBlock(BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_BROWN).sound(SoundType.WOOD).strength(2F).noOcclusion().pushReaction(PushReaction.BLOCK).lightLevel { if ((it.getValue(PastureBlock.ON) as Boolean) && (it.getValue(PastureBlock.PART) == PastureBlock.PasturePart.TOP)) 13 else 0 }))
-    @JvmField
+
     val RED_MINT = create("red_mint", MintBlock(MintType.RED, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_RED).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MINT_SOUNDS).pushReaction(PushReaction.DESTROY)))
     @JvmField
     val BLUE_MINT = create("blue_mint", MintBlock(MintType.BLUE, BlockBehaviour.Properties.of().mapColor(MapColor.COLOR_BLUE).noCollission().randomTicks().instabreak().sound(CobblemonSounds.MINT_SOUNDS).pushReaction(PushReaction.DESTROY)))
@@ -869,64 +755,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     @JvmField
     val POTTED_SACCHARINE_SAPLING = this.create("potted_saccharine_sapling", BlocksInvoker.createFlowerPotBlock(SACCHARINE_SAPLING))
 
-    @JvmField
-    val RED_MINT_LEAF_LITTER = this.mintLitter("red_mint_leaf_litter", MapColor.COLOR_RED)
-    @JvmField
-    val POTTED_RED_MINT = this.pottedPlant("potted_red_mint", RED_MINT_LEAF_LITTER)
-    @JvmField
-    val BLUE_MINT_LEAF_LITTER = this.mintLitter("blue_mint_leaf_litter", MapColor.COLOR_BLUE)
-    @JvmField
-    val POTTED_BLUE_MINT = this.pottedPlant("potted_blue_mint", BLUE_MINT_LEAF_LITTER)
-    @JvmField
-    val CYAN_MINT_LEAF_LITTER = this.mintLitter("cyan_mint_leaf_litter", MapColor.COLOR_CYAN)
-    @JvmField
-    val POTTED_CYAN_MINT = this.pottedPlant("potted_cyan_mint", CYAN_MINT_LEAF_LITTER)
-    @JvmField
-    val PINK_MINT_LEAF_LITTER = this.mintLitter("pink_mint_leaf_litter", MapColor.COLOR_PINK)
-    @JvmField
-    val POTTED_PINK_MINT = this.pottedPlant("potted_pink_mint", PINK_MINT_LEAF_LITTER)
-    @JvmField
-    val GREEN_MINT_LEAF_LITTER = this.mintLitter("green_mint_leaf_litter", MapColor.COLOR_GREEN)
-    @JvmField
-    val POTTED_GREEN_MINT = this.pottedPlant("potted_green_mint", GREEN_MINT_LEAF_LITTER)
-    @JvmField
-    val WHITE_MINT_LEAF_LITTER = this.mintLitter("white_mint_leaf_litter", MapColor.SNOW)
-    @JvmField
-    val POTTED_WHITE_MINT = this.pottedPlant("potted_white_mint", WHITE_MINT_LEAF_LITTER)
-
-    @JvmField
-    val LOBAILA = this.create("lobaila", LobailaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).offsetType(BlockBehaviour.OffsetType.XZ).ignitedByLava().pushReaction(PushReaction.DESTROY)))
-    @JvmField
-    val POMOHANA = this.create("pomohana", PomohanaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().instabreak().sound(SoundType.GRASS).ignitedByLava().pushReaction(PushReaction.DESTROY)))
-    @JvmField
-    val PAUVILLEA = this.create("pauvillea",PauvilleaFlowerBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY)))
-    @JvmField
-    val WISTENSU = this.create("wistensu", WistensuFlowerHeadBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY).lightLevel{11}))
-    @JvmField
-    val WISTENSU_VINE = this.create("wistensu_vine", WistensuFlowerVineBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).noCollission().sound(SoundType.GRASS).instabreak().ignitedByLava().pushReaction(PushReaction.DESTROY)))
-
-    @JvmField
-    val ELECTRIC_SEED = this.terrainSeed("electric_seed", TerrainSeedBlock.TerrainSeedType.ELECTRIC)
-    @JvmField
-    val PSYCHIC_SEED = this.terrainSeed("psychic_seed", TerrainSeedBlock.TerrainSeedType.PSYCHIC)
-    @JvmField
-    val MISTY_SEED = this.terrainSeed("misty_seed", TerrainSeedBlock.TerrainSeedType.MISTY)
-    @JvmField
-    val GRASSY_SEED = this.terrainSeed("grassy_seed", TerrainSeedBlock.TerrainSeedType.GRASSY)
-    @JvmField
-    val VOLTACONIA = this.terrainPlant("voltaconia") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 8 else 0 }
-    @JvmField
-    val VERDROOT = this.terrainPlant("verdroot") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 5 else 0 }
-    @JvmField
-    val LUCIBELL = this.terrainPlant("lucibell") { state -> if (state.getValue(TerrainPlantBlock.GLOWING)) 8 else 0 }
-    @JvmField
-    val MISTLEAF = this.create(
-        "mistleaf",
-        MistleafFlowerBlock {
-            if ((it.getValue(MistleafFlowerBlock.GLOWING) >= 1)) it.getValue(MistleafFlowerBlock.GLOWING) + 2 else 0
-        }
-    )
-
     @JvmField
     val HEARTY_GRAIN_BALE = this.create("hearty_grain_bale", BaleBlock(BlockBehaviour.Properties.of().mapColor(MapColor.PLANT).instrument(NoteBlockInstrument.BANJO).strength(0.5F).sound(CobblemonSounds.HEARTY_GRAIN_BALE_SOUNDS)))
     @JvmField
@@ -1103,147 +931,6 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     val YACHE_BERRY = this.berryBlock("yache")
     //val BINDING_SOIL = this.create("binding_soil", BindingSoilBlock(BlockBehaviour.Properties.of()))
 
-    @JvmField
-    val POTTED_AGUAV_BERRY = this.create("potted_aguav_berry", BlocksInvoker.createFlowerPotBlock(AGUAV_BERRY))
-    @JvmField
-    val POTTED_APICOT_BERRY = this.create("potted_apicot_berry", BlocksInvoker.createFlowerPotBlock(APICOT_BERRY))
-    @JvmField
-    val POTTED_ASPEAR_BERRY = this.create("potted_aspear_berry", BlocksInvoker.createFlowerPotBlock(ASPEAR_BERRY))
-    @JvmField
-    val POTTED_BABIRI_BERRY = this.create("potted_babiri_berry", BlocksInvoker.createFlowerPotBlock(BABIRI_BERRY))
-    @JvmField
-    val POTTED_BELUE_BERRY = this.create("potted_belue_berry", BlocksInvoker.createFlowerPotBlock(BELUE_BERRY))
-    @JvmField
-    val POTTED_BLUK_BERRY = this.create("potted_bluk_berry", BlocksInvoker.createFlowerPotBlock(BLUK_BERRY))
-    @JvmField
-    val POTTED_CHARTI_BERRY = this.create("potted_charti_berry", BlocksInvoker.createFlowerPotBlock(CHARTI_BERRY))
-    @JvmField
-    val POTTED_CHERI_BERRY = this.create("potted_cheri_berry", BlocksInvoker.createFlowerPotBlock(CHERI_BERRY))
-    @JvmField
-    val POTTED_CHESTO_BERRY = this.create("potted_chesto_berry", BlocksInvoker.createFlowerPotBlock(CHESTO_BERRY))
-    @JvmField
-    val POTTED_CHILAN_BERRY = this.create("potted_chilan_berry", BlocksInvoker.createFlowerPotBlock(CHILAN_BERRY))
-    @JvmField
-    val POTTED_CHOPLE_BERRY = this.create("potted_chople_berry", BlocksInvoker.createFlowerPotBlock(CHOPLE_BERRY))
-    @JvmField
-    val POTTED_COBA_BERRY = this.create("potted_coba_berry", BlocksInvoker.createFlowerPotBlock(COBA_BERRY))
-    @JvmField
-    val POTTED_COLBUR_BERRY = this.create("potted_colbur_berry", BlocksInvoker.createFlowerPotBlock(COLBUR_BERRY))
-    @JvmField
-    val POTTED_CORNN_BERRY = this.create("potted_cornn_berry", BlocksInvoker.createFlowerPotBlock(CORNN_BERRY))
-    @JvmField
-    val POTTED_CUSTAP_BERRY = this.create("potted_custap_berry", BlocksInvoker.createFlowerPotBlock(CUSTAP_BERRY))
-    @JvmField
-    val POTTED_DURIN_BERRY = this.create("potted_durin_berry", BlocksInvoker.createFlowerPotBlock(DURIN_BERRY))
-    @JvmField
-    val POTTED_EGGANT_BERRY = this.create("potted_eggant_berry", BlocksInvoker.createFlowerPotBlock(EGGANT_BERRY))
-    @JvmField
-    val POTTED_ENIGMA_BERRY = this.create("potted_enigma_berry", BlocksInvoker.createFlowerPotBlock(ENIGMA_BERRY))
-    @JvmField
-    val POTTED_FIGY_BERRY = this.create("potted_figy_berry", BlocksInvoker.createFlowerPotBlock(FIGY_BERRY))
-    @JvmField
-    val POTTED_GANLON_BERRY = this.create("potted_ganlon_berry", BlocksInvoker.createFlowerPotBlock(GANLON_BERRY))
-    @JvmField
-    val POTTED_GREPA_BERRY = this.create("potted_grepa_berry", BlocksInvoker.createFlowerPotBlock(GREPA_BERRY))
-    @JvmField
-    val POTTED_HABAN_BERRY = this.create("potted_haban_berry", BlocksInvoker.createFlowerPotBlock(HABAN_BERRY))
-    @JvmField
-    val POTTED_HONDEW_BERRY = this.create("potted_hondew_berry", BlocksInvoker.createFlowerPotBlock(HONDEW_BERRY))
-    @JvmField
-    val POTTED_HOPO_BERRY = this.create("potted_hopo_berry", BlocksInvoker.createFlowerPotBlock(HOPO_BERRY))
-    @JvmField
-    val POTTED_IAPAPA_BERRY = this.create("potted_iapapa_berry", BlocksInvoker.createFlowerPotBlock(IAPAPA_BERRY))
-    @JvmField
-    val POTTED_JABOCA_BERRY = this.create("potted_jaboca_berry", BlocksInvoker.createFlowerPotBlock(JABOCA_BERRY))
-    @JvmField
-    val POTTED_KASIB_BERRY = this.create("potted_kasib_berry", BlocksInvoker.createFlowerPotBlock(KASIB_BERRY))
-    @JvmField
-    val POTTED_KEBIA_BERRY = this.create("potted_kebia_berry", BlocksInvoker.createFlowerPotBlock(KEBIA_BERRY))
-    @JvmField
-    val POTTED_KEE_BERRY = this.create("potted_kee_berry", BlocksInvoker.createFlowerPotBlock(KEE_BERRY))
-    @JvmField
-    val POTTED_KELPSY_BERRY = this.create("potted_kelpsy_berry", BlocksInvoker.createFlowerPotBlock(KELPSY_BERRY))
-    @JvmField
-    val POTTED_LANSAT_BERRY = this.create("potted_lansat_berry", BlocksInvoker.createFlowerPotBlock(LANSAT_BERRY))
-    @JvmField
-    val POTTED_LEPPA_BERRY = this.create("potted_leppa_berry", BlocksInvoker.createFlowerPotBlock(LEPPA_BERRY))
-    @JvmField
-    val POTTED_LIECHI_BERRY = this.create("potted_liechi_berry", BlocksInvoker.createFlowerPotBlock(LIECHI_BERRY))
-    @JvmField
-    val POTTED_LUM_BERRY = this.create("potted_lum_berry", BlocksInvoker.createFlowerPotBlock(LUM_BERRY))
-    @JvmField
-    val POTTED_MAGO_BERRY = this.create("potted_mago_berry", BlocksInvoker.createFlowerPotBlock(MAGO_BERRY))
-    @JvmField
-    val POTTED_MAGOST_BERRY = this.create("potted_magost_berry", BlocksInvoker.createFlowerPotBlock(MAGOST_BERRY))
-    @JvmField
-    val POTTED_MARANGA_BERRY = this.create("potted_maranga_berry", BlocksInvoker.createFlowerPotBlock(MARANGA_BERRY))
-    @JvmField
-    val POTTED_MICLE_BERRY = this.create("potted_micle_berry", BlocksInvoker.createFlowerPotBlock(MICLE_BERRY))
-    @JvmField
-    val POTTED_NANAB_BERRY = this.create("potted_nanab_berry", BlocksInvoker.createFlowerPotBlock(NANAB_BERRY))
-    @JvmField
-    val POTTED_NOMEL_BERRY = this.create("potted_nomel_berry", BlocksInvoker.createFlowerPotBlock(NOMEL_BERRY))
-    @JvmField
-    val POTTED_OCCA_BERRY = this.create("potted_occa_berry", BlocksInvoker.createFlowerPotBlock(OCCA_BERRY))
-    @JvmField
-    val POTTED_ORAN_BERRY = this.create("potted_oran_berry", BlocksInvoker.createFlowerPotBlock(ORAN_BERRY))
-    @JvmField
-    val POTTED_PAMTRE_BERRY = this.create("potted_pamtre_berry", BlocksInvoker.createFlowerPotBlock(PAMTRE_BERRY))
-    @JvmField
-    val POTTED_PASSHO_BERRY = this.create("potted_passho_berry", BlocksInvoker.createFlowerPotBlock(PASSHO_BERRY))
-    @JvmField
-    val POTTED_PAYAPA_BERRY = this.create("potted_payapa_berry", BlocksInvoker.createFlowerPotBlock(PAYAPA_BERRY))
-    @JvmField
-    val POTTED_PECHA_BERRY = this.create("potted_pecha_berry", BlocksInvoker.createFlowerPotBlock(PECHA_BERRY))
-    @JvmField
-    val POTTED_PERSIM_BERRY = this.create("potted_persim_berry", BlocksInvoker.createFlowerPotBlock(PERSIM_BERRY))
-    @JvmField
-    val POTTED_PETAYA_BERRY = this.create("potted_petaya_berry", BlocksInvoker.createFlowerPotBlock(PETAYA_BERRY))
-    @JvmField
-    val POTTED_PINAP_BERRY = this.create("potted_pinap_berry", BlocksInvoker.createFlowerPotBlock(PINAP_BERRY))
-    @JvmField
-    val POTTED_POMEG_BERRY = this.create("potted_pomeg_berry", BlocksInvoker.createFlowerPotBlock(POMEG_BERRY))
-    @JvmField
-    val POTTED_QUALOT_BERRY = this.create("potted_qualot_berry", BlocksInvoker.createFlowerPotBlock(QUALOT_BERRY))
-    @JvmField
-    val POTTED_RABUTA_BERRY = this.create("potted_rabuta_berry", BlocksInvoker.createFlowerPotBlock(RABUTA_BERRY))
-    @JvmField
-    val POTTED_RAWST_BERRY = this.create("potted_rawst_berry", BlocksInvoker.createFlowerPotBlock(RAWST_BERRY))
-    @JvmField
-    val POTTED_RAZZ_BERRY = this.create("potted_razz_berry", BlocksInvoker.createFlowerPotBlock(RAZZ_BERRY))
-    @JvmField
-    val POTTED_RINDO_BERRY = this.create("potted_rindo_berry", BlocksInvoker.createFlowerPotBlock(RINDO_BERRY))
-    @JvmField
-    val POTTED_ROSELI_BERRY = this.create("potted_roseli_berry", BlocksInvoker.createFlowerPotBlock(ROSELI_BERRY))
-    @JvmField
-    val POTTED_ROWAP_BERRY = this.create("potted_rowap_berry", BlocksInvoker.createFlowerPotBlock(ROWAP_BERRY))
-    @JvmField
-    val POTTED_SALAC_BERRY = this.create("potted_salac_berry", BlocksInvoker.createFlowerPotBlock(SALAC_BERRY))
-    @JvmField
-    val POTTED_SHUCA_BERRY = this.create("potted_shuca_berry", BlocksInvoker.createFlowerPotBlock(SHUCA_BERRY))
-    @JvmField
-    val POTTED_SITRUS_BERRY = this.create("potted_sitrus_berry", BlocksInvoker.createFlowerPotBlock(SITRUS_BERRY))
-    @JvmField
-    val POTTED_SPELON_BERRY = this.create("potted_spelon_berry", BlocksInvoker.createFlowerPotBlock(SPELON_BERRY))
-    @JvmField
-    val POTTED_STARF_BERRY = this.create("potted_starf_berry", BlocksInvoker.createFlowerPotBlock(STARF_BERRY))
-    @JvmField
-    val POTTED_TAMATO_BERRY = this.create("potted_tamato_berry", BlocksInvoker.createFlowerPotBlock(TAMATO_BERRY))
-    @JvmField
-    val POTTED_TANGA_BERRY = this.create("potted_tanga_berry", BlocksInvoker.createFlowerPotBlock(TANGA_BERRY))
-    @JvmField
-    val POTTED_TOUGA_BERRY = this.create("potted_touga_berry", BlocksInvoker.createFlowerPotBlock(TOUGA_BERRY))
-    @JvmField
-    val POTTED_WACAN_BERRY = this.create("potted_wacan_berry", BlocksInvoker.createFlowerPotBlock(WACAN_BERRY))
-    @JvmField
-    val POTTED_WATMEL_BERRY = this.create("potted_watmel_berry", BlocksInvoker.createFlowerPotBlock(WATMEL_BERRY))
-    @JvmField
-    val POTTED_WEPEAR_BERRY = this.create("potted_wepear_berry", BlocksInvoker.createFlowerPotBlock(WEPEAR_BERRY))
-    @JvmField
-    val POTTED_WIKI_BERRY = this.create("potted_wiki_berry", BlocksInvoker.createFlowerPotBlock(WIKI_BERRY))
-    @JvmField
-    val POTTED_YACHE_BERRY = this.create("potted_yache_berry", BlocksInvoker.createFlowerPotBlock(YACHE_BERRY))
-
     init {
         /**
          * Makes all blocks in array flammable by adding them to FireBlock's flammableRegistry.
@@ -1345,48 +1032,4 @@ object CobblemonBlocks : PlatformRegistry<Registry<Block>, ResourceKey<Registry<
     }
 
     fun typeGemClusters() = typeGemClusters.toMap()
-
-    private fun pottedPlant(name: String, flower: Block) = this.create(name, BlocksInvoker.createFlowerPotBlock(flower))
-
-    private fun mintLitter(name: String, color: MapColor) = this.create(
-        name,
-        MintLitterBlock(
-            BlockBehaviour.Properties.of()
-                .sound(CobblemonSounds.MINT_SOUNDS)
-                .mapColor(color)
-                .noOcclusion()
-                .noCollission()
-                .pushReaction(PushReaction.DESTROY)
-        )
-    )
-
-    private fun terrainSeed(name: String, type: TerrainSeedBlock.TerrainSeedType) = this.create(
-        name,
-        TerrainSeedBlock(
-            type,
-            BlockBehaviour.Properties.of()
-                .pushReaction(PushReaction.DESTROY)
-                .ignitedByLava()
-                .mapColor(MapColor.PLANT)
-                .offsetType(BlockBehaviour.OffsetType.XZ)
-                .noCollission()
-                .randomTicks()
-                .instabreak()
-        )
-    )
-
-    private fun terrainPlant(name: String, lightLevel: (BlockState) -> Int) = this.create(
-        name,
-        TerrainPlantBlock(
-            BlockBehaviour.Properties.of()
-                .mapColor(MapColor.PLANT)
-                .noCollission()
-                .instabreak()
-                .sound(SoundType.GRASS)
-                .offsetType(BlockBehaviour.OffsetType.XZ)
-                .ignitedByLava()
-                .pushReaction(PushReaction.DESTROY)
-                .lightLevel(lightLevel)
-        )
-    )
 }

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

@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.mojang.brigadier.arguments.ArgumentType
 import kotlin.reflect.KClass
 import net.minecraft.commands.synchronization.ArgumentTypeInfo
-import net.minecraft.core.HolderLookup
 import net.minecraft.resources.ResourceKey
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.MinecraftServer
@@ -169,16 +168,12 @@ interface CobblemonImplementation {
      * TODO
      *
      * @param identifier
-     * @param reloaderFactory
+     * @param reloader
      * @param type
      * @param dependencies
      */
-    fun registerResourceReloader(
-        identifier: ResourceLocation,
-        type: PackType,
-        dependencies: Collection<ResourceLocation>,
-        reloaderFactory: (HolderLookup.Provider) -> PreparableReloadListener
-    )
+    fun registerResourceReloader(identifier: ResourceLocation, reloader: PreparableReloadListener, type: PackType, dependencies: Collection<ResourceLocation>)
+
     /**
      * TODO
      *

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

@@ -472,18 +472,18 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     // Evolution items
     @JvmField val LINK_CABLE = create("link_cable", LinkCableItem())
     @JvmField val DRAGON_SCALE = noSettingsItem("dragon_scale")
-    @JvmField val METAL_COAT = itemNameBlockItem("metal_coat", CobblemonBlocks.METAL_COAT)
-    @JvmField val UPGRADE = itemNameBlockItem("upgrade", CobblemonBlocks.UPGRADE)
-    @JvmField val DUBIOUS_DISC = itemNameBlockItem("dubious_disc", CobblemonBlocks.DUBIOUS_DISC)
+    @JvmField val METAL_COAT = noSettingsItem("metal_coat")
+    @JvmField val UPGRADE = noSettingsItem("upgrade")
+    @JvmField val DUBIOUS_DISC = noSettingsItem("dubious_disc")
     @JvmField val DEEP_SEA_SCALE = noSettingsItem("deep_sea_scale")
     @JvmField val DEEP_SEA_TOOTH = noSettingsItem("deep_sea_tooth")
-    @JvmField val ELECTIRIZER = itemNameBlockItem("electirizer", CobblemonBlocks.ELECTIRIZER)
-    @JvmField val MAGMARIZER = itemNameBlockItem("magmarizer", CobblemonBlocks.MAGMARIZER)
+    @JvmField val ELECTIRIZER = noSettingsItem("electirizer")
+    @JvmField val MAGMARIZER = noSettingsItem("magmarizer")
     @JvmField val OVAL_STONE = noSettingsItem("oval_stone")
     @JvmField val PROTECTOR = noSettingsItem("protector")
     @JvmField val REAPER_CLOTH = noSettingsItem("reaper_cloth")
     @JvmField val PRISM_SCALE = noSettingsItem("prism_scale")
-    @JvmField val SACHET = itemNameBlockItem("sachet", CobblemonBlocks.SACHET)
+    @JvmField val SACHET = noSettingsItem("sachet")
     @JvmField val WHIPPED_DREAM = create("whipped_dream", foodItem(8, 0.3f))
     @JvmField val STRAWBERRY_SWEET = create("strawberry_sweet", foodItem(6, 0.125f))
     @JvmField val LOVE_SWEET = create("love_sweet", foodItem(6, 0.125f))
@@ -492,20 +492,22 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField val FLOWER_SWEET = create("flower_sweet", foodItem(6, 0.125f))
     @JvmField val STAR_SWEET = create("star_sweet", foodItem(6, 0.125f))
     @JvmField val RIBBON_SWEET = create("ribbon_sweet", foodItem(6, 0.125f))
-    @JvmField val CHIPPED_POT = itemNameBlockItem("chipped_pot", CobblemonBlocks.CHIPPED_POT)
-    @JvmField val CRACKED_POT = itemNameBlockItem("cracked_pot", CobblemonBlocks.CRACKED_POT)
-    @JvmField val MASTERPIECE_TEACUP = itemNameBlockItem("masterpiece_teacup", CobblemonBlocks.MASTERPIECE_TEACUP)
-    @JvmField val UNREMARKABLE_TEACUP = itemNameBlockItem("unremarkable_teacup", CobblemonBlocks.UNREMARKABLE_TEACUP)
+    @JvmField val CHIPPED_POT = noSettingsItem("chipped_pot")
+    @JvmField val CRACKED_POT = noSettingsItem("cracked_pot")
+    @JvmField val MASTERPIECE_TEACUP = noSettingsItem("masterpiece_teacup")
+    @JvmField val UNREMARKABLE_TEACUP = noSettingsItem("unremarkable_teacup")
     @JvmField val SWEET_APPLE = compostableItem("sweet_apple", foodItem(4, 0.3f), 0.65f)
     @JvmField val TART_APPLE = compostableItem("tart_apple", foodItem(4, 0.3f), 0.65f)
     @JvmField val SYRUPY_APPLE = compostableItem("syrupy_apple", foodItem(4, 0.3f), 0.65f)
-    @JvmField val GALARICA_CUFF = itemNameBlockItem("galarica_cuff", CobblemonBlocks.GALARICA_CUFF)
+    @JvmField val GALARICA_CUFF = noSettingsItem("galarica_cuff")
+    @JvmField val GALARICA_WREATH = noSettingsItem("galarica_wreath")
     @JvmField val BLACK_AUGURITE = noSettingsItem("black_augurite")
     @JvmField val PEAT_BLOCK = noSettingsItem("peat_block")
     @JvmField val RAZOR_CLAW = noSettingsItem("razor_claw")
     @JvmField val RAZOR_FANG = noSettingsItem("razor_fang")
     @JvmField val AUSPICIOUS_ARMOR = heldItem("auspicious_armor")
     @JvmField val MALICIOUS_ARMOR = heldItem("malicious_armor")
+    @JvmField val SHELL_HELMET = heldItem("shell_helmet")
     @JvmField val METAL_ALLOY = noSettingsItem("metal_alloy")
     @JvmField val SCROLL_OF_DARKNESS = noSettingsItem("scroll_of_darkness")
     @JvmField val SCROLL_OF_WATERS = noSettingsItem("scroll_of_waters")
@@ -649,17 +651,17 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val EXPERIENCE_CANDY_XL = candyItem("exp_candy_xl") { _, _ -> CandyItem.DEFAULT_XL_CANDY_YIELD }
     @JvmField
-    val CALCIUM = create("calcium", VitaminItem(Stats.SPECIAL_ATTACK, CobblemonBlocks.CALCIUM))
+    val CALCIUM = create("calcium", VitaminItem(Stats.SPECIAL_ATTACK))
     @JvmField
-    val CARBOS = create("carbos", VitaminItem(Stats.SPEED, CobblemonBlocks.CARBOS))
+    val CARBOS = create("carbos", VitaminItem(Stats.SPEED))
     @JvmField
-    val HP_UP = create("hp_up", VitaminItem(Stats.HP, CobblemonBlocks.HP_UP))
+    val HP_UP = create("hp_up", VitaminItem(Stats.HP))
     @JvmField
-    val IRON = create("iron", VitaminItem(Stats.DEFENCE, CobblemonBlocks.IRON))
+    val IRON = create("iron", VitaminItem(Stats.DEFENCE))
     @JvmField
-    val PROTEIN = create("protein", VitaminItem(Stats.ATTACK, CobblemonBlocks.PROTEIN))
+    val PROTEIN = create("protein", VitaminItem(Stats.ATTACK))
     @JvmField
-    val ZINC = create("zinc", VitaminItem(Stats.SPECIAL_DEFENCE, CobblemonBlocks.ZINC))
+    val ZINC = create("zinc", VitaminItem(Stats.SPECIAL_DEFENCE))
     @JvmField
     val HEALTH_MOCHI = create("health_mochi", MochiItem(Stats.HP))
     @JvmField
@@ -711,7 +713,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val PEP_UP_FLOWER = compostableBlockItem("pep_up_flower", CobblemonBlocks.PEP_UP_FLOWER)
     @JvmField
-    val MEDICINAL_BREW = itemNameBlockItem("medicinal_brew", CobblemonBlocks.MEDICINAL_BREW)
+    val MEDICINAL_BREW = noSettingsItem("medicinal_brew")
     @JvmField
     val REMEDY = compostableItem("remedy", RemedyItem(RemedyItem.NORMAL), 0.65f)
     @JvmField
@@ -719,7 +721,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SUPERB_REMEDY = compostableItem("superb_remedy", RemedyItem(RemedyItem.SUPERB), 1f)
     @JvmField
-    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16)), CobblemonBlocks.MOOMOO_MILK))
+    val MOOMOO_MILK = create("moomoo_milk", MoomooMilk(Item.Properties().craftRemainder(Items.GLASS_BOTTLE).stacksTo((16))))
 
     @JvmField
     val POTION = create("potion", PotionItem(PotionType.POTION, CobblemonBlocks.POTION))
@@ -741,34 +743,34 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val MAX_REVIVE = create("max_revive", ReviveItem(max = true))
     @JvmField
-    val PP_UP = create("pp_up", PPUpItem(1, CobblemonBlocks.PP_UP))
+    val PP_UP = create("pp_up", PPUpItem(1))
     @JvmField
-    val PP_MAX = create("pp_max", PPUpItem(3, CobblemonBlocks.PP_MAX))
+    val PP_MAX = create("pp_max", PPUpItem(3))
 
     @JvmField
     val RED_MINT_SEEDS = mintSeed("red", MintType.RED.getCropBlock())
     @JvmField
-    val RED_MINT_LEAF = compostableItemNameBlockItem("red_mint_leaf", CobblemonBlocks.RED_MINT_LEAF_LITTER, 0.50f)
+    val RED_MINT_LEAF = mintLeaf("red", MintLeafItem(MintType.RED))
     @JvmField
     val BLUE_MINT_SEEDS = mintSeed("blue", MintType.BLUE.getCropBlock())
     @JvmField
-    val BLUE_MINT_LEAF = compostableItemNameBlockItem("blue_mint_leaf", CobblemonBlocks.BLUE_MINT_LEAF_LITTER, 0.50f)
+    val BLUE_MINT_LEAF = mintLeaf("blue", MintLeafItem(MintType.BLUE))
     @JvmField
     val CYAN_MINT_SEEDS = mintSeed("cyan", MintType.CYAN.getCropBlock())
     @JvmField
-    val CYAN_MINT_LEAF = compostableItemNameBlockItem("cyan_mint_leaf", CobblemonBlocks.CYAN_MINT_LEAF_LITTER, 0.50f)
+    val CYAN_MINT_LEAF = mintLeaf("cyan", MintLeafItem(MintType.CYAN))
     @JvmField
     val PINK_MINT_SEEDS = mintSeed("pink", MintType.PINK.getCropBlock())
     @JvmField
-    val PINK_MINT_LEAF = compostableItemNameBlockItem("pink_mint_leaf", CobblemonBlocks.PINK_MINT_LEAF_LITTER, 0.50f)
+    val PINK_MINT_LEAF = mintLeaf("pink", MintLeafItem(MintType.PINK))
     @JvmField
     val GREEN_MINT_SEEDS = mintSeed("green", MintType.GREEN.getCropBlock())
     @JvmField
-    val GREEN_MINT_LEAF = compostableItemNameBlockItem("green_mint_leaf", CobblemonBlocks.GREEN_MINT_LEAF_LITTER, 0.50f)
+    val GREEN_MINT_LEAF = mintLeaf("green", MintLeafItem(MintType.GREEN))
     @JvmField
     val WHITE_MINT_SEEDS = mintSeed("white", MintType.WHITE.getCropBlock())
     @JvmField
-    val WHITE_MINT_LEAF = compostableItemNameBlockItem("white_mint_leaf", CobblemonBlocks.WHITE_MINT_LEAF_LITTER, 0.50f)
+    val WHITE_MINT_LEAF = mintLeaf("white", MintLeafItem(MintType.WHITE))
 
     val mints = mutableMapOf<String, MintItem>()
 
@@ -920,18 +922,11 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField val CHOICE_SPECS = wearableItem("choice_specs")
     @JvmField val EXP_SHARE = wearableItem("exp_share")
     @JvmField val FOCUS_BAND = wearableItem("focus_band")
-    @JvmField val KINGS_ROCK = wearableBlockItem("kings_rock", CobblemonBlocks.KINGS_ROCK)
-    @JvmField val NEVER_MELT_ICE = wearableBlockItem("never_melt_ice", CobblemonBlocks.NEVER_MELT_ICE)
+    @JvmField val KINGS_ROCK = wearableItem("kings_rock")
     @JvmField val MUSCLE_BAND = wearableItem("muscle_band")
     @JvmField val ROCKY_HELMET = wearableItem("rocky_helmet")
     @JvmField val SAFETY_GOGGLES = wearableItem("safety_goggles")
     @JvmField val WISE_GLASSES = wearableItem("wise_glasses")
-    @JvmField val SHARP_BEAK = wearableItem("sharp_beak")
-    @JvmField val COVERT_CLOAK = wearableItem("covert_cloak")
-    @JvmField val SHELL_HELMET = wearableItem("shell_helmet")
-    @JvmField val GALARICA_WREATH = wearableBlockItem("galarica_wreath", CobblemonBlocks.GALARICA_WREATH)
-    @JvmField val CLEANSE_TAG = wearableBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
-    @JvmField val SPELL_TAG = wearableBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
 
     // Held Items
     @JvmField
@@ -959,17 +954,21 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val CHOICE_SCARF = heldItem("choice_scarf")
     @JvmField
+    val CLEANSE_TAG = itemNameBlockItem("cleanse_tag", CobblemonBlocks.CLEANSE_TAG)
+    @JvmField
     val CLEAR_AMULET = heldItem("clear_amulet")
     @JvmField
-    val DESTINY_KNOT = itemNameBlockItem("destiny_knot", CobblemonBlocks.DESTINY_KNOT)
+    val COVERT_CLOAK = heldItem("covert_cloak")
+    @JvmField
+    val DESTINY_KNOT = heldItem("destiny_knot")
     @JvmField
     val DRAGON_FANG = heldItem("dragon_fang")
     @JvmField
-    val EJECT_BUTTON = itemNameBlockItem("eject_button", CobblemonBlocks.EJECT_BUTTON)
+    val EJECT_BUTTON = heldItem("eject_button")
     @JvmField
     val EJECT_PACK = heldItem("eject_pack")
     @JvmField
-    val ELECTRIC_SEED = itemNameBlockItem("electric_seed", CobblemonBlocks.ELECTRIC_SEED)
+    val ELECTRIC_SEED = heldItem("electric_seed")
     @JvmField
     val EVERSTONE = heldItem("everstone")
     @JvmField
@@ -979,13 +978,13 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val FAIRY_FEATHER = heldItem("fairy_feather")
     @JvmField
-    val FLAME_ORB = itemNameBlockItem("flame_orb", CobblemonBlocks.FLAME_ORB)
+    val FLAME_ORB = heldItem("flame_orb")
     @JvmField
     val FLOAT_STONE = heldItem("float_stone")
     @JvmField
     val FOCUS_SASH = heldItem("focus_sash")
     @JvmField
-    val GRASSY_SEED = itemNameBlockItem("grassy_seed", CobblemonBlocks.GRASSY_SEED)
+    val GRASSY_SEED = heldItem("grassy_seed")
     @JvmField
     val GRIP_CLAW = heldItem("grip_claw")
     @JvmField
@@ -993,32 +992,34 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val HEAVY_DUTY_BOOTS = heldItem("heavy_duty_boots")
     @JvmField
-    val IRON_BALL = itemNameBlockItem("iron_ball", CobblemonBlocks.IRON_BALL)
+    val IRON_BALL = heldItem("iron_ball")
     @JvmField
     val LAGGING_TAIL = heldItem("lagging_tail")
     @JvmField
     val LEFTOVERS = compostableHeldItem("leftovers", null, 0.50f)
     @JvmField
-    val LIFE_ORB = itemNameBlockItem("life_orb", CobblemonBlocks.LIFE_ORB)
+    val LIFE_ORB = heldItem("life_orb")
     @JvmField
-    val LIGHT_BALL = itemNameBlockItem("light_ball", CobblemonBlocks.LIGHT_BALL)
+    val LIGHT_BALL = heldItem("light_ball")
     @JvmField
     val LIGHT_CLAY = heldItem("light_clay")
     @JvmField
-    val LOADED_DICE = itemNameBlockItem("loaded_dice", CobblemonBlocks.LOADED_DICE)
+    val LOADED_DICE = heldItem("loaded_dice")
     @JvmField
     val LUCKY_EGG = heldItem("lucky_egg")
     @JvmField
-    val LUMINOUS_MOSS = itemNameBlockItem("luminous_moss", CobblemonBlocks.LUMINOUS_MOSS)
+    val LUMINOUS_MOSS = heldItem("luminous_moss")
     @JvmField
-    val MAGNET = itemNameBlockItem("magnet", CobblemonBlocks.MAGNET)
+    val MAGNET = heldItem("magnet")
     @JvmField
-    val METRONOME = itemNameBlockItem("metronome", CobblemonBlocks.METRONOME)
+    val METRONOME = heldItem("metronome")
     @JvmField
     val MIRACLE_SEED = heldItem("miracle_seed")
     @JvmField
     val MYSTIC_WATER = heldItem("mystic_water")
     @JvmField
+    val NEVER_MELT_ICE = heldItem("never_melt_ice")
+    @JvmField
     val POISON_BARB = heldItem("poison_barb")
     @JvmField
     val POWER_ANKLET = heldItem("power_anklet")
@@ -1033,7 +1034,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val POWER_WEIGHT = heldItem("power_weight")
     @JvmField
-    val PSYCHIC_SEED = itemNameBlockItem("psychic_seed", CobblemonBlocks.PSYCHIC_SEED)
+    val PSYCHIC_SEED = heldItem("psychic_seed")
     @JvmField
     val PROTECTIVE_PADS = heldItem("protective_pads")
     @JvmField
@@ -1043,11 +1044,13 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val RED_CARD = heldItem("red_card")
     @JvmField
-    val RING_TARGET = itemNameBlockItem("ring_target", CobblemonBlocks.RING_TARGET)
+    val RING_TARGET = heldItem("ring_target")
     @JvmField
     val ROOM_SERVICE = heldItem("room_service")
     @JvmField
-    val SCOPE_LENS = itemNameBlockItem("scope_lens", CobblemonBlocks.SCOPE_LENS)
+    val SCOPE_LENS = heldItem("scope_lens")
+    @JvmField
+    val SHARP_BEAK = heldItem("sharp_beak")
     @JvmField
     val SHED_SHELL = heldItem("shed_shell")
     @JvmField
@@ -1057,19 +1060,21 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val SILVER_POWDER = heldItem("silver_powder")
     @JvmField
-    val SOFT_SAND = itemNameBlockItem("soft_sand", CobblemonBlocks.SOFT_SAND)
+    val SOFT_SAND = heldItem("soft_sand")
     @JvmField
-    val SMOKE_BALL = itemNameBlockItem("smoke_ball", CobblemonBlocks.SMOKE_BALL)
+    val SPELL_TAG = itemNameBlockItem("spell_tag", CobblemonBlocks.SPELL_TAG)
+    @JvmField
+    val SMOKE_BALL = heldItem("smoke_ball")
     @JvmField
     val SOOTHE_BELL = heldItem("soothe_bell")
     @JvmField
     val STICKY_BARB = heldItem("sticky_barb")
     @JvmField
-    val TERRAIN_EXTENDER = itemNameBlockItem("terrain_extender", CobblemonBlocks.TERRAIN_EXTENDER)
+    val TERRAIN_EXTENDER = heldItem("terrain_extender")
     @JvmField
-    val THROAT_SPRAY = itemNameBlockItem("throat_spray", CobblemonBlocks.THROAT_SPRAY)
+    val THROAT_SPRAY = heldItem("throat_spray")
     @JvmField
-    val TOXIC_ORB = itemNameBlockItem("toxic_orb", CobblemonBlocks.TOXIC_ORB)
+    val TOXIC_ORB = heldItem("toxic_orb")
     @JvmField
     val TWISTED_SPOON = heldItem("twisted_spoon")
     @JvmField
@@ -1077,33 +1082,33 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     @JvmField
     val WEAKNESS_POLICY = itemNameBlockItem("weakness_policy", CobblemonBlocks.WEAKNESS_POLICY)
     @JvmField
-    val WIDE_LENS = itemNameBlockItem("wide_lens", CobblemonBlocks.WIDE_LENS)
+    val WIDE_LENS = heldItem("wide_lens")
     @JvmField
-    val ZOOM_LENS = itemNameBlockItem("zoom_lens", CobblemonBlocks.ZOOM_LENS)
+    val ZOOM_LENS = heldItem("zoom_lens")
     @JvmField
     val MENTAL_HERB = compostableHeldItem("mental_herb", null, 0.85F)
     @JvmField
     val MIRROR_HERB = compostableHeldItem("mirror_herb", null, 0.85F)
     @JvmField
-    val MISTY_SEED = itemNameBlockItem("misty_seed", CobblemonBlocks.MISTY_SEED)
+    val MISTY_SEED = heldItem("misty_seed")
     @JvmField
     val POWER_HERB = compostableHeldItem("power_herb", null, 0.85F)
     @JvmField
     val WHITE_HERB = compostableHeldItem("white_herb", null, 0.85F)
     @JvmField
-    val BRIGHT_POWDER = glowItem("bright_powder", CobblemonBlocks.BRIGHT_POWDER)
+    val BRIGHT_POWDER = heldItem("bright_powder")
     @JvmField
-    val METAL_POWDER = itemNameBlockItem("metal_powder", CobblemonBlocks.METAL_POWDER)
+    val METAL_POWDER = heldItem("metal_powder")
     @JvmField
-    val QUICK_POWDER = itemNameBlockItem("quick_powder", CobblemonBlocks.QUICK_POWDER)
+    val QUICK_POWDER = heldItem("quick_powder")
     @JvmField
-    val DAMP_ROCK = itemNameBlockItem("damp_rock", CobblemonBlocks.DAMP_ROCK)
+    val DAMP_ROCK = heldItem("damp_rock")
     @JvmField
-    val HEAT_ROCK = itemNameBlockItem("heat_rock", CobblemonBlocks.HEAT_ROCK)
+    val HEAT_ROCK = heldItem("heat_rock")
     @JvmField
-    val SMOOTH_ROCK = itemNameBlockItem("smooth_rock", CobblemonBlocks.SMOOTH_ROCK)
+    val SMOOTH_ROCK = heldItem("smooth_rock")
     @JvmField
-    val ICY_ROCK = itemNameBlockItem("icy_rock", CobblemonBlocks.ICY_ROCK)
+    val ICY_ROCK = heldItem("icy_rock")
 
     // Mulch
     @JvmField
@@ -1558,25 +1563,6 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     //@JvmField
     //val BINDING_SOIL = blockItem("binding_soil", CobblemonBlocks.BINDING_SOIL)
 
-    // Plants, Flora, and Flowers
-    @JvmField
-    val LOBAILA = compostableBlockItem("lobaila", CobblemonBlocks.LOBAILA, 0.65f)
-    @JvmField
-    val POMOHANA = compostableBlockItem("pomohana", CobblemonBlocks.POMOHANA, 0.3f)
-    @JvmField
-    val PAUVILLEA = compostableBlockItem("pauvillea", CobblemonBlocks.PAUVILLEA, 0.65f)
-    @JvmField
-    val WISTENSU = compostableBlockItem("wistensu", CobblemonBlocks.WISTENSU, 0.5f)
-
-    @JvmField
-    val VOLTACONIA = compostableBlockItem("voltaconia", CobblemonBlocks.VOLTACONIA, 0.85f)
-    @JvmField
-    val VERDROOT = compostableBlockItem("verdroot", CobblemonBlocks.VERDROOT, 0.85f)
-    @JvmField
-    val MISTLEAF = compostableBlockItem("mistleaf", CobblemonBlocks.MISTLEAF, 0.85f)
-    @JvmField
-    val LUCIBELL = compostableBlockItem("lucibell", CobblemonBlocks.LUCIBELL, 0.85f)
-
     private fun blockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): BlockItem = this.create(name, BlockItem(block, Item.Properties().rarity(rarity)))
 
     private fun itemNameBlockItem(name: String, block: Block, rarity: Rarity = Rarity.COMMON): ItemNameBlockItem = this.create(name, ItemNameBlockItem(block, Item.Properties().rarity(rarity)))
@@ -1613,16 +1599,7 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
 
     private fun wearableItem(name: String, heldItemRemappedName: String? = null): CobblemonItem = create(
         name,
-        WearableHatItem(name).also {
-            wearables.add(it)
-            if (heldItemRemappedName != null) {
-                CobblemonHeldItemManager.registerRemap(it, heldItemRemappedName)
-            }
-        }
-    )
-    private fun wearableBlockItem(name: String, block: Block, heldItemRemappedName: String? = null): WearableBlockItem = create(
-        name,
-        WearableBlockItem(name, block).also {
+        WearableItem(name).also {
             wearables.add(it)
             if (heldItemRemappedName != null) {
                 CobblemonHeldItemManager.registerRemap(it, heldItemRemappedName)
@@ -1779,6 +1756,4 @@ object CobblemonItems : PlatformRegistry<Registry<Item>, ResourceKey<Registry<It
     private fun foodItem(nutrition: Int, saturationModifier: Float): Item {
         return CobblemonItem(Item.Properties().food(FoodProperties.Builder().nutrition(nutrition).saturationModifier(saturationModifier).build()))
     }
-
-    private fun glowItem(name: String, block: Block): GlowItem  = this.create(name, GlowItem(block, Item.Properties()))
 }

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

@@ -8,6 +8,34 @@
 
 package com.cobblemon.mod.common
 
+import com.cobblemon.mod.common.net.serverhandling.battle.TeamPreviewSelectPokemonHandler
+
+import com.cobblemon.mod.common.net.messages.server.battle.TeamPreviewSelectPokemonPacket
+
+import com.cobblemon.mod.common.client.net.battle.CloseTeamPreviewHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.CloseTeamPreviewPacket
+
+import com.cobblemon.mod.common.client.net.battle.TeamPreviewHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.TeamPreviewPacket
+
+import com.cobblemon.mod.common.client.net.battle.BattleTimerHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleTimerPacket
+
+import com.cobblemon.mod.common.client.net.battle.BattleInformationHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleInformationPacket
+
+import com.cobblemon.mod.common.client.net.battle.BattleActorTeamHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleActorTeamPacket
+
+import com.cobblemon.mod.common.client.net.battle.BattleActorInformationHandler
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleActorInformationPacket
+
 import com.cobblemon.mod.common.api.net.NetworkPacket
 import com.cobblemon.mod.common.client.net.OpenBehaviourEditorHandler
 import com.cobblemon.mod.common.client.net.PlayerInteractOptionsHandler
@@ -386,6 +414,12 @@ object CobblemonNetwork {
         // Battle packets
         list.add(PacketRegisterInfo(BattleEndPacket.ID, BattleEndPacket::decode, BattleEndHandler))
         list.add(PacketRegisterInfo(BattleInitializePacket.ID, BattleInitializePacket::decode, BattleInitializeHandler))
+        list.add(PacketRegisterInfo(BattleActorInformationPacket.ID, BattleActorInformationPacket::decode, BattleActorInformationHandler))
+        list.add(PacketRegisterInfo(BattleActorTeamPacket.ID, BattleActorTeamPacket::decode, BattleActorTeamHandler))
+        list.add(PacketRegisterInfo(BattleInformationPacket.ID, BattleInformationPacket::decode, BattleInformationHandler))
+        list.add(PacketRegisterInfo(BattleTimerPacket.ID, BattleTimerPacket::decode, BattleTimerHandler))
+        list.add(PacketRegisterInfo(TeamPreviewPacket.ID, TeamPreviewPacket::decode, TeamPreviewHandler))
+        list.add(PacketRegisterInfo(CloseTeamPreviewPacket.ID, CloseTeamPreviewPacket::decode, CloseTeamPreviewHandler))
         list.add(PacketRegisterInfo(BattleQueueRequestPacket.ID, BattleQueueRequestPacket::decode, BattleQueueRequestHandler))
         list.add(PacketRegisterInfo(BattleFaintPacket.ID, BattleFaintPacket::decode, BattleFaintHandler))
         list.add(PacketRegisterInfo(BattleMakeChoicePacket.ID, BattleMakeChoicePacket::decode, BattleMakeChoiceHandler))
@@ -425,7 +459,6 @@ object CobblemonNetwork {
         list.add(PacketRegisterInfo(MovesRegistrySyncPacket.ID, MovesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(BerryRegistrySyncPacket.ID, BerryRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(SpeciesRegistrySyncPacket.ID, SpeciesRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
-        list.add(PacketRegisterInfo(SpeciesEvolutionSyncPacket.ID, SpeciesEvolutionSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(PropertiesCompletionRegistrySyncPacket.ID, PropertiesCompletionRegistrySyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(StandardSpeciesFeatureSyncPacket.ID, StandardSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))
         list.add(PacketRegisterInfo(GlobalSpeciesFeatureSyncPacket.ID, GlobalSpeciesFeatureSyncPacket::decode, DataRegistrySyncPacketHandler()))
@@ -574,6 +607,7 @@ object CobblemonNetwork {
 
         // Battle packets
         list.add(PacketRegisterInfo(BattleSelectActionsPacket.ID, BattleSelectActionsPacket::decode, BattleSelectActionsHandler))
+        list.add(PacketRegisterInfo(TeamPreviewSelectPokemonPacket.ID, TeamPreviewSelectPokemonPacket::decode, TeamPreviewSelectPokemonHandler))
         list.add(PacketRegisterInfo(SpectateBattlePacket.ID, SpectateBattlePacket::decode, SpectateBattleHandler))
         list.add(PacketRegisterInfo(RemoveSpectatorPacket.ID, RemoveSpectatorPacket::decode, RemoveSpectatorHandler))
 

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

@@ -148,9 +148,6 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
     @JvmField
     val MONITOR_GLITCHING = this.create("block.monitor.glitching")
 
-    @JvmField
-    val BRIGHT_POWDER_USE = this.create("block.bright_powder.use")
-
     @JvmField
     val FOSSIL_MACHINE_ACTIVATE = this.create("block.fossil_machine.activate")
     @JvmField
@@ -660,95 +657,5 @@ object CobblemonSounds : PlatformRegistry<Registry<SoundEvent>, ResourceKey<Regi
         SoundEvents.WOOL_FALL
     )
 
-    @JvmField
-    val ITEM_BLOCK_POWDER_PLACE = this.create("block.item_block.powder.place")
-    @JvmField
-    val ITEM_BLOCK_POWDER_BREAK = this.create("block.item_block.powder.break")
-    @JvmField
-    val ITEM_BLOCK_POWDER_STEP = this.create("block.item_block.powder.step")
-    @JvmField
-    val ITEM_BLOCK_POWDER_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_POWDER_BREAK,
-        ITEM_BLOCK_POWDER_STEP,
-        ITEM_BLOCK_POWDER_PLACE,
-        ITEM_BLOCK_POWDER_STEP,
-        ITEM_BLOCK_POWDER_STEP
-    )
-
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_LIQUID_PLACE = this.create("block.item_block.bottle_liquid.place")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_LIQUID_BREAK = this.create("block.item_block.bottle_liquid.break")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_LIQUID_STEP = this.create("block.item_block.bottle_liquid.step")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_LIQUID_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_BOTTLE_LIQUID_BREAK,
-        ITEM_BLOCK_BOTTLE_LIQUID_STEP,
-        ITEM_BLOCK_BOTTLE_LIQUID_PLACE,
-        ITEM_BLOCK_BOTTLE_LIQUID_PLACE,
-        ITEM_BLOCK_BOTTLE_LIQUID_PLACE
-    )
-
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_PILLS_PLACE = this.create("block.item_block.bottle_pills.place")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_PILLS_BREAK = this.create("block.item_block.bottle_pills.break")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_PILLS_STEP = this.create("block.item_block.bottle_pills.step")
-    @JvmField
-    val ITEM_BLOCK_BOTTLE_PILLS_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_BOTTLE_PILLS_BREAK,
-        ITEM_BLOCK_BOTTLE_PILLS_STEP,
-        ITEM_BLOCK_BOTTLE_PILLS_PLACE,
-        ITEM_BLOCK_BOTTLE_PILLS_PLACE,
-        ITEM_BLOCK_BOTTLE_PILLS_PLACE
-    )
-
-    @JvmField
-    val ITEM_BLOCK_DICE_PLACE = this.create("block.item_block.dice.place")
-    @JvmField
-    val ITEM_BLOCK_DICE_BREAK = this.create("block.item_block.dice.break")
-    @JvmField
-    val ITEM_BLOCK_DICE_STEP = this.create("block.item_block.dice.step")
-    @JvmField
-    val ITEM_BLOCK_DICE_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_DICE_BREAK,
-        ITEM_BLOCK_DICE_STEP,
-        ITEM_BLOCK_DICE_PLACE,
-        ITEM_BLOCK_DICE_STEP,
-        ITEM_BLOCK_DICE_STEP
-    )
-
-    @JvmField
-    val ITEM_BLOCK_METAL_CAN_PLACE = this.create("block.item_block.metal_can.place")
-    @JvmField
-    val ITEM_BLOCK_METAL_CAN_BREAK = this.create("block.item_block.metal_can.break")
-    @JvmField
-    val ITEM_BLOCK_METAL_CAN_STEP = this.create("block.item_block.metal_can.step")
-    @JvmField
-    val ITEM_BLOCK_METAL_CAN_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_METAL_CAN_BREAK,
-        ITEM_BLOCK_METAL_CAN_STEP,
-        ITEM_BLOCK_METAL_CAN_PLACE,
-        ITEM_BLOCK_METAL_CAN_STEP,
-        ITEM_BLOCK_METAL_CAN_STEP
-    )
-
-    @JvmField
-    val ITEM_BLOCK_JAR_GLASS_LIQUID_PLACE = this.create("block.item_block.jar_glass_liquid.place")
-    @JvmField
-    val ITEM_BLOCK_JAR_GLASS_LIQUID_BREAK = this.create("block.item_block.jar_glass_liquid.break")
-    @JvmField
-    val ITEM_BLOCK_JAR_GLASS_LIQUID_STEP = this.create("block.item_block.jar_glass_liquid.step")
-    @JvmField
-    val ITEM_BLOCK_JAR_GLASS_LIQUID_SOUNDS = SoundType(1f, 1.1f,
-        ITEM_BLOCK_JAR_GLASS_LIQUID_BREAK,
-        ITEM_BLOCK_JAR_GLASS_LIQUID_STEP,
-        ITEM_BLOCK_JAR_GLASS_LIQUID_PLACE,
-        ITEM_BLOCK_JAR_GLASS_LIQUID_STEP,
-        ITEM_BLOCK_JAR_GLASS_LIQUID_STEP
-    )
-
     private fun create(name: String): SoundEvent = this.create(name, SoundEvent.createVariableRangeEvent(cobblemonResource(name)))
 }

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

@@ -1,25 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.battles.model
-
-/**
- * How a [PokemonBattle] came to an end.
- */
-enum class BattleEndResult {
-    /** One side defeated the other. */
-    VICTORY,
-    /** A wild Pokémon was captured, ending the battle. */
-    CAPTURE,
-    /** An actor forfeited, giving the victory to the other side. */
-    FORFEIT,
-    /** A player fled from a wild Pokémon. */
-    FLED,
-    /** The battle was stopped without a winner, such as by a command, a player disconnecting or an error. */
-    STOPPED
-}

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

@@ -8,6 +8,16 @@
 
 package com.cobblemon.mod.common.api.battles.model
 
+import com.cobblemon.mod.common.net.messages.client.battle.FieldEffect
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleInformationPacket
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleInformationDTO
+
+import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
+
+import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
+
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
@@ -21,7 +31,6 @@ import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
 import com.cobblemon.mod.common.api.battles.model.actor.EntityBackedBattleActor
 import com.cobblemon.mod.common.api.battles.model.actor.FleeableBattleActor
 import com.cobblemon.mod.common.api.events.CobblemonEvents
-import com.cobblemon.mod.common.api.events.battles.BattleEndedEvent
 import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
 import com.cobblemon.mod.common.api.events.battles.BattleFleeAttemptEvent
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
@@ -125,12 +134,6 @@ open class PokemonBattle(
     var winners = listOf<BattleActor>()
     var losers = listOf<BattleActor>()
     var ended = false
-    /** How the battle ended, or null if it hasn't ended yet. */
-    var endResult: BattleEndResult? = null
-    /** The actor that forfeited the battle, if any. */
-    var forfeitedBy: BattleActor? = null
-    /** Whether a player fled from the battle. */
-    var fled = false
     // TEMP battle showcase stuff
     var announcingRules = false
     var turn: Int = 0
@@ -254,18 +257,42 @@ open class PokemonBattle(
             }
         }
         this.turn = newTurnNumber
+        notifyAllOfUpdates()
+    }
+
+    fun notifyAllOfUpdates() {
+        val uuids = this.actors.flatMap { it.getPlayerUUIDs() } + this.spectators
+        notifyOfUpdates(uuids)
+    }
+
+    fun notifyOfUpdates(uuids: List<UUID>) {
+        val weather = this.contextManager.get(BattleContext.Type.WEATHER)?.firstOrNull()
+        val terrain = this.contextManager.get(BattleContext.Type.TERRAIN)?.firstOrNull()
+        val room = this.contextManager.get(BattleContext.Type.ROOM)?.firstOrNull()
+        val side1SidedEffects = getSidedFieldEffects(side1)
+        val side2SidedEffects = getSidedFieldEffects(side2)
+        val updatePacket = BattleInformationPacket(this.battleId, BattleInformationDTO(
+            turn = turn,
+            weather = weather?.let { FieldEffect(it.id, it.turn, it.origin?.entity?.id) },
+            terrain = terrain?.let { FieldEffect(it.id, it.turn, it.origin?.entity?.id) },
+            room = room?.let { FieldEffect(it.id, it.turn, it.origin?.entity?.id) },
+            side1SidedEffects = side1SidedEffects,
+            side2SidedEffects = side2SidedEffects,
+        ))
+        uuids.mapNotNull { it.getPlayer() }.forEach {
+            it.sendPacket(updatePacket)
+        }
+    }
+
+    private fun getSidedFieldEffects(side: BattleSide): List<FieldEffect> {
+        val hazards = side.contextManager.get(BattleContext.Type.HAZARD)?.map { FieldEffect(it.id, it.turn, it.origin?.entity?.id) } ?: emptyList()
+        val screens = side.contextManager.get(BattleContext.Type.SCREEN)?.map { FieldEffect(it.id, it.turn, it.origin?.entity?.id) } ?: emptyList()
+        val tailwind = side.contextManager.get(BattleContext.Type.TAILWIND)?.firstOrNull()?.let { FieldEffect(it.id, it.turn, it.origin?.entity?.id) }
+        return hazards + screens + listOfNotNull(tailwind)
     }
 
     fun end() {
         ended = true
-        val result = when {
-            winners.isNotEmpty() && showdownMessages.any { "capture" in it } -> BattleEndResult.CAPTURE
-            winners.isNotEmpty() && forfeitedBy != null -> BattleEndResult.FORFEIT
-            winners.isNotEmpty() -> BattleEndResult.VICTORY
-            fled -> BattleEndResult.FLED
-            else -> BattleEndResult.STOPPED
-        }
-        endResult = result
         val awardToFainted = Cobblemon.config.awardExperienceToFaintedPokemon
         val awardOnLoss = Cobblemon.config.awardExperienceOnBattleLoss
         this.actors.forEach { actor ->
@@ -347,7 +374,6 @@ open class PokemonBattle(
                 }
             }
         }
-        CobblemonEvents.BATTLE_ENDED.post(BattleEndedEvent(this, result, forfeitedBy.takeIf { result == BattleEndResult.FORFEIT }))
         sendUpdate(BattleEndPacket())
         BattleRegistry.closeBattle(this)
     }
@@ -470,6 +496,7 @@ open class PokemonBattle(
     }
 
     fun tick() {
+        if (!ended) actors.filterIsInstance<PlayerBattleActor>().forEach { it.timer?.tick() }
         try {
             while (dispatchResult.canProceed()) {
                 val dispatch = dispatches.poll() ?: break
@@ -518,7 +545,6 @@ open class PokemonBattle(
                 .forEach{it.pokemon.heal()}
             CobblemonEvents.BATTLE_FLED.post(BattleFledEvent(this, actors.asSequence().filterIsInstance<PlayerBattleActor>().iterator().next()))
             actors.filterIsInstance<EntityBackedBattleActor<*>>().mapNotNull { it.entity }.forEach { it.sendSystemMessage(battleLang("flee").yellow()) }
-            fled = true
             stop()
         }
     }
@@ -556,7 +582,6 @@ open class PokemonBattle(
     private fun checkForfeit(): Boolean {
         val forfeit = actors.find { it.responses.any { it is ForfeitActionResponse } }
         return forfeit?.let {
-            forfeitedBy = it
             this.dispatchWaiting { this.broadcastChatMessage(battleLang("forfeit", it.getName()).red()) }
             writeShowdownAction(">forcelose ${it.showdownId}")
             true

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

@@ -8,6 +8,10 @@
 
 package com.cobblemon.mod.common.api.battles.model.actor
 
+import com.cobblemon.mod.common.net.messages.client.battle.BattleTimerPacket
+
+import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
+
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
 import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.api.net.NetworkPacket
@@ -48,6 +52,20 @@ abstract class BattleActor(
     var responses = mutableListOf<ShowdownActionResponse>()
     val expectingPassActions = mutableListOf<ShowdownActionResponse>()
     var mustChoose = false
+        set(value) {
+            if (field == value) return
+            field = value
+            if (this is PlayerBattleActor) {
+                timer?.let {
+                    if (value) {
+                        it.startSelection()
+                        sendUpdate(BattleTimerPacket(it.mustChooseBy()))
+                    } else {
+                        it.endSelection()
+                    }
+                }
+            }
+        }
 
     var itemsUsed = mutableListOf<BagItem>()
     /** For when battles start, it's the number of Pokémon that are still in the process of being sent out (animation wise) */

common/src/main/kotlin/com/cobblemon/mod/common/api/conditional/RegistryLikeAdapter.kt

@@ -11,9 +11,6 @@ package com.cobblemon.mod.common.api.conditional
 import com.google.gson.JsonDeserializationContext
 import com.google.gson.JsonDeserializer
 import com.google.gson.JsonElement
-import com.google.gson.JsonPrimitive
-import com.google.gson.JsonSerializationContext
-import com.google.gson.JsonSerializer
 import java.lang.reflect.Type
 
 /**
@@ -24,19 +21,11 @@ import java.lang.reflect.Type
  * @author Hiroku
  * @since July 17th, 2022
  */
-interface RegistryLikeAdapter<B> : JsonDeserializer<RegistryLikeCondition<B>>, JsonSerializer<RegistryLikeCondition<B>> {
+interface RegistryLikeAdapter<B> : JsonDeserializer<RegistryLikeCondition<B>> {
     val registryLikeConditions: MutableList<(JsonElement) -> RegistryLikeCondition<B>?>
 
     override fun deserialize(json: JsonElement, type: Type, ctx: JsonDeserializationContext): RegistryLikeCondition<B> {
         return registryLikeConditions.firstNotNullOfOrNull { it(json) }
             ?: throw IllegalArgumentException("Unable to deserialize $json")
     }
-
-    override fun serialize(src: RegistryLikeCondition<B>, typeOfSrc: Type, ctx: JsonSerializationContext): JsonElement {
-        return when (src) {
-            is RegistryLikeTagCondition<B> -> JsonPrimitive(RegistryLikeTagCondition.PREFIX + src.tag.location())
-            is RegistryLikeIdentifierCondition<B> -> JsonPrimitive(src.identifier.toString())
-            else -> throw IllegalArgumentException("Unable to serialize $src")
-        }
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/data/ServerJsonDataRegistry.kt

@@ -1,93 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.data
-
-import com.cobblemon.mod.common.util.endsWith
-import com.google.gson.Gson
-import com.google.gson.reflect.TypeToken
-import net.minecraft.core.HolderLookup
-import java.io.BufferedReader
-import java.io.File
-import java.util.concurrent.ExecutionException
-import net.minecraft.resources.ResourceLocation
-import net.minecraft.server.packs.PackType
-import net.minecraft.server.packs.resources.ResourceManager
-
-/**
- * A [DataRegistry] that consumes JSON files.
- * Every deserialized instance is attached to an [Identifier].
- * For example a file under data/mymod/[resourcePath]/entry.json would be backed by the identifier modid:entry.
- *
- * @param T The type of the data consumed by this registry.
- *
- * @author Licious
- * @since August 5th, 2022
- */
-interface ServerJsonDataRegistry<T> : DataRegistry {
-
-    /**
-     * The [TypeToken] of type [T].
-     */
-    val typeToken: TypeToken<T>
-
-    /**
-     * The folder location for the data this registry will consume.
-     */
-    val resourcePath: String
-
-    override val type: PackType
-        get() = PackType.SERVER_DATA
-
-    override fun reload(manager: ResourceManager) {
-        //NO-OP, handled by reload(manager, registry)
-    }
-
-    fun reload(manager: ResourceManager, registry: HolderLookup.Provider) {
-        val gson = setupParser(registry)
-        val data = hashMapOf<ResourceLocation, T>()
-        manager.listResources(resourcePath) { path -> path.endsWith(JSON_EXTENSION) }.forEach { (identifier, resource) ->
-            if (identifier.namespace == "pixelmon") {
-                return@forEach
-            }
-
-            resource.open().use { stream ->
-                stream.bufferedReader().use { reader ->
-                    val resolvedIdentifier = ResourceLocation.fromNamespaceAndPath(identifier.namespace, File(identifier.path).nameWithoutExtension)
-                    data[resolvedIdentifier] = parse(reader, resolvedIdentifier, gson)
-                }
-            }
-        }
-
-        reload(data, registry)
-    }
-
-    fun parse(reader: BufferedReader, identifier: ResourceLocation, gson: Gson): T {
-        return try {
-            gson.fromJson(reader, typeToken.type)
-        } catch (exception: Exception) {
-            throw ExecutionException("Error loading JSON for data: $identifier", exception)
-        }
-    }
-
-    /**
-     * Allows the creation of [Gson] instances which have adapters that are registry-aware, e.g. [com.cobblemon.mod.common.pokemon.evolution.adapters.LegacyItemConditionWrapperAdapter]
-     */
-    fun setupParser(registry: HolderLookup.Provider): Gson
-
-    /**
-     * Reloads this registry from the deserialized data.
-     *
-     * @param data A map of the data associating an instance to the respective identifier from the [ResourceManager].
-     */
-    fun reload(data: Map<ResourceLocation, T>, registry: HolderLookup.Provider)
-
-    companion object {
-        const val JSON_EXTENSION = ".json"
-    }
-}

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

@@ -12,7 +12,6 @@ import com.cobblemon.mod.common.api.events.battles.BattleFaintedEvent
 import com.cobblemon.mod.common.api.events.battles.BattleFledEvent
 import com.cobblemon.mod.common.api.events.battles.BattleFleeAttemptEvent
 import com.cobblemon.mod.common.api.events.battles.BattleStartedEvent
-import com.cobblemon.mod.common.api.events.battles.BattleEndedEvent
 import com.cobblemon.mod.common.api.events.battles.BattleVictoryEvent
 import com.cobblemon.mod.common.api.events.battles.instruction.FormeChangeEvent
 import com.cobblemon.mod.common.api.events.battles.instruction.MegaEvolutionEvent
@@ -140,9 +139,6 @@ object CobblemonEvents {
     @JvmField
     val BATTLE_FAINTED = EventObservable<BattleFaintedEvent>()
 
-    @JvmField
-    val BATTLE_ENDED = EventObservable<BattleEndedEvent>()
-
     // instructions
     @JvmField
     val MEGA_EVOLUTION = EventObservable<MegaEvolutionEvent>()

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

@@ -1,69 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.events.battles
-
-import com.bedrockk.molang.runtime.value.DoubleValue
-import com.bedrockk.molang.runtime.value.MoValue
-import com.bedrockk.molang.runtime.value.StringValue
-import com.cobblemon.mod.common.api.battles.model.BattleEndResult
-import com.cobblemon.mod.common.api.battles.model.PokemonBattle
-import com.cobblemon.mod.common.api.battles.model.actor.BattleActor
-import com.cobblemon.mod.common.api.battles.model.actor.ActorType
-import com.cobblemon.mod.common.util.asArrayValue
-
-/**
- * Event fired whenever a [PokemonBattle] ends, regardless of how it ended (victory, fleeing, being stopped, etc).
- *
- * [PokemonBattle.winners] and [PokemonBattle.losers] are only populated if the [result] has a winner,
- * that is [BattleEndResult.VICTORY], [BattleEndResult.CAPTURE] or [BattleEndResult.FORFEIT].
- *
- * @param result How the battle ended.
- * @param forfeitedBy The actor that forfeited, if the [result] is [BattleEndResult.FORFEIT].
- */
-data class BattleEndedEvent(
-    override val battle: PokemonBattle,
-    val result: BattleEndResult,
-    val forfeitedBy: BattleActor?
-) : BattleEvent {
-    /** Whether one side won the battle, which includes captures and forfeits. */
-    val hasWinner = battle.winners.isNotEmpty()
-    val wasVictory = result == BattleEndResult.VICTORY
-    val wasCapture = result == BattleEndResult.CAPTURE
-    val wasForfeit = result == BattleEndResult.FORFEIT
-    val wasFled = result == BattleEndResult.FLED
-    val wasStopped = result == BattleEndResult.STOPPED
-
-    /** Whether the battle was between players and wild Pokémon. */
-    val isPvW = battle.isPvW
-    /** Whether the battle was between players and NPCs. */
-    val isPvN = battle.isPvN
-    /** Whether the battle was between players. */
-    val isPvP = battle.isPvP
-
-    val context = mutableMapOf<String, MoValue>(
-        "battle" to battle.struct,
-        "result" to StringValue(result.name.lowercase()),
-        "has_winner" to DoubleValue(hasWinner),
-        "was_victory" to DoubleValue(wasVictory),
-        "was_capture" to DoubleValue(wasCapture),
-        "was_forfeit" to DoubleValue(wasForfeit),
-        "was_fled" to DoubleValue(wasFled),
-        "was_stopped" to DoubleValue(wasStopped),
-        "is_pvw" to DoubleValue(isPvW),
-        "is_pvn" to DoubleValue(isPvN),
-        "is_pvp" to DoubleValue(isPvP),
-        "winners" to battle.winners.asArrayValue { it.struct },
-        "losers" to battle.losers.asArrayValue { it.struct },
-        "players" to battle.actors.filter { it.type == ActorType.PLAYER }.asArrayValue { it.struct },
-        "npcs" to battle.actors.filter { it.type == ActorType.NPC }.asArrayValue { it.struct },
-        "wild_pokemon" to battle.actors.filter { it.type == ActorType.WILD }.asArrayValue { it.struct }
-    ).apply {
-        forfeitedBy?.let { put("forfeited_by", it.struct) }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/fossil/Fossils.kt

@@ -40,7 +40,7 @@ object Fossils: JsonDataRegistry<Fossil> {
         .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
         .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter())
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
         .create()
 
     override val typeToken: TypeToken<Fossil> = TypeToken.get(Fossil::class.java)

common/src/main/kotlin/com/cobblemon/mod/common/api/gui/ParentWidget.kt

@@ -10,6 +10,7 @@ package com.cobblemon.mod.common.api.gui
 
 import com.cobblemon.mod.common.client.gui.CobblemonRenderable
 import net.minecraft.client.gui.components.AbstractWidget
+import net.minecraft.client.gui.components.Renderable
 import net.minecraft.client.gui.components.events.GuiEventListener
 import net.minecraft.client.gui.narration.NarrationElementOutput
 import net.minecraft.network.chat.Component
@@ -54,8 +55,6 @@ abstract class ParentWidget(
     }
 
     override fun mouseClicked(pMouseX: Double, pMouseY: Double, pButton: Int): Boolean {
-        if (!active) return false
-
         return children.any {
             it.mouseClicked(pMouseX, pMouseY, pButton)
         }

common/src/main/kotlin/com/cobblemon/mod/common/api/gui/TreeDrawingUtils.kt

@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.gui
-
-import kotlin.math.max
-import kotlin.math.min
-
-interface TreeNode<T> {
-    val children: List<TreeNode<T>>
-}
-
-class TreeDrawingNode<T>(
-    val value: T,
-    val children: List<TreeDrawingNode<T>>,
-) {
-    var x = 0
-    var y = 0
-    var offset = 0
-}
-
-fun <T> createDrawingTree(treeNode: TreeNode<T>): TreeDrawingNode<T> {
-    val root = setup(treeNode, 0, mutableListOf<Int>(), mutableListOf<Int>())
-    addMods(root, 0)
-
-    return root
-}
-
-@Suppress("UNCHECKED_CAST")
-private fun <T> setup(
-    treeNode: TreeNode<T>,
-    depth: Int,
-    nexts: MutableList<Int>,
-    offset: MutableList<Int>,
-): TreeDrawingNode<T> {
-    val children = treeNode.children.map { child ->
-        setup(child, depth + 1, nexts, offset)
-    }
-
-    val treeDrawingNode = TreeDrawingNode<T>(treeNode as T, children)
-    treeDrawingNode.y = depth
-
-    while (nexts.size <= depth) {
-        nexts.add(0)
-    }
-
-    while (offset.size <= depth) {
-        offset.add(0)
-    }
-
-    var place =
-        if (children.isEmpty()) {
-            nexts[depth]
-        } else if (children.size == 1) {
-//            children.first().x - 1
-            children.first().x
-        } else {
-//            (children[0].x + children[1].x) / 2
-            (children.first().x + children.last().x) / 2
-        }
-
-    offset[depth] = max(offset[depth], nexts[depth] - place)
-
-    if (children.isEmpty()) {
-        treeDrawingNode.x = place
-    } else {
-        treeDrawingNode.x = place + offset[depth]
-    }
-
-    nexts[depth] += 2
-    treeDrawingNode.offset = offset[depth]
-
-    return treeDrawingNode
-}
-
-private fun <T> addMods(
-    treeNode: TreeDrawingNode<T>,
-    modSum: Int,
-) {
-    treeNode.x += modSum
-    val newModSum = modSum + treeNode.offset
-
-    treeNode.children.forEach { child ->
-        addMods(child, newModSum)
-    }
-}
-
-data class TreeDrawingBounds(val minX: Int, val maxX: Int, val minY: Int, val maxY: Int) {
-    val width = maxX - minX
-    val height = maxY - minY
-    val xCenter = (maxX + minX) / 2.0
-    val yCenter = (maxY + minY) / 2.0
-}
-
-fun <T> calculateBounds(treeDrawingNode: TreeDrawingNode<T>): TreeDrawingBounds {
-    var minX = treeDrawingNode.x
-    var maxX = treeDrawingNode.x
-    var minY = treeDrawingNode.y
-    var maxY = treeDrawingNode.y
-
-    for (child in treeDrawingNode.children) {
-        val childBounds = calculateBounds(child)
-
-        minX = min(minX, childBounds.minX)
-        maxX = max(maxX, childBounds.maxX)
-        minY = min(minY, childBounds.minY)
-        maxY = max(maxY, childBounds.maxY)
-    }
-
-    return TreeDrawingBounds(minX, maxX, minY, maxY)
-}

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

@@ -10,7 +10,7 @@ package com.cobblemon.mod.common.api.interaction
 
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.conditional.RegistryLikeCondition
-import com.cobblemon.mod.common.api.data.ServerJsonDataRegistry
+import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.molang.ExpressionLike
 import com.cobblemon.mod.common.api.pokemon.PokemonProperties
 import com.cobblemon.mod.common.api.pokemon.requirement.Requirement
@@ -26,7 +26,6 @@ import com.google.gson.Gson
 import com.google.gson.GsonBuilder
 import com.google.gson.reflect.TypeToken
 import net.minecraft.advancements.critereon.ItemPredicate
-import net.minecraft.core.HolderLookup
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerPlayer
 import net.minecraft.server.packs.PackType
@@ -37,31 +36,28 @@ import net.minecraft.world.level.block.Block
 import net.minecraft.world.level.levelgen.structure.Structure
 import net.minecraft.world.level.material.Fluid
 
-object PokemonInteractions : ServerJsonDataRegistry<PokemonInteractionSet> {
+object PokemonInteractions : JsonDataRegistry<PokemonInteractionSet> {
     override val id = cobblemonResource("pokemon_interactions")
     override val type = PackType.SERVER_DATA
-    override fun setupParser(registry: HolderLookup.Provider): Gson {
-        return GsonBuilder()
-            .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
-            .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
-            .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter(registry))
-            .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
-            .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
-            .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
-            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
-            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
-            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
-            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
-            .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
-            .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
-            .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
-            .setPrettyPrinting()
-            .create()
-    }
-
     override val observable = SimpleObservable<PokemonInteractions>()
     override val typeToken: TypeToken<PokemonInteractionSet> = TypeToken.get(PokemonInteractionSet::class.java)
     override val resourcePath = "pokemon_interactions"
+    override val gson: Gson = GsonBuilder()
+        .registerTypeAdapter(ResourceLocation::class.java, IdentifierAdapter)
+        .registerTypeAdapter(PokemonProperties::class.java, pokemonPropertiesShortAdapter)
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
+        .registerTypeAdapter(Requirement::class.java, CobblemonRequirementAdapter)
+        .registerTypeAdapter(InteractionEffect::class.java, InteractionEffectAdapter)
+        .registerTypeAdapter(ExpressionLike::class.java, ExpressionLikeAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Biome::class.java).type, BiomeLikeConditionAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Block::class.java).type, BlockLikeConditionAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Item::class.java).type, ItemLikeConditionAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Structure::class.java).type, StructureLikeConditionAdapter)
+        .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
+        .registerTypeAdapter(IntRange::class.java, IntRangeAdapter)
+        .registerTypeAdapterFactory(LowerCaseEnumTypeAdapterFactory())
+        .setPrettyPrinting()
+        .create()
 
     val interactions = mutableListOf<PokemonInteractionSet>()
 
@@ -69,7 +65,7 @@ object PokemonInteractions : ServerJsonDataRegistry<PokemonInteractionSet> {
         PokemonInteractionsSyncPacket(interactions).sendToPlayer(player)
     }
 
-    override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>, registry: HolderLookup.Provider) {
+    override fun reload(data: Map<ResourceLocation, PokemonInteractionSet>) {
         interactions.clear()
         val split = data.entries
             .partition {
@@ -91,4 +87,4 @@ object PokemonInteractions : ServerJsonDataRegistry<PokemonInteractionSet> {
             .flatMap { it.interactions }
             .firstOrNull(interactionCheck)
     }
-}
+}

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

@@ -16,7 +16,6 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.asMoLangValue
 import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
 import com.cobblemon.mod.common.battles.actor.PokemonBattleActor
 import com.cobblemon.mod.common.entity.npc.NPCBattleActor
-import com.cobblemon.mod.common.util.asArrayValue
 
 object BattleActorMoLangFunctions : AbstractMoLangFunctionHolder<BattleActor>() {
     override fun BattleActor.moLangFunctions(): MutableMap<String, (MoParams) -> Any> {
@@ -26,7 +25,6 @@ object BattleActorMoLangFunctions : AbstractMoLangFunctionHolder<BattleActor>()
         functions["is_npc"] = { DoubleValue(actor.type == ActorType.NPC) }
         functions["is_player"] = { DoubleValue(actor.type == ActorType.PLAYER) }
         functions["is_wild"] = { DoubleValue(actor.type == ActorType.WILD) }
-        functions["battle_pokemon"] = { actor.pokemonList.asArrayValue { it.struct } }
 
         when (actor) {
             is NPCBattleActor -> {

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

@@ -55,11 +55,6 @@ object GeneralMoLangFunctions {
             struct.map.remove(variable)
             DoubleValue.ONE
         }
-        functions["delete_variables"] = { params ->
-            val struct = params.get<VariableStruct>(0)
-            struct.map.clear()
-            DoubleValue.ONE
-        }
         functions["get_variable"] = { params ->
             val struct = params.get<VariableStruct>(0)
             val variable = params.getString(1)

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

@@ -16,7 +16,6 @@ import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.pokedex.AbstractPokedexManager
 import com.cobblemon.mod.common.api.pokedex.CaughtCount
 import com.cobblemon.mod.common.api.pokedex.CaughtPercent
-import com.cobblemon.mod.common.api.pokedex.Dexes
 import com.cobblemon.mod.common.api.pokedex.PokedexEntryProgress
 import com.cobblemon.mod.common.api.pokedex.PokedexManager
 import com.cobblemon.mod.common.api.pokedex.SeenCount
@@ -75,27 +74,6 @@ object PokedexMoLangFunctions : AbstractMoLangFunctionHolder<AbstractPokedexMana
         functions["caught_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(CaughtPercent)) }
         functions["seen_percent"] = { DoubleValue(pokedex.getGlobalCalculatedValue(SeenPercent)) }
 
-        functions["dex_caught_count"] = { params ->
-            val dexId = params.getString(0).asIdentifierDefaultingNamespace()
-            if (Dexes.dexEntryMap.containsKey(dexId)) DoubleValue(pokedex.getDexCalculatedValue(dexId, CaughtCount))
-            else DoubleValue.ZERO
-        }
-        functions["dex_seen_count"] = { params ->
-            val dexId = params.getString(0).asIdentifierDefaultingNamespace()
-            if (Dexes.dexEntryMap.containsKey(dexId)) DoubleValue(pokedex.getDexCalculatedValue(dexId, SeenCount))
-            else DoubleValue.ZERO
-        }
-        functions["dex_caught_percent"] = { params ->
-            val dexId = params.getString(0).asIdentifierDefaultingNamespace()
-            if (Dexes.dexEntryMap.containsKey(dexId)) DoubleValue(pokedex.getDexCalculatedValue(dexId, CaughtPercent).toDouble())
-            else DoubleValue.ZERO
-        }
-        functions["dex_seen_percent"] = { params ->
-            val dexId = params.getString(0).asIdentifierDefaultingNamespace()
-            if (Dexes.dexEntryMap.containsKey(dexId)) DoubleValue(pokedex.getDexCalculatedValue(dexId, SeenPercent).toDouble())
-            else DoubleValue.ZERO
-        }
-
         when (pokedex) {
             is PokedexManager -> {
                 functions["player_id"] = { StringValue(pokedex.uuid.toString()) }

common/src/main/kotlin/com/cobblemon/mod/common/api/orientation/OrientationController.kt

@@ -8,10 +8,8 @@
 
 package com.cobblemon.mod.common.api.orientation
 
-import com.cobblemon.mod.common.util.math.QuatSpring
 import com.cobblemon.mod.common.util.math.geometry.toDegrees
 import com.cobblemon.mod.common.util.math.geometry.toRadians
-import com.cobblemon.mod.common.util.math.simpleSpringDamperQuat
 import net.minecraft.client.Minecraft
 import net.minecraft.util.Mth
 import net.minecraft.world.entity.LivingEntity
@@ -28,8 +26,6 @@ open class OrientationController(val entity: LivingEntity) {
         val FORWARDS: Vector3f = Vector3f(0.0f, 0.0f, -1.0f)
         val UP: Vector3f = Vector3f(0.0f, 1.0f, 0.0f)
         val LEFT: Vector3f = Vector3f(-1.0f, 0.0f, 0.0f)
-        private const val TICK_DT = 1f / 20f // Minecraft server tick rate
-        private const val RENDER_SMOOTH_HALFLIFE = 0.1f // seconds to close ~half the gap
     }
 
     open var active: Boolean = false
@@ -37,8 +33,6 @@ open class OrientationController(val entity: LivingEntity) {
     var orientation: Matrix3f? = null
         private set
 
-    private val renderSpring = QuatSpring()
-
     private var renderOrientationO: Matrix3f? = null
     private var renderOrientation: Matrix3f? = null
 
@@ -60,8 +54,6 @@ open class OrientationController(val entity: LivingEntity) {
         orientation = null
         renderOrientationO = null
         renderOrientation = null
-        renderSpring.quat.identity()
-        renderSpring.angVel.set(0f, 0f, 0f)
         active = false
     }
 
@@ -85,26 +77,18 @@ open class OrientationController(val entity: LivingEntity) {
         return oldQuat
     }
 
-    /** Every tick move the current render orientation towards the last known true orientation **/
     fun tick() {
         if (!active || orientation == null) return
         renderOrientationO = renderOrientation
-        val current = orientation!!
-        val targetQuat = Quaternionf().setFromUnnormalized(current)
-
-        if (renderOrientation == null) {
-            // First tick: snap the spring to the target instead of easing in from identity
-            renderSpring.quat.set(targetQuat)
-            renderSpring.angVel.set(0f, 0f, 0f)
-        }
-
-        // Use a "quat spring" to smoothly move the render orientation towards the goal orientation.
-        // It takes into account the orientations angular velocities and should be much more resilient
-        // to sharp changes in goal orientation or late/missed packets.
-        simpleSpringDamperQuat(renderSpring, targetQuat, 0.15f, TICK_DT)
+        val current = orientation
+        val renderMatrix = this.renderOrientation ?: current
+        val renderQuat = Quaternionf().setFromUnnormalized(renderMatrix)
+        val targetQuat  = Quaternionf().setFromUnnormalized(current)
+        val dampingFactor = 0.66f // Smooth interpolation to reduce jitter of orientations recieved from the server.
+        renderQuat.slerp(targetQuat, dampingFactor)
 
         val newRenderOrientation = Matrix3f()
-        renderSpring.quat.get(newRenderOrientation)
+        renderQuat.get(newRenderOrientation)
         renderOrientation = newRenderOrientation
     }
 

common/src/main/kotlin/com/cobblemon/mod/common/api/pokeball/catching/modifiers/CatchRateModifiers.kt

@@ -108,7 +108,7 @@ object CatchRateModifiers {
      * Used by [PokeBalls.SAFARI_BALL].
      * Checks if the target is not battling, if true boost by *1.5
      */
-    val SAFARI = MultiplierModifier(1.5f) { _, poke -> !poke.entity?.isBattling!! }
+    val SAFARI = WorldStateModifier { _, entity -> if (!entity.isBattling) 1.5F else 1F }
 
     /**
      * Used by [PokeBalls.PARK_BALL].

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

@@ -13,10 +13,6 @@ import com.cobblemon.mod.common.api.molang.MoLangFunctions.addStandardFunctions
 import com.cobblemon.mod.common.api.molang.ObjectValue
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
 import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
-import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
-import com.cobblemon.mod.common.api.pokemon.feature.ChoiceSpeciesFeatureProvider
-import com.cobblemon.mod.common.api.pokemon.feature.SpeciesFeatures
-import com.cobblemon.mod.common.api.pokemon.feature.WeightedChoiceSpeciesFeatureProvider
 import com.cobblemon.mod.common.pokedex.scanner.PokedexEntityData
 import com.cobblemon.mod.common.pokemon.Gender
 import net.minecraft.resources.ResourceLocation
@@ -76,57 +72,6 @@ abstract class AbstractPokedexManager {
         } ?: PokedexEntryProgress.UNREGISTERED
     }
 
-    fun getHighestKnowledgeFor(entry: PokedexEntry, form: PokedexForm?): PokedexEntryProgress {
-        if (form == null) return getHighestKnowledgeFor(entry)
-
-        val speciesRecord = getSpeciesRecord(entry.speciesId) ?: return PokedexEntryProgress.UNREGISTERED
-        val hasAllAspects = entry.conditionAspects.all(speciesRecord::hasAspect)
-        if (!hasAllAspects) {
-            return PokedexEntryProgress.UNREGISTERED
-        }
-
-        return speciesRecord.getFormRecord(form.displayForm)?.knowledge ?: PokedexEntryProgress.UNREGISTERED
-    }
-
-    fun getHighestKnowledgeFor(entry: PokedexEntry, form: PokedexForm?, aspects: Iterable<String>): PokedexEntryProgress {
-        val formKnowledge = getHighestKnowledgeFor(entry, form)
-
-        if (formKnowledge == PokedexEntryProgress.UNREGISTERED) return PokedexEntryProgress.UNREGISTERED
-
-        val seenAspects = getSeenAspects(entry)
-
-        // Aspects that select one of the species' own forms are already covered by the form knowledge check above,
-        // so exempt them (and every other value of the same feature, since defaults like "phony" never appear on a form directly).
-        val species = PokemonSpecies.getByIdentifier(entry.speciesId)
-        val formAspects = species?.forms?.flatMapTo(hashSetOf()) { it.aspects } ?: emptySet()
-        val formSelectingFeatureAspects = species?.let(SpeciesFeatures::getFeaturesFor).orEmpty()
-            .mapNotNull { provider ->
-                val allAspects: Collection<String> = when (provider) {
-                    is ChoiceSpeciesFeatureProvider -> provider.getAllAspects()
-                    is WeightedChoiceSpeciesFeatureProvider -> provider.getAllAspects().keys
-                    else -> return@mapNotNull null
-                }
-                allAspects.takeIf { it.any { aspect -> aspect in formAspects } }
-            }
-            .flatten()
-            .toHashSet()
-
-        val allSeenAspects = aspects
-            .filter { aspect ->
-                if (Dexes.equivalentFormsLookup[aspect] != null) return@filter false
-                if (aspect in formAspects || aspect in formSelectingFeatureAspects) return@filter false
-                if (aspect.uppercase() in setOf(Gender.MALE.name, Gender.FEMALE.name, Gender.GENDERLESS.name)) return@filter false
-                if ("shiny".equals(aspect, ignoreCase = true)) return@filter false
-
-                return@filter true
-            }
-            .all { aspect -> seenAspects.contains(aspect) }
-
-        if (!allSeenAspects) return PokedexEntryProgress.UNREGISTERED
-
-        return formKnowledge
-    }
-
     fun getEncounteredForms(entry: PokedexEntry) : List<PokedexForm> {
         return getFormsWithKnowledge(entry, PokedexEntryProgress.SEEN)
     }

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

@@ -10,9 +10,6 @@ package com.cobblemon.mod.common.api.pokedex
 
 import com.cobblemon.mod.common.api.data.JsonDataRegistry
 import com.cobblemon.mod.common.api.pokedex.def.PokedexDef
-import com.cobblemon.mod.common.api.pokedex.entry.PokedexEntry
-import com.cobblemon.mod.common.api.pokedex.entry.PokedexForm
-import com.cobblemon.mod.common.api.pokemon.PokemonSpecies
 import com.cobblemon.mod.common.api.reactive.SimpleObservable
 import com.cobblemon.mod.common.net.messages.client.data.PokedexDexSyncPacket
 import com.cobblemon.mod.common.util.adapters.CodecBackedAdapter
@@ -43,17 +40,6 @@ object Dexes : JsonDataRegistry<PokedexDef> {
     //Maps a dex id to its PokedexDef
     val dexEntryMap = linkedMapOf<ResourceLocation, PokedexDef>()
 
-    val equivalentForms = mapOf(
-        "galar" to listOf("region-bias-galar", "bias-galar", "galar-bias", "galarian", "galar"),
-        "alola" to listOf("region-bias-alola", "bias-alola", "alola-bias", "alolan", "alola"),
-        "hisui" to listOf("region-bias-hisui", "bias-hisui", "hisui-bias", "hisuian", "hisui"),
-        "paldea" to listOf("region-bias-paldea", "bias-paldea", "paldea-bias", "paldean", "paldea"),
-    )
-
-    val equivalentFormsLookup = equivalentForms.flatMap { (key, values) ->
-        values.map { it to key }
-    }.toMap()
-
     override fun reload(data: Map<ResourceLocation, PokedexDef>) {
         dexEntryMap.clear()
         data.entries.sortedBy { it.value.sortOrder }.forEach { (id, def) -> dexEntryMap[id] = def }
@@ -63,41 +49,4 @@ object Dexes : JsonDataRegistry<PokedexDef> {
     override fun sync(player: ServerPlayer) {
         PokedexDexSyncPacket(dexEntryMap.values).sendToPlayer(player)
     }
-
-    fun findDexEntryBySpeciesId(regionId: ResourceLocation, speciesId: ResourceLocation): PokedexEntry? {
-        return dexEntryMap[regionId]?.getEntries()?.firstOrNull { it -> it.speciesId == speciesId }
-    }
-
-    fun findDexEntryBySpeciesId(speciesId: ResourceLocation): PokedexEntry? {
-        return findDexEntryBySpeciesId(cobblemonResource("national"), speciesId)
-    }
-
-    fun findRootDexEntryBySpeciesId(speciesId: ResourceLocation, formName: String): Pair<PokedexEntry, PokedexForm> {
-        var rootSpecies = PokemonSpecies.getByIdentifier(speciesId)!!
-        val initialFormEquivalents = getFormEquivalents(formName)
-        var rootForm = rootSpecies.forms.firstOrNull { initialFormEquivalents.contains(it.name.lowercase()) }
-            ?: rootSpecies.standardForm
-
-        var preEvolution = rootForm.preEvolution
-        while (preEvolution != null) {
-            rootSpecies = preEvolution.species
-            rootForm = preEvolution.resolveForm(rootForm.aspects.toSet())
-            preEvolution = rootForm.preEvolution
-        }
-
-        val entry = findDexEntryBySpeciesId(rootSpecies.resourceIdentifier)
-            ?: throw RuntimeException("Root dex entry not found")
-
-        val formEquivalents = getFormEquivalents(rootForm.name)
-        val form =
-            entry.forms.firstOrNull { formEquivalents.contains(it.displayForm.lowercase()) } ?:
-            entry.forms.first { it.displayForm.equals("Normal", ignoreCase = true) }
-
-        return entry to form
-    }
-
-    fun getFormEquivalents(formName: String): List<String> {
-        val key = equivalentFormsLookup[formName.lowercase()]
-        return equivalentForms[key] ?: listOf(formName.lowercase())
-    }
 }

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

@@ -121,7 +121,6 @@ class SpeciesDexRecord {
 
     fun addAspects(addedAspects: Set<String>) {
         aspects.addAll(addedAspects)
-        pokedexManager.onSpeciesRecordUpdated(this)
     }
 
     /** Returns true if the given Pokémon contains new information. Internal because it's only to be called from [FormDexRecord.wouldBeDifferent]. */

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

@@ -44,9 +44,6 @@ import com.cobblemon.mod.common.api.riding.sound.RideSoundSettingsList
 import com.cobblemon.mod.common.api.spawning.TimeRange
 import com.cobblemon.mod.common.api.types.ElementalType
 import com.cobblemon.mod.common.api.types.adapters.ElementalTypeAdapter
-import com.cobblemon.mod.common.net.messages.client.data.FormEvolutionOverride
-import com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionEntry
-import com.cobblemon.mod.common.net.messages.client.data.SpeciesEvolutionSyncPacket
 import com.cobblemon.mod.common.net.messages.client.data.SpeciesRegistrySyncPacket
 import com.cobblemon.mod.common.pokemon.FormData
 import com.cobblemon.mod.common.pokemon.Species
@@ -131,7 +128,7 @@ object PokemonSpecies : JsonDataRegistry<Species> {
         .registerTypeAdapter(TypeToken.getParameterized(RegistryLikeCondition::class.java, Fluid::class.java).type, FluidLikeConditionAdapter)
         .registerTypeAdapter(EggGroup::class.java, EggGroupAdapter)
         .registerTypeAdapter(MobEffect::class.java, RegistryElementAdapter<MobEffect>(BuiltInRegistries::MOB_EFFECT))
-        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter())
+        .registerTypeAdapter(ItemPredicate::class.java, LegacyItemConditionWrapperAdapter)
         .registerTypeAdapter(RidingBehaviourSettings::class.java, RidingBehaviourSettingsAdapter)
         .registerTypeAdapter(RideSoundSettingsList::class.java, RideSoundSettingsListAdapter)
         .registerTypeAdapter(ObtainableItemCondition::class.java, ObtainableItemConditionAdapter)
@@ -246,18 +243,6 @@ object PokemonSpecies : JsonDataRegistry<Species> {
 
     override fun sync(player: ServerPlayer) {
         SpeciesRegistrySyncPacket(species.toList()).sendToPlayer(player)
-        // Sent after the species themselves so every species is already registered by the time this is decoded.
-        val evolutionEntries = species.map { singleSpecies ->
-            val formOverrides = singleSpecies.forms.mapNotNull { form ->
-                if (form.ownEvolutions == null && form.ownPreEvolution == null) {
-                    null
-                } else {
-                    FormEvolutionOverride(form.name, form.ownEvolutions, form.ownPreEvolution)
-                }
-            }
-            SpeciesEvolutionEntry(singleSpecies.resourceIdentifier, singleSpecies.evolutions, singleSpecies.preEvolution, formOverrides)
-        }
-        SpeciesEvolutionSyncPacket(evolutionEntries).sendToPlayer(player)
     }
 
     /**

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/aspect/AspectParticleMap.kt

@@ -15,8 +15,6 @@ import com.cobblemon.mod.common.block.entity.PokeSnackBlockEntity
 import com.cobblemon.mod.common.client.entity.PokemonClientDelegate
 import com.cobblemon.mod.common.client.render.MatrixWrapper
 import com.cobblemon.mod.common.util.cobblemonResource
-import net.minecraft.client.Minecraft
-import net.minecraft.client.ParticleStatus
 import net.minecraft.core.particles.BlockParticleOption
 import net.minecraft.core.particles.ParticleOptions
 import net.minecraft.core.particles.ParticleTypes
@@ -42,25 +40,13 @@ sealed class ParticleData {
         val chance: Double,
         val amount: Int,
         val locatorResolver: (Map<String, MatrixWrapper>) -> List<String>
-    ): ParticleData() {
-        fun amount(): Int = when(Minecraft.getInstance().options.particles().get()) {
-            ParticleStatus.ALL -> amount
-            ParticleStatus.DECREASED -> amount / 2
-            ParticleStatus.MINIMAL -> amount / 4
-        }
-    }
+    ): ParticleData()
 
     data class MinecraftParticle(
         val particle: ParticleOptions,
         val chance: Double,
         val amount: Int
-    ): ParticleData() {
-        fun amount(): Int = when(Minecraft.getInstance().options.particles().get()) {
-            ParticleStatus.ALL -> amount
-            ParticleStatus.DECREASED -> amount / 2
-            ParticleStatus.MINIMAL -> amount / 4
-        }
-    }
+    ): ParticleData()
 }
 
 /**

common/src/main/kotlin/com/cobblemon/mod/common/api/pokemon/evolution/PreEvolution.kt

@@ -25,8 +25,6 @@ interface PreEvolution {
 
     val form: FormData
 
-    fun resolveForm(extraAspects: Set<String> = emptySet()): FormData = form
-
     companion object {
 
         fun of(species: Species, form: FormData = species.standardForm): PreEvolution = StandardPreEvolution(species, form)

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

@@ -11,8 +11,6 @@ package com.cobblemon.mod.common.api.pokemon.requirement
 import com.cobblemon.mod.common.api.pokemon.evolution.ContextEvolution
 import com.cobblemon.mod.common.api.pokemon.evolution.Evolution
 import com.cobblemon.mod.common.pokemon.Pokemon
-import net.minecraft.resources.ResourceLocation
-import java.util.WeakHashMap
 
 /**
  * Represents a universal requirement suitable for various checks on pokemon..
@@ -34,11 +32,4 @@ fun interface Requirement {
      */
     fun check(pokemon: Pokemon): Boolean
 
-    val pokedexIcon: ResourceLocation? get() = pokedexIconOverrides[this]
-    val pokedexTooltip: String? get() = pokedexTooltipOverrides[this]
-
-    companion object {
-        val pokedexIconOverrides = WeakHashMap<Requirement, ResourceLocation>()
-        val pokedexTooltipOverrides = WeakHashMap<Requirement, String>()
-    }
 }

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/util/BlockPrimitiveCollector.kt

@@ -1,62 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.riding.util
-
-import net.minecraft.core.BlockPos
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.phys.AABB
-import kotlin.math.floor
-
-/**
- * Walks every block position inside [searchBox] and turns each solid block into one
- * full-cube [FieldPrimitive].
- *
- * @author Jackson
- * @since July 27th, 2026
- */
-
-fun collectPrimitivesFromBlocks(
-    level: BlockGetter,
-    searchBox: AABB,
-    shape: PrimitiveShape,
-    includeFluids: Boolean = false
-): List<FieldPrimitive> {
-    val primitives = mutableListOf<FieldPrimitive>()
-
-    val minX = floor(searchBox.minX).toInt()
-    val maxX = floor(searchBox.maxX).toInt()
-    val minY = floor(searchBox.minY).toInt()
-    val maxY = floor(searchBox.maxY).toInt()
-    val minZ = floor(searchBox.minZ).toInt()
-    val maxZ = floor(searchBox.maxZ).toInt()
-
-    val pos = BlockPos.MutableBlockPos()
-    for (x in minX..maxX) {
-        for (y in minY..maxY) {
-            for (z in minZ..maxZ) {
-                pos.set(x, y, z)
-                val state = level.getBlockState(pos)
-
-                val isSolid = !state.getCollisionShape(level, pos).isEmpty
-                val isFluid = includeFluids && !state.fluidState.isEmpty
-                if (!isSolid && !isFluid) continue
-
-                primitives.add(
-                    FieldPrimitive(
-                        shape = shape,
-                        centerX = x + 0.5f, centerY = y + 0.5f, centerZ = z + 0.5f,
-                        halfWidth = 0.5f, halfHeight = 0.5f, halfDepth = 0.5f
-                    )
-                )
-            }
-        }
-    }
-
-    return primitives
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/util/DistanceFieldMath.kt

@@ -1,155 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.riding.util
-
-import net.minecraft.world.phys.Vec3
-import kotlin.math.abs
-import kotlin.math.max
-import kotlin.math.min
-import kotlin.math.sqrt
-
-/**
- * Helpful Functions when working with signed distance fields/functions.
- * https://iquilezles.org/articles/distfunctions/
- *
- * @author Jackson
- * @since July 27th, 2026
- */
-
-/** Which distance formula a primitive uses. */
-enum class PrimitiveShape {
-    BOX,
-    ROUNDED_BOX,
-    ELLIPSOID
-}
-
-/** Tunable constants for the field. */
-data class DistanceFieldTuning(
-    val smoothingRange: Float = 0.5f,
-    val roundingRadius: Float = 0.08f
-)
-
-/** A single shape in the field - a center position, half-extents, and which formula to use. */
-data class FieldPrimitive(
-    val shape: PrimitiveShape,
-    val centerX: Float, val centerY: Float, val centerZ: Float,
-    val halfWidth: Float, val halfHeight: Float, val halfDepth: Float
-)
-
-/** Fast approximate 1/sqrt(x) - the Quake III trick, cheaper than a real sqrt + divide. */
-fun fastInverseSqrt(value: Float): Float {
-    var x = value
-    val halfX = 0.5f * x
-    var bits = java.lang.Float.floatToIntBits(x)
-    bits = 0x5f3759df - (bits shr 1)
-    x = java.lang.Float.intBitsToFloat(bits)
-    x *= (1.5f - halfX * x * x)
-    return x
-}
-
-/** Exact distance from a point to an axis-aligned box. Inputs are relative to the box's own center. */
-fun boxDistance(relX: Float, relY: Float, relZ: Float, halfWidth: Float, halfHeight: Float, halfDepth: Float): Float {
-    val qx = abs(relX) - halfWidth
-    val qy = abs(relY) - halfHeight
-    val qz = abs(relZ) - halfDepth
-    val ox = max(qx, 0f)
-    val oy = max(qy, 0f)
-    val oz = max(qz, 0f)
-    val outside = sqrt(ox * ox + oy * oy + oz * oz)
-    val inside = min(max(qx, max(qy, qz)), 0f)
-    return outside + inside
-}
-
-/** Same as boxDistance but with rounded corners/edges https://iquilezles.org/articles/distfunctions/ */
-fun roundedBoxDistance(relX: Float, relY: Float, relZ: Float, halfWidth: Float, halfHeight: Float, halfDepth: Float, roundingRadius: Float): Float =
-    boxDistance(relX, relY, relZ, halfWidth - roundingRadius, halfHeight - roundingRadius, halfDepth - roundingRadius) - roundingRadius
-
-/** Approximate (lower-bound) distance to an ellipsoid https://iquilezles.org/articles/ellipsoids/. */
-fun ellipsoidDistance(relX: Float, relY: Float, relZ: Float, halfWidth: Float, halfHeight: Float, halfDepth: Float): Float {
-    val px = relX / halfWidth
-    val py = relY / halfHeight
-    val pz = relZ / halfDepth
-    val inverseMagnitude = fastInverseSqrt(px * px + py * py + pz * pz)
-    val trueDistance = sqrt(relX * relX + relY * relY + relZ * relZ)
-    return trueDistance * (1.0f - inverseMagnitude)
-}
-
-/** Distance from a point to one primitive, dispatched by its shape. */
-fun distanceToPrimitive(primitive: FieldPrimitive, sampleX: Float, sampleY: Float, sampleZ: Float, tuning: DistanceFieldTuning): Float {
-    val relX = sampleX - primitive.centerX
-    val relY = sampleY - primitive.centerY
-    val relZ = sampleZ - primitive.centerZ
-    return when (primitive.shape) {
-        PrimitiveShape.BOX -> boxDistance(relX, relY, relZ, primitive.halfWidth, primitive.halfHeight, primitive.halfDepth)
-        PrimitiveShape.ROUNDED_BOX -> roundedBoxDistance(relX, relY, relZ, primitive.halfWidth, primitive.halfHeight, primitive.halfDepth, tuning.roundingRadius)
-        PrimitiveShape.ELLIPSOID -> ellipsoidDistance(relX, relY, relZ, primitive.halfWidth, primitive.halfHeight, primitive.halfDepth)
-    }
-}
-
-///** Normalized quadratic smooth-min https://iquilezles.org/articles/smin/ */
-//fun smoothMinimum(a: Float, b: Float, smoothingRange: Float): Float {
-//    if (smoothingRange <= 0.001f) return min(a, b)
-//    val k = smoothingRange * 4.0f
-//    val h = (0.5f + 0.5f * (b - a) / k).coerceIn(0f, 1f)
-//    return b + (a - b) * h - k * h * (1f - h)
-//}
-//
-///** Folds every primitive's distance together into one field value at a point. */
-//fun sampleField(primitives: List<FieldPrimitive>, sampleX: Float, sampleY: Float, sampleZ: Float, tuning: DistanceFieldTuning): Float {
-//    var result = Float.POSITIVE_INFINITY
-//    for (primitive in primitives) {
-//        val distance = distanceToPrimitive(primitive, sampleX, sampleY, sampleZ, tuning)
-//        result = if (result == Float.POSITIVE_INFINITY) distance else smoothMinimum(result, distance, tuning.smoothingRange)
-//    }
-//    return result
-//}
-
-/** Normalized quadratic smooth-min https://iquilezles.org/articles/smin/ */
-fun smoothMinimum(a: Float, b: Float, smoothingRange: Float): Float {
-    if (smoothingRange <= 0.001f) return min(a, b)
-    val k = smoothingRange * 4.0f
-    val h = (0.5f + 0.5f * (b - a) / k).coerceIn(0f, 1f)
-    return b + (a - b) * h - k * h * (1f - h)
-}
-
-/** Folds nearby primitive distances together into one field value at a point. */
-fun sampleField(primitives: List<FieldPrimitive>, sampleX: Float, sampleY: Float, sampleZ: Float, tuning: DistanceFieldTuning): Float {
-    if (primitives.isEmpty()) return Float.POSITIVE_INFINITY
-
-    val distances = FloatArray(primitives.size) { distanceToPrimitive(primitives[it], sampleX, sampleY, sampleZ, tuning) }
-    val minDistance = distances.min()
-
-    if (tuning.smoothingRange <= 0.001f) return minDistance
-
-    // Anything more than a few blend-widths past the closest primitive is cut - its
-    // contribution would be negligible in a correct blend anyway, but left in, it still
-    // drags the chained result down the more of them there are.
-    val cutoff = tuning.smoothingRange * 3f
-
-    var result = Float.POSITIVE_INFINITY
-    for (distance in distances) {
-        if (distance - minDistance > cutoff) continue
-        result = if (result == Float.POSITIVE_INFINITY) distance else smoothMinimum(result, distance, tuning.smoothingRange)
-    }
-    return result
-}
-
-/** Finite-difference gradient of the field at a point - points away from the surface, magnitude ~1 for a clean field. */
-fun estimateGradient(primitives: List<FieldPrimitive>, point: Vec3, tuning: DistanceFieldTuning, epsilon: Float = 0.05f): Vec3 {
-    val px = point.x.toFloat()
-    val py = point.y.toFloat()
-    val pz = point.z.toFloat()
-
-    val dx = sampleField(primitives, px + epsilon, py, pz, tuning) - sampleField(primitives, px - epsilon, py, pz, tuning)
-    val dy = sampleField(primitives, px, py + epsilon, pz, tuning) - sampleField(primitives, px, py - epsilon, pz, tuning)
-    val dz = sampleField(primitives, px, py, pz + epsilon, tuning) - sampleField(primitives, px, py, pz - epsilon, tuning)
-
-    val gradient = Vec3(dx.toDouble(), dy.toDouble(), dz.toDouble())
-    return if (gradient.lengthSqr() > 1e-8) gradient.normalize() else Vec3(0.0, 1.0, 0.0)
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/riding/util/SdfVisualizer.kt

@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.api.riding.util
-
-import net.minecraft.core.particles.DustParticleOptions
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.phys.AABB
-import net.minecraft.world.phys.Vec3
-import org.joml.Vector3f
-
-/** One shell to draw - a target field value, a color, a particle size. */
-data class DistanceFieldLayer(
-    val isoValue: Float,
-    val color: Vector3f,
-    val particleSize: Float = 1.0f
-)
-
-/**
- * Marches a grid of vertical columns through the field around [center] and spawns a
- * particle everywhere it crosses one of [layers]' target values. Server-side only.
- */
-fun visualizeDistanceField(
-    referenceEntity: Entity,
-    center: Vec3,
-    layers: List<DistanceFieldLayer>,
-    shape: PrimitiveShape = PrimitiveShape.BOX,
-    horizontalRadius: Double = 4.0,
-    verticalRange: Double = 4.0,
-    sampleSpacing: Double = 0.5,
-    marchStep: Double = 0.1,
-    tuning: DistanceFieldTuning = DistanceFieldTuning()
-) {
-    val level = referenceEntity.level()
-    if (level !is ServerLevel) return
-
-    val searchBox = AABB(
-        center.x - horizontalRadius, center.y - verticalRange, center.z - horizontalRadius,
-        center.x + horizontalRadius, center.y, center.z + horizontalRadius
-    )
-
-    val primitives = collectPrimitivesFromBlocks(level, searchBox, shape, includeFluids = true)
-    if (primitives.isEmpty()) return
-
-    var x = -horizontalRadius
-    while (x <= horizontalRadius) {
-        var z = -horizontalRadius
-        while (z <= horizontalRadius) {
-            marchColumn(level, primitives, center, x, z, verticalRange, marchStep, layers, tuning)
-            z += sampleSpacing
-        }
-        x += sampleSpacing
-    }
-}
-
-private fun marchColumn(
-    level: ServerLevel,
-    primitives: List<FieldPrimitive>,
-    center: Vec3,
-    offsetX: Double,
-    offsetZ: Double,
-    verticalRange: Double,
-    marchStep: Double,
-    layers: List<DistanceFieldLayer>,
-    tuning: DistanceFieldTuning
-) {
-    val previousValue = FloatArray(layers.size) { Float.NaN }
-
-    var y = verticalRange
-    while (y >= -verticalRange) {
-        val worldX = (center.x + offsetX).toFloat()
-        val worldY = (center.y + y).toFloat()
-        val worldZ = (center.z + offsetZ).toFloat()
-        val fieldValue = sampleField(primitives, worldX, worldY, worldZ, tuning)
-
-        for (layerIndex in layers.indices) {
-            val layer = layers[layerIndex]
-            val previous = previousValue[layerIndex]
-
-            if (!previous.isNaN() && crossedTarget(previous, fieldValue, layer.isoValue)) {
-                val t = (layer.isoValue - previous) / (fieldValue - previous)
-                val crossingY = (y + marchStep) - marchStep * t
-                spawnLayerParticle(level, center.add(offsetX, crossingY, offsetZ), layer)
-            }
-
-            previousValue[layerIndex] = fieldValue
-        }
-
-        y -= marchStep
-    }
-}
-
-private fun crossedTarget(previous: Float, current: Float, target: Float): Boolean =
-    (previous - target) * (current - target) < 0f
-
-private fun spawnLayerParticle(level: ServerLevel, pos: Vec3, layer: DistanceFieldLayer) {
-    val particle = DustParticleOptions(layer.color, layer.particleSize)
-    level.sendParticles(particle, pos.x, pos.y, pos.z, 1, 0.0, 0.0, 0.0, 0.0)
-}

common/src/main/kotlin/com/cobblemon/mod/common/api/snowstorm/ParticleEvent.kt

@@ -129,7 +129,12 @@ class ParticleEvent(
                 onDespawn = {},
                 getParticleColor = storm.getParticleColor,
                 targetPos = storm.targetPos,
-                runtime = MoLangRuntime().setup(),
+                runtime = MoLangRuntime().setup().also { runtime ->
+                    // Weather sub-emitters share the parent's lifetime condition.
+                    storm.runtime.environment.query.functions["is_weather_active"]?.let {
+                        runtime.environment.query.addFunction("is_weather_active", it)
+                    }
+                },
                 entity = storm.entity
             )
             //The reason this doesn't use the newStorms runtime is that the parent storm can add queries AFTER
@@ -211,4 +216,4 @@ class EventSoundEffect(
             ).apply(instance, ::EventSoundEffect)
         }
     }
-}
+}

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

@@ -10,8 +10,6 @@ package com.cobblemon.mod.common.api.spawning
 
 import com.cobblemon.mod.common.api.spawning.TimeRange.Companion.timeRanges
 import com.cobblemon.mod.common.api.spawning.condition.SpawningCondition
-import com.cobblemon.mod.common.util.lang
-import net.minecraft.network.chat.MutableComponent
 import com.cobblemon.mod.common.util.adapters.IntRangesAdapter
 
 /**
@@ -51,25 +49,4 @@ class TimeRange : IntRanges {
 
     constructor() : super()
     constructor(vararg ranges: IntRange) : super(*ranges)
-
-    fun displayName(): MutableComponent? {
-        val key = timeRanges.entries.firstOrNull { entry -> this == entry.value }?.key ?: return null
-        return lang("ui.time_range.$key")
-    }
-
-    override fun equals(other: Any?): Boolean {
-        if (this === other) return true
-        if (other !is TimeRange) return false
-
-        if (other.ranges.size != this.ranges.size) return false
-        other.ranges.forEachIndexed { index, otherRange ->
-            if (this.ranges[index] != otherRange) return false
-        }
-
-        return true
-    }
-
-    override fun hashCode(): Int {
-        return ranges.hashCode()
-    }
 }

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

@@ -8,8 +8,6 @@
 
 package com.cobblemon.mod.common.api.spawning.condition
 
-import com.cobblemon.mod.common.util.lang
-import net.minecraft.network.chat.MutableComponent
 import net.minecraft.world.level.Level
 
 /**
@@ -44,7 +42,4 @@ enum class MoonPhase {
         fun ofWorld(world: Level): MoonPhase = VALUES[world.moonPhase]
     }
 
-    fun displayName(): MutableComponent {
-        return lang("ui.moon_phase.${this.name.lowercase()}")
-    }
 }

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

@@ -27,7 +27,6 @@ import com.cobblemon.mod.common.entity.pokemon.PokemonEntity
 import com.cobblemon.mod.common.util.isBoxLoaded
 import com.cobblemon.mod.common.util.removeIf
 import com.cobblemon.mod.common.util.squeezeWithinBounds
-import com.cobblemon.mod.common.util.toBlockPos
 import com.cobblemon.mod.common.util.toVec3f
 import com.cobblemon.mod.common.util.weightedSelection
 import kotlin.math.max
@@ -191,60 +190,73 @@ interface Spawner {
     }
 
     fun isValidStartPoint(world: Level, chunk: ChunkAccess, startPos: BlockPos.MutableBlockPos): Boolean {
-        val abovePos = startPos.above()
-        if (!world.isLoaded(startPos) || !world.isLoaded(abovePos)) {
+        val y = startPos.y
+        if (!world.isLoaded(startPos) || !world.isLoaded(startPos.setY(y + 1))) {
             return false
         }
-        val mid = chunk.getBlockState(startPos)
-        val above = chunk.getBlockState(abovePos)
 
-        return above.isPathfindable(PathComputationType.AIR) && mid.isAir
+        val mid = chunk.getBlockState(startPos.setY(y))
+        val above = chunk.getBlockState(startPos.setY(y + 1))
+
+        // Above must be non-solid
+        if (!above.isPathfindable(PathComputationType.AIR)) {
+            return false
+        }
+
+        // Position must be non-air
+        if (mid.isAir) {
+            return false
+        }
+
+        return true
     }
 
     fun constrainArea(area: SpawningZoneInput): SpawningZoneInput? {
-        val world = area.world
-        val centerPos = area.getCenter().toBlockPos()
+        val basePos = BlockPos.MutableBlockPos(area.baseX, area.baseY, area.baseZ)
+        val originalY = area.baseY
+
+        val (chunkX, chunkZ) = Pair(SectionPos.blockToSectionCoord(area.baseX), SectionPos.blockToSectionCoord(area.baseZ))
 
-        val (centerChunkX, centerChunkZ) = Pair(SectionPos.blockToSectionCoord(centerPos.x), SectionPos.blockToSectionCoord(centerPos.z))
         // if the chunk isn't loaded, we don't want to go further & we don't want the getChunk function below to load/create the chunk.
-        if (!world.areEntitiesLoaded(ChunkPos.asLong(centerChunkX, centerChunkZ))) return null
+        if (!area.world.areEntitiesLoaded(ChunkPos.asLong(chunkX, chunkZ))) return null
 
-        val chunk = world.getChunk(centerChunkX, centerChunkZ, ChunkStatus.FULL) ?: return null
+        val chunk = area.world.getChunk(chunkX, chunkZ, ChunkStatus.FULL) ?: return null
 
-        val probePos = centerPos.mutable()
-        var validY = if (isValidStartPoint(world, chunk, probePos)) centerPos.y else null
+        var valid = isValidStartPoint(area.world, chunk, basePos)
 
-        if (validY == null) {
-            for (offset in 1..Cobblemon.config.maxVerticalCorrectionBlocks) {
-                if (isValidStartPoint(world, chunk, probePos.set(centerPos.x, centerPos.y + offset, centerPos.z))) {
-                    validY = centerPos.y + offset
+        if (!valid) {
+            var offset = 1
+            do {
+                if (isValidStartPoint(area.world, chunk, basePos.setY(originalY + offset))) {
+                    valid = true
+                    basePos.y = originalY + offset
                     break
-                } else if (isValidStartPoint(world, chunk, probePos.set(centerPos.x, centerPos.y - offset, centerPos.z))) {
-                    validY = centerPos.y - offset
+                } else if (isValidStartPoint(area.world, chunk, basePos.setY(originalY - offset))) {
+                    valid = true
+                    basePos.y = originalY - offset
                     break
                 }
-            }
+                offset++
+            } while (offset <= Cobblemon.config.maxVerticalCorrectionBlocks)
         }
-        val targetY = validY ?: return null
-        val newBaseY = (targetY - (area.height / 2)).coerceIn(world.minBuildHeight, world.maxBuildHeight)
-        val minPos = world.squeezeWithinBounds(BlockPos(area.baseX, newBaseY, area.baseZ))
-        val maxPos = world.squeezeWithinBounds(BlockPos(area.baseX + area.length, newBaseY + area.height, area.baseZ + area.width))
 
-        val finalBox = AABB(
-            minPos.x.toDouble(), minPos.y.toDouble(), minPos.z.toDouble(),
-            maxPos.x.toDouble(), maxPos.y.toDouble(), maxPos.z.toDouble()
-        )
-        if (minPos.x < maxPos.x && minPos.y < maxPos.y && minPos.z < maxPos.z && world.isBoxLoaded(finalBox)) {
-            return SpawningZoneInput(
-                cause = area.cause,
-                world = world,
-                baseX = minPos.x,
-                baseY = minPos.y,
-                baseZ = minPos.z,
-                length = maxPos.x - minPos.x,
-                height = maxPos.y - minPos.y,
-                width = maxPos.z - minPos.z
-            )
+        if (valid) {
+            val min = area.world.squeezeWithinBounds(basePos)
+            val max = area.world.squeezeWithinBounds(basePos.move(area.length, area.height, area.width))
+            if (area.world.isLoaded(min) && area.world.isLoaded(max) &&
+                min.x < max.x && min.y < max.y && min.z < max.z
+            ) {
+                return SpawningZoneInput(
+                    cause = area.cause,
+                    world = area.world,
+                    baseX = min.x,
+                    baseY = min.y,
+                    baseZ = min.z,
+                    length = max.x - min.x,
+                    height = max.y - min.y,
+                    width = max.z - min.z
+                )
+            }
         }
 
         return null

common/src/main/kotlin/com/cobblemon/mod/common/api/types/ElementalType.kt

@@ -34,7 +34,6 @@ class ElementalType(
     val resourceLocation: ResourceLocation = ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, "ui/types.png"),
     val showdownId: String = ShowdownIdentifiable.REGEX.replace(name.lowercase(), ""),
     val typeGem: ResourceLocation = ResourceLocation.fromNamespaceAndPath(Cobblemon.MODID, showdownId + "_gem"),
-    val order: Int = 1000
     ) : ShowdownIdentifiable {
 
     override fun showdownId(): String {

common/src/main/kotlin/com/cobblemon/mod/common/api/types/ElementalTypes.kt

@@ -25,8 +25,7 @@ object ElementalTypes {
         hue = 0xE8E8DA,
         textureXMultiplier = 0,
         primaryColor = 0x8FA689,
-        secondaryColor = 0xFFFBE2,
-        order = 0
+        secondaryColor = 0xFFFBE2
     )
 
     @JvmField
@@ -36,8 +35,7 @@ object ElementalTypes {
         hue = 0xFF6E21,
         textureXMultiplier = 1,
         primaryColor = 0xF92D2D,
-        secondaryColor = 0xF99B1D,
-        order = 1
+        secondaryColor = 0xF99B1D
     )
 
     @JvmField
@@ -47,8 +45,7 @@ object ElementalTypes {
         hue = 0x3FA5FF,
         textureXMultiplier = 2,
         primaryColor = 0x377AF6,
-        secondaryColor = 0x50DDF9,
-        order = 2
+        secondaryColor = 0x50DDF9
     )
 
     @JvmField
@@ -58,8 +55,7 @@ object ElementalTypes {
         hue = 0x62D14F,
         textureXMultiplier = 3,
         primaryColor = 0x0EAE95,
-        secondaryColor = 0xC6F554,
-        order = 3
+        secondaryColor = 0xC6F554
     )
 
     @JvmField
@@ -69,8 +65,7 @@ object ElementalTypes {
         hue = 0xFFD314,
         textureXMultiplier = 4,
         primaryColor = 0xF7AB19,
-        secondaryColor = 0xFFF257,
-        order = 4
+        secondaryColor = 0xFFF257
     )
 
     @JvmField
@@ -80,8 +75,7 @@ object ElementalTypes {
         hue = 0x54F2F2,
         textureXMultiplier = 5,
         primaryColor = 0x41BAED,
-        secondaryColor = 0x91F4F9,
-        order = 5
+        secondaryColor = 0x91F4F9
     )
 
     @JvmField
@@ -91,8 +85,7 @@ object ElementalTypes {
         hue = 0xEF565D,
         textureXMultiplier = 6,
         primaryColor = 0xC8356B,
-        secondaryColor = 0xF36A3F,
-        order = 6
+        secondaryColor = 0xF36A3F
     )
 
     @JvmField
@@ -102,8 +95,7 @@ object ElementalTypes {
         hue = 0xD651FF,
         textureXMultiplier = 7,
         primaryColor = 0x7B41DD,
-        secondaryColor = 0xE568F4,
-        order = 7
+        secondaryColor = 0xE568F4
     )
 
     @JvmField
@@ -113,8 +105,7 @@ object ElementalTypes {
         hue = 0xF4A453,
         textureXMultiplier = 8,
         primaryColor = 0xE08835,
-        secondaryColor = 0xFFD057,
-        order = 8
+        secondaryColor = 0xFFD057
     )
 
     @JvmField
@@ -124,8 +115,7 @@ object ElementalTypes {
         hue = 0xB8B2FF,
         textureXMultiplier = 9,
         primaryColor = 0x6083F6,
-        secondaryColor = 0xD5CCFA,
-        order = 9
+        secondaryColor = 0xD5CCFA
     )
 
     @JvmField
@@ -135,8 +125,7 @@ object ElementalTypes {
         hue = 0xFF5E9E,
         textureXMultiplier = 10,
         primaryColor = 0xE553CE,
-        secondaryColor = 0xF69DD5,
-        order = 10
+        secondaryColor = 0xF69DD5
     )
 
     @JvmField
@@ -146,8 +135,7 @@ object ElementalTypes {
         hue = 0xD3D319,
         textureXMultiplier = 11,
         primaryColor = 0x9FBE1B,
-        secondaryColor = 0xE9FB5B,
-        order = 11
+        secondaryColor = 0xE9FB5B
     )
 
     @JvmField
@@ -157,8 +145,7 @@ object ElementalTypes {
         hue = 0xB7A16E,
         textureXMultiplier = 12,
         primaryColor = 0x9F814A,
-        secondaryColor = 0xEECB7A,
-        order = 12
+        secondaryColor = 0xEECB7A
     )
 
     @JvmField
@@ -168,8 +155,7 @@ object ElementalTypes {
         hue = 0x9C80F7,
         textureXMultiplier = 13,
         primaryColor = 0x4F57DD,
-        secondaryColor = 0xC182F1,
-        order = 13
+        secondaryColor = 0xC182F1
     )
 
     @JvmField
@@ -179,8 +165,7 @@ object ElementalTypes {
         hue = 0x7580FF,
         textureXMultiplier = 14,
         primaryColor = 0x4E68E2,
-        secondaryColor = 0x47C7F7,
-        order = 14
+        secondaryColor = 0x47C7F7
     )
 
     @JvmField
@@ -190,8 +175,7 @@ object ElementalTypes {
         hue = 0x587DA0,
         textureXMultiplier = 15,
         primaryColor = 0x465B99,
-        secondaryColor = 0x689EBF,
-        order = 15
+        secondaryColor = 0x689EBF
     )
 
     @JvmField
@@ -201,8 +185,7 @@ object ElementalTypes {
         hue = 0xABD1F4,
         textureXMultiplier = 16,
         primaryColor = 0x628CB9,
-        secondaryColor = 0xD6F7F3,
-        order = 16
+        secondaryColor = 0xD6F7F3
     )
 
     @JvmField
@@ -212,21 +195,18 @@ object ElementalTypes {
         hue = 0xFF7FE5,
         textureXMultiplier = 17,
         primaryColor = 0xE2678C,
-        secondaryColor = 0xF5A7B7,
-        order = 17
+        secondaryColor = 0xF5A7B7
     )
 
     @JvmStatic
-    @JvmOverloads
-    fun register(name: String, displayName: MutableComponent, hue: Int, textureXMultiplier: Int, primaryColor: Int, secondaryColor: Int, order: Int = 1000): ElementalType {
+    fun register(name: String, displayName: MutableComponent, hue: Int, textureXMultiplier: Int, primaryColor: Int, secondaryColor: Int): ElementalType {
         return ElementalType(
             name = name,
             displayName = displayName,
             hue = hue,
             textureXMultiplier = textureXMultiplier,
             primaryColor =  primaryColor,
-            secondaryColor = secondaryColor,
-            order = order
+            secondaryColor = secondaryColor
         ).also {
             allTypes.add(it)
         }

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

@@ -28,7 +28,11 @@ data class BattleFormat(
     var ruleSet: Set<String> = setOf(),
     val gen: Int = 9,
     var adjustLevel: Int = -1, // Stop gap rule before a more general system for rules enforced by Cobblemon is implemented.
+    val isOpenTeamSheet: Boolean = false,
 ) {
+    val hasTeamPreview: Boolean
+        get() = ruleSet.any { it.equals(BattleRules.TEAM_PREVIEW, ignoreCase = true) || it.equals("teampreview", ignoreCase = true) }
+
     companion object {
         fun setBattleRules(
             battleFormat: BattleFormat,
@@ -121,4 +125,4 @@ data class BattleFormat(
             }
         """.trimIndent().replace("\n", "")
     }
-}
+}

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

@@ -211,7 +211,16 @@ object ShowdownInterpreter {
     }
 
     // Broadcasts a generic lang to notify players of ability activations (effects are broadcasted separately)
-    fun broadcastAbility(battle: PokemonBattle, effect: Effect, pokemon: BattlePokemon) {
+    @JvmOverloads
+    fun broadcastAbility(battle: PokemonBattle, effect: Effect, pokemon: BattlePokemon, revealedAbility: Effect = effect) {
+        // Direct -ability messages omit the ability: prefix. A copied ability can also differ
+        // from the effect announced in chat (for example, Trace).
+        if (revealedAbility.type == Effect.Type.ABILITY || revealedAbility.type == Effect.Type.PURE) {
+            battle.dispatchGo {
+                pokemon.revealedAbility = revealedAbility.id
+                pokemon.sendUpdate()
+            }
+        }
         battle.dispatchWaiting(0.5F) {
             val lang = battleLang("ability.generic", pokemon.getName(), effect.typelessData).yellow()
             battle.broadcastChatMessage(lang)
@@ -321,4 +330,4 @@ object ShowdownInterpreter {
     fun registerSideInstructionParser(id: String, callback: (PokemonBattle, BattleActor, InstructionSet, BattleMessage) -> InterpreterInstruction) {
         sideInstructionParser[id] = callback
     }
-}
+}

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

@@ -0,0 +1,151 @@
+/*
+ * 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.battles
+
+import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
+import com.cobblemon.mod.common.net.messages.client.battle.CloseTeamPreviewPacket
+import com.cobblemon.mod.common.net.messages.client.battle.TeamPreviewPacket
+import com.cobblemon.mod.common.pokemon.Pokemon
+import com.cobblemon.mod.common.util.getPlayer
+import com.cobblemon.mod.common.util.party
+import net.minecraft.network.chat.Component
+import net.minecraft.server.level.ServerPlayer
+import java.time.Duration
+import java.time.Instant
+import java.util.UUID
+
+object TeamPreviewManager {
+    private val previews = mutableListOf<TeamPreview>()
+    val TEAM_PREVIEW_TIME_SECONDS = 60
+
+    fun tick() {
+        val expired = previews.filter { Duration.between(it.started, Instant.now()).seconds >= TEAM_PREVIEW_TIME_SECONDS }
+        expired.forEach { cancel(it) }
+
+        val ready = previews.filter {
+            hasEligibleSelections(it.sideA) && hasEligibleSelections(it.sideB)
+        }
+        ready.forEach { start(it) }
+    }
+
+    fun add(sideA: TeamPreviewSide, sideB: TeamPreviewSide, openTeamSheet: Boolean, onStart: (TeamPreview) -> Unit, onCancel: (TeamPreview) -> Unit) {
+        require(sideA.uuid != sideB.uuid) { "A team preview requires two distinct participants" }
+        require(listOf(sideA, sideB).all { it.neededSelections in 1..it.party.count { pokemon -> pokemon != null } }) {
+            "Each side must be able to fill its requested selection"
+        }
+        if (previews.any { it.sideA.uuid == sideA.uuid || it.sideB.uuid == sideA.uuid || it.sideA.uuid == sideB.uuid || it.sideB.uuid == sideB.uuid }) return
+        val now = Instant.now()
+        previews.add(TeamPreview(sideA, sideB, now, onStart, onCancel))
+        if (sideA.isPlayer) {
+            sideA.uuid.getPlayer()?.sendPacket(
+                TeamPreviewPacket(
+                    sideA.neededSelections,
+                    sideA.party,
+                    sideB.party,
+                    openTeamSheet,
+                    now.plusSeconds(TEAM_PREVIEW_TIME_SECONDS.toLong()),
+                    sideB.name
+                )
+            )
+        }
+        if (sideB.isPlayer) {
+            sideB.uuid.getPlayer()?.sendPacket(
+                TeamPreviewPacket(
+                    sideB.neededSelections,
+                    sideB.party,
+                    sideA.party,
+                    openTeamSheet,
+                    now.plusSeconds(TEAM_PREVIEW_TIME_SECONDS.toLong()),
+                    sideA.name
+                )
+            )
+        }
+    }
+
+    fun clear() {
+        previews.toList().forEach { cancel(it) }
+    }
+
+    fun remove(player: ServerPlayer) {
+        val preview = previews.firstOrNull { it.sideA.isPlayer && it.sideA.uuid == player.uuid || it.sideB.isPlayer && it.sideB.uuid == player.uuid } ?: return
+        cancel(preview)
+    }
+
+    fun cancel(preview: TeamPreview) {
+        if (!previews.remove(preview)) return
+        if (preview.sideA.isPlayer) {
+            preview.sideA.uuid.getPlayer()?.sendPacket(CloseTeamPreviewPacket())
+        }
+        if (preview.sideB.isPlayer) {
+            preview.sideB.uuid.getPlayer()?.sendPacket(CloseTeamPreviewPacket())
+        }
+        preview.onCancel(preview)
+    }
+
+    fun start(preview: TeamPreview) {
+        if (!previews.remove(preview)) return
+        if (preview.sideA.isPlayer) {
+            preview.sideA.uuid.getPlayer()?.sendPacket(CloseTeamPreviewPacket())
+        }
+        if (preview.sideB.isPlayer) {
+            preview.sideB.uuid.getPlayer()?.sendPacket(CloseTeamPreviewPacket())
+        }
+        preview.onStart(preview)
+    }
+
+    fun changeSelections(uuid: UUID, selections: Set<Int>) {
+        val preview = previews.firstOrNull { it.sideA.uuid == uuid || it.sideB.uuid == uuid } ?: return
+        val isSideA = preview.sideA.uuid == uuid
+        val side = if (isSideA) preview.sideA else preview.sideB
+        if (!side.isPlayer || !isValidSelection(side.party, selections, side.neededSelections, requireComplete = false)) return
+        previews.remove(preview)
+        if (isSideA) {
+            previews.add(
+                preview.copy(
+                    sideA = preview.sideA.copy(selections = selections.toSet()),
+                )
+            )
+        }
+        else {
+            previews.add(
+                preview.copy(
+                    sideB = preview.sideB.copy(selections = selections.toSet()),
+                )
+            )
+        }
+    }
+
+    fun hasEligibleSelections(side: TeamPreviewSide): Boolean =
+        isValidSelection(side.party, side.selections, side.neededSelections)
+
+    internal fun isValidSelection(party: List<*>, selections: Set<Int>, needed: Int, requireComplete: Boolean = true): Boolean {
+        if (needed < 1 || selections.size > needed || (requireComplete && selections.size != needed)) return false
+        return selections.all { it in party.indices && party[it] != null }
+    }
+}
+
+data class TeamPreview(
+    val sideA: TeamPreviewSide,
+    val sideB: TeamPreviewSide,
+    val started: Instant,
+    val onStart: (TeamPreview) -> Unit,
+    val onCancel: (TeamPreview) -> Unit
+)
+
+data class TeamPreviewSide(
+    val uuid: UUID,
+    val name: Component,
+    val isPlayer: Boolean,
+    val party: List<Pokemon?>,
+    val selections: Set<Int>,
+    val neededSelections: Int
+) {
+    constructor(player: ServerPlayer, neededSelections: Int): this(player.uuid, player.name, true, player.party().toGappyList(), emptySet(), neededSelections)
+    constructor(pokemon: Pokemon, name: Component? = null): this(pokemon.uuid, name ?: pokemon.getDisplayName(), false, listOf(null, null, pokemon, null, null, null, null), setOf(2), 1)
+}

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.battles.actor
 
+import com.cobblemon.mod.common.battles.timers.PlayerBattleTimer
+
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonNetwork
 import com.cobblemon.mod.common.api.battles.model.actor.ActorType
@@ -33,6 +35,8 @@ class PlayerBattleActor(
     pokemonList: List<BattlePokemon>,
 ) : BattleActor(uuid, pokemonList.toMutableList()), EntityBackedBattleActor<ServerPlayer> {
 
+    var timer: PlayerBattleTimer? = null
+
     override val initialPos: Vec3?
     override val entity: ServerPlayer?
         get() = this.uuid.getPlayer()

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

@@ -37,7 +37,7 @@ class AbilityInstruction(val instructionSet: InstructionSet, val message: Battle
         val optionalPokemon = message.battlePokemonFromOptional(battle)
 
         // If there is an optional effect causing the activation, broadcast that instead of the standard effect
-        ShowdownInterpreter.broadcastAbility(battle, optionalEffect ?: effect, pokemon)
+        ShowdownInterpreter.broadcastAbility(battle, optionalEffect ?: effect, pokemon, revealedAbility = effect)
 
         battle.dispatch {
             val pokemonName = pokemon.getName()
@@ -63,4 +63,4 @@ class AbilityInstruction(val instructionSet: InstructionSet, val message: Battle
             else return@dispatch GO
         }
     }
-}
+}

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

@@ -83,6 +83,10 @@ class BoostInstruction(battle: PokemonBattle, val message: BattleMessage, val is
             }
             battle.broadcastChatMessage(lang)
 
+            val changedStat = Stats.getStat(statKey)
+            val delta = if (isBoost) stages else -stages
+            pokemon.statChanges[changedStat] = ((pokemon.statChanges[changedStat] ?: 0) + delta).coerceIn(-6, 6)
+            pokemon.sendUpdate()
             val boostBucket = if (isBoost) BattleContext.Type.BOOST else BattleContext.Type.UNBOOST
             val context = ShowdownInterpreter.getContextFromAction(message, boostBucket, battle)
             // TODO: replace with context that tracks detailed information such as # of stages

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

@@ -26,6 +26,8 @@ class ClearAllBoostInstruction(val message: BattleMessage): InterpreterInstructi
     override fun invoke(battle: PokemonBattle) {
         battle.dispatchWaiting(1.5F) {
             battle.activePokemon.forEach {
+                it.battlePokemon?.statChanges?.clear()
+                it.battlePokemon?.sendUpdate()
                 it.battlePokemon?.contextManager?.clear(BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)
             }
             battle.broadcastChatMessage(battleLang("clearallboost"))

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

@@ -30,6 +30,8 @@ class ClearBoostInstruction(val message: BattleMessage): InterpreterInstruction
             val pokemonName = battlePokemon.getName()
             val lang = battleLang("clearboost", pokemonName)
             battle.broadcastChatMessage(lang)
+            battlePokemon.statChanges.clear()
+            battlePokemon.sendUpdate()
             battlePokemon.contextManager.clear(BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)
             battle.minorBattleActions[battlePokemon.uuid] = message
         }

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

@@ -36,6 +36,8 @@ class ClearNegativeBoostInstruction(val message: BattleMessage): InterpreterInst
                 battle.broadcastChatMessage(lang)
             }
 
+            battlePokemon.statChanges.entries.removeIf { it.value < 0 }
+            battlePokemon.sendUpdate()
             battlePokemon.contextManager.clear(BattleContext.Type.UNBOOST)
             battle.minorBattleActions[battlePokemon.uuid] = message
         }

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

@@ -32,6 +32,10 @@ class CopyBoostInstruction(val message: BattleMessage): InterpreterInstruction {
             val lang = battleLang("copyboost.generic", pokemonName, targetPokemonName)
             battle.broadcastChatMessage(lang)
 
+            val changes = targetPokemon.statChanges.toMap()
+            pokemon.statChanges.clear()
+            pokemon.statChanges.putAll(changes)
+            pokemon.sendUpdate()
             pokemon.contextManager.copy(targetPokemon.contextManager, BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)
             battle.minorBattleActions[pokemon.uuid] = message
         }

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

@@ -155,6 +155,13 @@ class DamageInstruction(
 
             val newHealthRatio: Float
             val remainingHealth = newHealth.split("/")[0].toInt()
+            val previousHealth = battlePokemon.effectedPokemon.currentHealth
+            val damageDealt = (previousHealth - remainingHealth).coerceAtLeast(0)
+            val maxHp = battlePokemon.effectedPokemon.maxHealth
+            if (damageDealt > 0 && maxHp > 0) {
+                val percent = Math.round(damageDealt.toFloat() / maxHp * 100F).coerceAtLeast(1)
+                battle.broadcastChatMessage(battleLang("damage_dealt", battlePokemon.getName(), "$percent%"))
+            }
 
             if (effect != null) {
                 val lang = when (effect.id) {
@@ -222,4 +229,4 @@ class DamageInstruction(
         }
     }
 
-}
+}

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

@@ -35,6 +35,8 @@ class EndItemInstruction(val message: BattleMessage): InterpreterInstruction {
             val battlePokemon = message.battlePokemon(0, battle) ?: return@dispatchWaiting
             val itemEffect = message.effectAt(1) ?: return@dispatchWaiting
             battlePokemon.heldItemManager.handleEndInstruction(battlePokemon, battle, message)
+            battlePokemon.revealedHeldItem = net.minecraft.world.item.ItemStack.EMPTY
+            battlePokemon.sendUpdate()
             battle.minorBattleActions[battlePokemon.uuid] = message
             battlePokemon.contextManager.remove(itemEffect.id, BattleContext.Type.ITEM)
             if (message.hasOptionalArgument("eat")) {

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.battles.interpreter.instructions
 
+import com.cobblemon.mod.common.net.messages.client.battle.BattleActorTeamPacket
+
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
@@ -58,6 +60,11 @@ class InitializeInstruction(val instructionSet: InstructionSet, val message: Bat
 
         battle.actors.forEach { actor ->
             actor.sendUpdate(BattleSetTeamPokemonPacket(actor.pokemonList.map { it.effectedPokemon }))
+            battle.actors.forEach { viewer ->
+                viewer.sendUpdate(BattleActorTeamPacket(actor.uuid, actor.pokemonList.map {
+                    it.toBattleDTO(ally = viewer == actor)
+                }))
+            }
             val req = actor.request ?: return@forEach
             actor.sendUpdate(BattleQueueRequestPacket(req))
         }
@@ -68,8 +75,10 @@ class InitializeInstruction(val instructionSet: InstructionSet, val message: Bat
 
         battle.dispatchGo {
             battle.started = true
+            battle.activePokemon.mapNotNull { it.battlePokemon }.forEach { it.sendUpdate() }
+            battle.notifyAllOfUpdates()
             battle.side1.playCries()
             afterOnServer(seconds = 1.0F) { battle.side2.playCries() }
         }
     }
-}
+}

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

@@ -28,6 +28,8 @@ class InvertBoostInstruction(val message: BattleMessage): InterpreterInstruction
     override fun invoke(battle: PokemonBattle) {
         battle.dispatchWaiting {
             val pokemon = message.battlePokemon(0, battle) ?: return@dispatchWaiting
+            pokemon.statChanges.replaceAll { _, value -> -value }
+            pokemon.sendUpdate()
             val name = pokemon.getName()
             battle.broadcastChatMessage(battleLang("invertboost", name))
 

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

@@ -34,6 +34,8 @@ class ItemInstruction(val message: BattleMessage): InterpreterInstruction {
         battle.dispatchWaiting(1.5F) {
             val battlePokemon = message.battlePokemon(0, battle) ?: return@dispatchWaiting
             battlePokemon.heldItemManager.handleStartInstruction(battlePokemon, battle, message)
+            battlePokemon.revealedHeldItem = battlePokemon.effectedPokemon.heldItem.copy()
+            battlePokemon.sendUpdate()
             battle.minorBattleActions[battlePokemon.uuid] = message
             battlePokemon.contextManager.add(ShowdownInterpreter.getContextFromAction(message, BattleContext.Type.ITEM, battle))
         }

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.battles.interpreter.instructions
 
+import com.cobblemon.mod.common.net.messages.client.battle.MoveDTO
+
 import com.bedrockk.molang.runtime.MoLangRuntime
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
@@ -74,6 +76,14 @@ class MoveInstruction(
         battle.dispatch { UntilDispatch { instructionSet.getMostRecentInstruction<MoveInstruction>(this)?.future?.isDone != false } }
 
         battle.dispatch {
+            val knownMove = userPokemon.revealedMoves.firstOrNull { it?.move == move.displayName }
+            if (knownMove != null) {
+                knownMove.timesUsed++
+            } else {
+                val slot = userPokemon.revealedMoves.indexOfFirst { it == null }
+                if (slot >= 0) userPokemon.revealedMoves[slot] = MoveDTO(move.displayName, 1)
+            }
+            userPokemon.sendUpdate()
             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

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

@@ -19,6 +19,13 @@ import com.cobblemon.mod.common.battles.dispatch.InterpreterInstruction
  */
 object PostUpdateInstruction : InterpreterInstruction {
     override fun invoke(battle: PokemonBattle) {
-        battle.dispatchGo { battle.actors.forEach { it.postUpdate() } }
+        battle.dispatchGo {
+            battle.actors.forEach { it.postUpdate() }
+            battle.notifyAllOfUpdates()
+            val viewers = battle.actors.flatMap { it.getPlayerUUIDs() } + battle.spectators
+            battle.actors.forEach { actor ->
+                actor.pokemonList.forEach { it.updateBattleActorInformation(viewers) }
+            }
+        }
     }
 }

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.battles.interpreter.instructions
 
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+
 import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
 import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
@@ -27,6 +29,12 @@ class SetBoostInstruction(val message: BattleMessage): InterpreterInstruction {
     override fun invoke(battle: PokemonBattle) {
         battle.dispatchWaiting(1.5F) {
             val pokemon = message.battlePokemon(0, battle) ?: return@dispatchWaiting
+            val stat = message.argumentAt(1)?.let { Stats.getStat(it) }
+            val amount = message.argumentAt(2)?.toIntOrNull()
+            if (stat != null && amount != null) {
+                pokemon.statChanges[stat] = amount.coerceIn(-6, 6)
+                pokemon.sendUpdate()
+            }
             val pokemonName = pokemon.getName()
             val effectID = message.effect()?.id ?: return@dispatchWaiting
             val lang = battleLang("setboost.$effectID", pokemonName)

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

@@ -8,6 +8,8 @@
 
 package com.cobblemon.mod.common.battles.interpreter.instructions
 
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+
 import com.cobblemon.mod.common.api.battles.interpreter.BattleContext
 import com.cobblemon.mod.common.api.battles.interpreter.BattleMessage
 import com.cobblemon.mod.common.api.battles.model.PokemonBattle
@@ -29,6 +31,15 @@ class SwapBoostInstruction(val message: BattleMessage): InterpreterInstruction {
             val pokemonName = pokemon.getName()
             val targetPokemon = message.battlePokemon(1, battle) ?: return@dispatchWaiting
             val targetPokemonName = targetPokemon.getName()
+            val stats = message.argumentAt(2)?.split(',')?.map { Stats.getStat(it.trim()) }
+                ?: (pokemon.statChanges.keys + targetPokemon.statChanges.keys).toList()
+            stats.forEach { stat ->
+                val previous = pokemon.statChanges[stat] ?: 0
+                pokemon.statChanges[stat] = targetPokemon.statChanges[stat] ?: 0
+                targetPokemon.statChanges[stat] = previous
+            }
+            pokemon.sendUpdate()
+            targetPokemon.sendUpdate()
             val effectID = message.effect()?.id ?: return@dispatchWaiting
             val lang = when (effectID) {
                 "guardswap", "powerswap", "heartswap" -> battleLang("swapboost.$effectID", pokemonName)

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

@@ -129,6 +129,14 @@ class SwitchInstruction(val instructionSet: InstructionSet, val battleActor: Bat
 
                 activePokemon.battlePokemon?.let { oldPokemon ->
                     if (publicMessage.effect()?.id == "batonpass") oldPokemon.contextManager.swap(pokemon.contextManager, BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)
+                    pokemon.statChanges.clear()
+                    if (publicMessage.effect()?.id == "batonpass") pokemon.statChanges.putAll(oldPokemon.statChanges)
+                    oldPokemon.statChanges.clear()
+                    if (oldPokemon.transformed != null) {
+                        oldPokemon.revealedMoves.indices.forEach { oldPokemon.revealedMoves[it] = null }
+                        oldPokemon.revealedAbility = null
+                    }
+                    oldPokemon.transformed = null
                     oldPokemon.contextManager.clear(BattleContext.Type.VOLATILE, BattleContext.Type.BOOST, BattleContext.Type.UNBOOST)
                     battle.majorBattleActions[oldPokemon.uuid] = publicMessage
 
@@ -215,6 +223,8 @@ class SwitchInstruction(val instructionSet: InstructionSet, val battleActor: Bat
         }
 
         private fun broadcastSwitch(battle: PokemonBattle, actor: BattleActor, newPokemon: BattlePokemon, illusion: BattlePokemon?) {
+            // The active slot and its illusion are now set, so reveal the identity that entered battle.
+            newPokemon.sendUpdate()
             val publicPokemon = (illusion ?: newPokemon).effectedPokemon
             val publicLang = publicPokemon.nickname?.let { nickname ->
                 battleLang("switch.other.nickname", actor.getName(), nickname, publicPokemon.species.translatedName)
@@ -229,4 +239,4 @@ class SwitchInstruction(val instructionSet: InstructionSet, val battleActor: Bat
         }
     }
 
-}
+}

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

@@ -30,6 +30,8 @@ class TerastallizeInstruction(val message: BattleMessage): InterpreterInstructio
         val battlePokemon = message.battlePokemon(0, battle) ?: return
         val type = message.effectAt(1)?.let { TeraTypes.get(it.id) } ?: return
         battle.dispatchWaiting {
+            battlePokemon.terastallized = type
+            battlePokemon.sendUpdate()
             val pokemonName = battlePokemon.getName()
             battle.broadcastChatMessage(battleLang("terastallize", pokemonName, type.displayName).yellow())
             CobblemonEvents.TERASTALLIZATION.post(TerastallizationEvent(battle, battlePokemon, type))

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

@@ -46,6 +46,16 @@ class TransformInstruction(val battle: PokemonBattle, val message: BattleMessage
         }
 
         battle.dispatchWaiting {
+            pokemon.transformed = targetPokemon
+            pokemon.statChanges.clear()
+            pokemon.statChanges.putAll(targetPokemon.statChanges)
+            for (index in pokemon.revealedMoves.indices) {
+                pokemon.revealedMoves[index] = targetPokemon.moveSet.get(index)?.let {
+                    com.cobblemon.mod.common.net.messages.client.battle.MoveDTO(it.displayName, 0)
+                }
+            }
+            pokemon.revealedAbility = targetPokemon.effectedPokemon.ability.name
+            pokemon.sendUpdate()
             val mock = pokemon.entity?.effects?.mockEffect?.mock
             val pokemonName = pokemon.getName()
             val targetPokemonName = targetPokemon.getName()
@@ -63,4 +73,4 @@ class TransformInstruction(val battle: PokemonBattle, val message: BattleMessage
             battle.minorBattleActions[pokemon.uuid] = message
         }
     }
-}
+}

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

@@ -8,6 +8,24 @@
 
 package com.cobblemon.mod.common.battles.pokemon
 
+import net.minecraft.world.item.ItemStack
+
+import com.cobblemon.mod.common.util.getPlayer
+
+import com.cobblemon.mod.common.net.messages.client.battle.MoveDTO
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattlePokemonDTO
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleActorInformationPacket
+
+import com.cobblemon.mod.common.net.messages.client.battle.BattleInitializePacket
+
+import com.cobblemon.mod.common.api.types.tera.TeraType
+
+import com.cobblemon.mod.common.api.pokemon.stats.Stats
+
+import com.cobblemon.mod.common.CobblemonNetwork.sendPacket
+
 import com.bedrockk.molang.runtime.struct.QueryStruct
 import com.bedrockk.molang.runtime.value.DoubleValue
 import com.bedrockk.molang.runtime.value.StringValue
@@ -83,8 +101,7 @@ open class BattlePokemon(
             "max_health" to Function { DoubleValue(maxHealth.toDouble()) },
             "ivs" to Function { effectedPokemon.ivs.struct },
             "nature" to Function { StringValue(effectedPokemon.nature.name.toString()) },
-            "moveset" to Function { effectedPokemon.moveSet.toStruct() },
-            "has_faced_opponents" to Function { DoubleValue(facedOpponents.isNotEmpty()) }
+            "moveset" to Function { effectedPokemon.moveSet.toStruct() }
         ))
 
     val uuid: UUID
@@ -121,6 +138,13 @@ open class BattlePokemon(
 
     val contextManager = ContextManager()
 
+    var revealed = false
+    var revealedAbility: String? = null
+    val revealedMoves: MutableList<MoveDTO?> = mutableListOf(null, null, null, null)
+    var revealedHeldItem: ItemStack? = null
+    var transformed: BattlePokemon? = null
+    var terastallized: TeraType? = null
+
     open fun getName(): MutableComponent {
         val displayPokemon = getIllusion()?.effectedPokemon ?: effectedPokemon
         return if (actor is PokemonBattleActor || actor is MultiPokemonBattleActor) {
@@ -130,8 +154,72 @@ open class BattlePokemon(
         }
     }
 
+    fun toBattleDTO(ally: Boolean, forceReveal: Boolean = false): BattlePokemonDTO {
+        val moves = (transformed?.effectedPokemon ?: effectedPokemon).moveSet.getMovesWithNulls().map { move ->
+            move?.let { MoveDTO(it.displayName, revealedMoves.firstOrNull { known -> known?.move == it.displayName }?.timesUsed ?: 0) }
+        }
+
+        val boostMultipliers = statChanges.entries.mapNotNull { (stat, stage) ->
+            val standardStat = stat as? Stats ?: return@mapNotNull null
+            val base = if (standardStat == Stats.ACCURACY || standardStat == Stats.EVASION) 3.0 else 2.0
+            val clamped = stage.coerceIn(-6, 6)
+            standardStat to if (clamped >= 0) (base + clamped) / base else base / (base - clamped)
+        }.toMap().filterValues { it != 1.0 }
+
+        val format = if (::actor.isInitialized && actor.isInitialized()) actor.battle.format else null
+        val isTeamSheet = format?.isOpenTeamSheet == true
+        if (ally || isTeamSheet) {
+            val allyDto = BattleInitializePacket.ActiveBattlePokemonDTO.fromPokemon(this, ally, getIllusion())
+            return BattlePokemonDTO(
+                this.effectedPokemon.uuid,
+                this.effectedPokemon.isFainted(),
+                (transformed?.effectedPokemon ?: effectedPokemon).ability.name,
+                moves,
+                this.effectedPokemon.heldItem,
+                boostMultipliers,
+                if (ally) effectedPokemon.speed else null,
+                terastallized = terastallized,
+                allyDto
+            )
+        }
+        else {
+            // Team Preview reveals identities, while moves, abilities and items still require discovery.
+            val nonAllyDto = if (forceReveal || revealed || format?.hasTeamPreview == true) {
+                BattleInitializePacket.ActiveBattlePokemonDTO.fromPokemon(this, false, getIllusion())
+            } else null
+            return BattlePokemonDTO(
+                this.effectedPokemon.uuid,
+                this.effectedPokemon.isFainted(),
+                revealedAbility,
+                revealedMoves,
+                revealedHeldItem,
+                boostMultipliers,
+                speed = null,
+                terastallized = terastallized,
+                nonAllyDto
+            )
+        }
+    }
+
+    fun updateBattleActorInformation(uuids: List<UUID>) {
+        uuids.forEach {
+            if (actor.uuid == it) {
+                it.getPlayer()?.sendPacket(
+                    BattleActorInformationPacket(actor.uuid, toBattleDTO(true))
+                )
+            }
+            else {
+                it.getPlayer()?.sendPacket(
+                    BattleActorInformationPacket(actor.uuid, toBattleDTO(false))
+                )
+            }
+        }
+    }
+
     fun sendUpdate() {
         actor.sendUpdate(BattleUpdateTeamPokemonPacket(effectedPokemon))
+        revealed = revealed || isSentOut()
+        updateBattleActorInformation(actor.battle.actors.flatMap { it.getPlayerUUIDs() } + actor.battle.spectators)
     }
 
     fun isSentOut() = actor.battle.activePokemon.any { it.battlePokemon == this }
@@ -142,5 +230,7 @@ open class BattlePokemon(
             !isSentOut() && !willBeSwitchedIn && health > 0
         }
 
-    fun getIllusion(): BattlePokemon? = this.actor.activePokemon.find { it.battlePokemon == this }?.illusion
-}
+    fun getIllusion(): BattlePokemon? = if (::actor.isInitialized) {
+        actor.activePokemon.find { it.battlePokemon == this }?.illusion
+    } else null
+}

common/src/main/kotlin/com/cobblemon/mod/common/battles/timers/PlayerBattleTimer.kt

@@ -0,0 +1,28 @@
+/*
+ * 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.battles.timers
+
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.battles.ForfeitActionResponse
+import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
+import java.time.Instant
+
+interface PlayerBattleTimer {
+    val actor: PlayerBattleActor
+    val battle: PokemonBattle
+
+    fun startSelection()
+    fun endSelection()
+    fun tick()
+    fun mustChooseBy(): Instant
+
+    fun timeout() {
+        actor.setActionResponses(listOf(ForfeitActionResponse()))
+    }
+}

common/src/main/kotlin/com/cobblemon/mod/common/battles/timers/ShowdownTimer.kt

@@ -0,0 +1,45 @@
+/*
+ * 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.battles.timers
+
+import com.cobblemon.mod.common.api.battles.model.PokemonBattle
+import com.cobblemon.mod.common.battles.actor.PlayerBattleActor
+import java.time.Duration
+import java.time.Instant
+
+class ShowdownTimer(override val battle: PokemonBattle, override val actor: PlayerBattleActor): PlayerBattleTimer {
+    private lateinit var turnStart: Instant
+    private var secondsRemaining = 210
+    private var hasSelected = true
+
+    override fun tick() {
+        if (hasSelected || !::turnStart.isInitialized || battle.ended) return
+        val secondsSinceStart = Duration.between(turnStart, Instant.now()).seconds
+        if (secondsRemaining - secondsSinceStart <= 0) {
+            hasSelected = true
+            timeout()
+        }
+    }
+
+    override fun startSelection() {
+        turnStart = Instant.now()
+        hasSelected = false
+    }
+
+    override fun endSelection() {
+        if (hasSelected || !::turnStart.isInitialized) return
+        hasSelected = true
+        val secondsSinceStart = Duration.between(turnStart, Instant.now()).seconds.toInt()
+        secondsRemaining = secondsRemaining - secondsSinceStart + 10
+    }
+
+    override fun mustChooseBy(): Instant {
+        return turnStart.plusSeconds(secondsRemaining.toLong())
+    }
+}

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

@@ -1,137 +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.decor
-
-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.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.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.gameevent.GameEvent
-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.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class ActivatableDecorationBlock(settings: Properties, val type: ActivatableDecorationBlockType) : HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
-    enum class ActivatableDecorationBlockType: StringRepresentable {
-        //For basic use, also ignore camelcase errors, it's just dumb
-        CENTERED_8x,
-        //For specific items
-        METRONOME;
-
-        override fun getSerializedName(): String = this.name.lowercase()
-
-        companion object {
-            val CODEC = StringRepresentable.fromEnum(::values)
-        }
-    }
-
-    companion object {
-        val CODEC: MapCodec<ActivatableDecorationBlock> = RecordCodecBuilder.mapCodec { it.group(
-            propertiesCodec(),
-            ActivatableDecorationBlockType.CODEC.fieldOf("type").forGetter(ActivatableDecorationBlock::type)
-        ).apply(it, ::ActivatableDecorationBlock) }
-        val ACTIVE = BooleanProperty.create("active")
-
-        val CENTERED_8x = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.5, 0.75)
-        val METRONOME_HITBOX = Shapes.box(0.25, 0.0, 0.375, 0.75, 0.8125, 0.75)
-
-        fun getShape(type: ActivatableDecorationBlockType): VoxelShape {
-            return when (type) {
-                ActivatableDecorationBlockType.METRONOME -> METRONOME_HITBOX
-                else -> CENTERED_8x
-            }
-        }
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(ACTIVE, false)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun codec(): MapCodec<ActivatableDecorationBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HORIZONTAL_FACING, ACTIVE, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? = if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState)
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (state.getValue(HORIZONTAL_FACING).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun getCollisionShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(HORIZONTAL_FACING)
-        return rotateShape(Direction.NORTH, direction, getShape(type))
-    }
-
-    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 useWithoutItem(
-        state: BlockState,
-        level: Level,
-        pos: BlockPos,
-        player: Player,
-        hitResult: BlockHitResult
-    ): InteractionResult {
-        if (level.isClientSide) {
-            level.setBlockAndUpdate(pos, state.cycle(ACTIVE))
-            return InteractionResult.SUCCESS
-        } else {
-            this.push(state, level, pos, null as Player?)
-            return InteractionResult.CONSUME
-        }
-    }
-
-    fun push(state: BlockState, level: Level, pos: BlockPos?, player: Player?) {
-        var state = state
-        state = state.cycle(ACTIVE)
-        level.setBlock(pos!!, state, 3)
-        level.gameEvent(player, if (state.getValue(ACTIVE)) GameEvent.BLOCK_ACTIVATE else GameEvent.BLOCK_DEACTIVATE, pos)
-    }
-
-    override fun hasAnalogOutputSignal(state: BlockState): Boolean {
-        return true
-    }
-        //TODO: Replace this forced 4 with a value that can be set by the block, only relevant when more blocks of this class are added.
-    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
-        return if (level.getBlockState(pos).getValue(ACTIVE) as Boolean) 4 else 0
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/DecorativeItemBlock.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
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.util.StringRepresentable
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.HorizontalDirectionalBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.HORIZONTAL_FACING
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class DecorativeItemBlock(settings: Properties, val type: DecorativeItemBlockType): HorizontalDirectionalBlock(settings), SimpleWaterloggedBlock {
-
-    enum class DecorativeItemBlockType: StringRepresentable {
-        //For basic use, also ignore camelcase errors, it's just dumb
-        CENTERED_8x,
-        CENTERED_6x,
-        FLATTENED_8x6,
-        FLATTENED_8x4,
-        FLATTENED_10x4,
-        //For specific items
-        TEACUP,
-        TEAPOT,
-        KNOT,
-        POUCH,
-        NEVERMELT,
-        SCOPE,
-        WIDE,
-        ZOOM,
-        IZER;
-
-        override fun getSerializedName(): String = this.name.lowercase()
-
-        companion object {
-            val CODEC = StringRepresentable.fromEnum(::values)
-        }
-    }
-
-    companion object {
-        val CODEC: MapCodec<DecorativeItemBlock> = RecordCodecBuilder.mapCodec { it.group(
-            propertiesCodec(),
-            DecorativeItemBlockType.CODEC.fieldOf("type").forGetter(DecorativeItemBlock::type)
-        ).apply(it, ::DecorativeItemBlock) }
-
-        val CENTERED_8x = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.5, 0.75)
-        val CENTERED_6x = Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.375, 0.6875)
-        val FLAT6_HITBOX = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.375, 0.75)
-        val FLAT4_HITBOX = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.25, 0.75)
-        val SMOOSHED4_HITBOX = Shapes.box(0.1875, 0.0, 0.1875, 0.8125, 0.25, 0.8125)
-        val TEACUP_HITBOX = Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.25, 0.6875)
-        val TEAPOT_HITBOX = Shapes.box(0.1875, 0.0, 0.1875, 0.8125, 0.625, 0.8125)
-        val KNOT_HITBOX = Shapes.box(0.375, 0.0, 0.375, 0.75, 0.375, 0.75)
-        val POUCH_HITBOX = Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.3125, 0.6875)
-        val NEVERMELT_HITBOX = Shapes.box(0.25, 0.0, 0.3125, 0.6875, 0.25, 0.75)
-        val SCOPE_HITBOX = Shapes.box(0.625, 0.0, 0.4375, 0.9375, 0.125, 0.75)
-        val WIDE_HITBOX = Shapes.box(0.625, 0.0, 0.125, 0.9375, 0.0625, 0.625)
-        val ZOOM_HITBOX = Shapes.box(0.125, 0.0, 0.1875, 0.375, 0.1875, 0.5)
-        val IZER_HITBOX = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.375, 0.75)
-
-        fun getShape(type: DecorativeItemBlockType): VoxelShape {
-            return when (type) {
-                DecorativeItemBlockType.TEAPOT -> TEAPOT_HITBOX
-                DecorativeItemBlockType.TEACUP -> TEACUP_HITBOX
-                DecorativeItemBlockType.KNOT -> KNOT_HITBOX
-                DecorativeItemBlockType.POUCH -> POUCH_HITBOX
-                DecorativeItemBlockType.NEVERMELT -> NEVERMELT_HITBOX
-                DecorativeItemBlockType.SCOPE -> SCOPE_HITBOX
-                DecorativeItemBlockType.WIDE -> WIDE_HITBOX
-                DecorativeItemBlockType.ZOOM -> ZOOM_HITBOX
-                DecorativeItemBlockType.IZER -> IZER_HITBOX
-                DecorativeItemBlockType.FLATTENED_10x4 -> SMOOSHED4_HITBOX
-                DecorativeItemBlockType.FLATTENED_8x4 -> FLAT4_HITBOX
-                DecorativeItemBlockType.FLATTENED_8x6 -> FLAT6_HITBOX
-                DecorativeItemBlockType.CENTERED_6x -> CENTERED_6x
-                else -> CENTERED_8x
-            }
-        }
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HORIZONTAL_FACING, Direction.NORTH)
-            .setValue(WATERLOGGED, false))
-    }
-
-    override fun codec(): MapCodec<DecorativeItemBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HORIZONTAL_FACING, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? = if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState)
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (state.getValue(HORIZONTAL_FACING).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(HORIZONTAL_FACING)
-        return rotateShape(Direction.NORTH, direction, getShape(type))
-    }
-
-    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/EjectButtonBlock.kt

@@ -1,139 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.ButtonBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockSetType
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class EjectButtonBlock(properties: Properties, ticksToStayPressed: Int) : ButtonBlock(BlockSetType.IRON, ticksToStayPressed, properties), SimpleWaterloggedBlock  {
-    companion object {
-        val FLOOR_UNPOWERED = Shapes.or(
-            Shapes.box(0.125, 0.0, 0.125, 0.875, 0.1875, 0.875),
-            Shapes.box(0.375, 0.1875, 0.375, 0.625, 0.3125, 0.625) )
-        val FLOOR_POWERED = Shapes.or(
-            Shapes.box(0.125, 0.0, 0.125, 0.875, 0.1875, 0.875),
-            Shapes.box(0.375, 0.1875, 0.375, 0.625, 0.25, 0.625) )
-        val FLOOR_PANEL = Shapes.box(0.125, 0.0, 0.125, 0.875, 0.1875, 0.875)
-        val CEILING_UNPOWERED = Shapes.or(
-            Shapes.box(0.125, 0.8125, 0.125, 0.875, 1.0, 0.875),
-            Shapes.box(0.375, 0.6875, 0.375, 0.625, 0.8125, 0.625) )
-        val CEILING_POWERED = Shapes.or(
-            Shapes.box(0.125, 0.8125, 0.125, 0.875, 1.0, 0.875),
-            Shapes.box(0.375, 0.75, 0.375, 0.625, 0.8125, 0.625) )
-        val CEILING_PANEL = Shapes.box(0.125, 0.8125, 0.125, 0.875, 1.0, 0.875)
-        val WALL_UNPOWERED = Shapes.or(
-            Shapes.box(0.125, 0.125, 0.8125, 0.875, 0.875, 1.0),
-            Shapes.box(0.375, 0.375, 0.6875, 0.625, 0.625, 0.8125) )
-        val WALL_POWERED = Shapes.or(
-            Shapes.box(0.125, 0.125, 0.8125, 0.875, 0.875, 1.0),
-            Shapes.box(0.375, 0.375, 0.75, 0.625, 0.625, 0.8125) )
-        val WALL_PANEL = Shapes.box(0.125, 0.125, 0.8125, 0.875, 0.875, 1.0)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(FACE, AttachFace.WALL)
-            .setValue(POWERED, false)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(FACING, FACE, POWERED, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? {
-        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        for (direction in context.nearestLookingDirections) {
-            val blockState: BlockState
-            if (direction.getAxis() === Direction.Axis.Y) {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, if (direction == Direction.UP) AttachFace.CEILING else AttachFace.FLOOR) as BlockState)
-                    .setValue(FACING, context.horizontalDirection.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                    ) as BlockState
-            } else {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, AttachFace.WALL) as BlockState)
-                    .setValue(FACING, direction.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                    ) as BlockState
-            }
-            if (blockState.canSurvive(context.getLevel(), context.getClickedPos())) {
-                return blockState
-            }
-        }
-        return null
-    }
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR -> if (state.getValue(POWERED)) {FLOOR_POWERED} else {FLOOR_UNPOWERED}
-            AttachFace.WALL ->
-                when (direction) {
-                    Direction.NORTH, Direction.UP, Direction.DOWN -> if (state.getValue(POWERED)) {WALL_POWERED} else {WALL_UNPOWERED}
-                    else -> rotateShape(Direction.NORTH, direction, if (state.getValue(POWERED)) {WALL_POWERED} else {WALL_UNPOWERED})
-                }
-            AttachFace.CEILING -> if (state.getValue(POWERED)) {CEILING_POWERED} else {CEILING_UNPOWERED}
-        }
-    }
-    override fun getCollisionShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR -> FLOOR_PANEL
-            AttachFace.WALL -> when (direction) {
-                Direction.NORTH, Direction.UP, Direction.DOWN -> WALL_PANEL
-                else -> rotateShape(Direction.NORTH, direction, WALL_PANEL)
-            }
-            AttachFace.CEILING -> CEILING_PANEL
-        }
-    }
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (getConnectedDirection(state).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return if (state.getValue(FACE) != AttachFace.WALL) {
-            val direction = getConnectedDirection(state)
-            canSupportCenter(level, pos.relative(direction.opposite), direction)
-        } else {
-            level.getBlockState(pos.relative(state.getValue(FACING).opposite)).isSolid
-        }
-    }
-}

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

@@ -1,63 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class GalaricaWreathBlock(properties: Properties) : SixFaceRotationalBlock(properties) {
-    companion object {
-        val CODEC: MapCodec<GalaricaWreathBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::GalaricaWreathBlock)
-        }
-
-        val FLOOR_NORTH = Shapes.box(0.125, 0.0, 0.125, 0.875, 0.25, 0.875)
-        val WALL_NORTH = Shapes.box(0.125, 0.125, 0.75, 0.875, 0.875, 1.0)
-        val CEILING_NORTH = Shapes.box(0.125, 0.125, 0.375, 0.875, 0.625, 0.5625)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(FACE, AttachFace.WALL)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun codec(): MapCodec<GalaricaWreathBlock> = CODEC
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, FLOOR_NORTH)
-                } else FLOOR_NORTH
-            AttachFace.WALL ->
-                when (direction) {
-                    Direction.NORTH, Direction.UP, Direction.DOWN -> WALL_NORTH
-                    else -> rotateShape(Direction.NORTH, direction, WALL_NORTH)
-                }
-            AttachFace.CEILING ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, CEILING_NORTH)
-                } else CEILING_NORTH
-        }
-    }
-}

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

@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class MagnetBlock(properties: Properties) : SixFaceRotationalBlock(properties) {
-    companion object {
-        val CODEC: MapCodec<MagnetBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::MagnetBlock)
-        }
-
-        val FLOOR_NORTH = Shapes.box(0.25, 0.0, 0.25, 0.75, 0.1875, 0.75)
-        val WALL_NORTH = Shapes.box(0.25, 0.25, 0.8125, 0.75, 0.75, 1.0)
-        val CEILING_NORTH = Shapes.box(0.25, 0.8125, 0.25, 0.75, 1.0, 0.75)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(FACE, AttachFace.WALL)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun codec(): MapCodec<MagnetBlock> = CODEC
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, FLOOR_NORTH)
-                } else FLOOR_NORTH
-            AttachFace.WALL ->
-                when (direction) {
-                    Direction.NORTH, Direction.UP, Direction.DOWN -> WALL_NORTH
-                    else -> rotateShape(Direction.NORTH, direction, WALL_NORTH)
-                }
-            AttachFace.CEILING ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, CEILING_NORTH)
-                } else CEILING_NORTH
-        }
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return true
-    }
-}

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

@@ -103,15 +103,15 @@ class MintBlock(private val mintType: MintType, settings: Properties) : CropBloc
             GREEN -> CobblemonItems.GREEN_MINT_SEEDS
             WHITE -> CobblemonItems.WHITE_MINT_SEEDS
         }
-// These don't seem to get called to anywhere besides the direct item, and since I'm trying to do funny stuff there, just commenting this out
-//        fun getLeaf(): MintLeafItem = when (this) {
-//            RED -> CobblemonItems.RED_MINT_LEAF
-//            BLUE -> CobblemonItems.BLUE_MINT_LEAF
-//            CYAN -> CobblemonItems.CYAN_MINT_LEAF
-//            PINK -> CobblemonItems.PINK_MINT_LEAF
-//            GREEN -> CobblemonItems.GREEN_MINT_LEAF
-//            WHITE -> CobblemonItems.WHITE_MINT_LEAF
-//        }
+
+        fun getLeaf(): MintLeafItem = when (this) {
+            RED -> CobblemonItems.RED_MINT_LEAF
+            BLUE -> CobblemonItems.BLUE_MINT_LEAF
+            CYAN -> CobblemonItems.CYAN_MINT_LEAF
+            PINK -> CobblemonItems.PINK_MINT_LEAF
+            GREEN -> CobblemonItems.GREEN_MINT_LEAF
+            WHITE -> CobblemonItems.WHITE_MINT_LEAF
+        }
 
         fun getCropBlock(): MintBlock = when (this) {
             RED -> CobblemonBlocks.RED_MINT

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

@@ -1,68 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block
-
-import com.cobblemon.mod.common.util.rotateShape
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class OrbBlock(properties: Properties) : SixFaceRotationalBlock(properties) {
-    companion object {
-        val CODEC: MapCodec<OrbBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::OrbBlock)
-        }
-
-        val FLOOR_NORTH = Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.375, 0.6875)
-        val WALL_NORTH = Shapes.box(0.3125, 0.3125, 0.625, 0.6875, 0.6875, 1.0)
-        val CEILING_NORTH = Shapes.box(0.3125, 0.625, 0.375, 0.6875, 1.0, 0.6875)
-    }
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(FACE, AttachFace.WALL)
-            .setValue(WATERLOGGED, false)
-        )
-    }
-
-    override fun codec(): MapCodec<OrbBlock> = CODEC
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        val direction = state.getValue(FACING)
-        return when (state.getValue(FACE)) {
-            AttachFace.FLOOR ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, FLOOR_NORTH)
-                } else FLOOR_NORTH
-            AttachFace.WALL ->
-                when (direction) {
-                    Direction.NORTH, Direction.UP, Direction.DOWN -> WALL_NORTH
-                    else -> rotateShape(Direction.NORTH, direction, WALL_NORTH)
-                }
-            AttachFace.CEILING ->
-                if (direction.axis === Direction.Axis.X) {
-                    rotateShape(Direction.NORTH, Direction.WEST, CEILING_NORTH)
-                } else CEILING_NORTH
-        }
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return true
-    }
-}

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

@@ -13,15 +13,25 @@ import com.mojang.serialization.MapCodec
 import com.mojang.serialization.codecs.RecordCodecBuilder
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
+import net.minecraft.world.item.context.BlockPlaceContext
 import net.minecraft.world.level.BlockGetter
+import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.LevelReader
+import net.minecraft.world.level.block.Block
+import net.minecraft.world.level.block.Blocks
+import net.minecraft.world.level.block.FaceAttachedHorizontalDirectionalBlock
+import net.minecraft.world.level.block.SimpleWaterloggedBlock
 import net.minecraft.world.level.block.state.BlockState
+import net.minecraft.world.level.block.state.StateDefinition
 import net.minecraft.world.level.block.state.properties.AttachFace
 import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
+import net.minecraft.world.level.material.FluidState
+import net.minecraft.world.level.material.Fluids
 import net.minecraft.world.phys.shapes.CollisionContext
 import net.minecraft.world.phys.shapes.Shapes
 import net.minecraft.world.phys.shapes.VoxelShape
 
-class PlaqueBlock(properties : Properties) : SixFaceRotationalBlock(properties) {
+class PlaqueBlock(properties : Properties) : FaceAttachedHorizontalDirectionalBlock(properties), SimpleWaterloggedBlock {
     companion object {
         val CODEC: MapCodec<PlaqueBlock> = RecordCodecBuilder.mapCodec {
             it.group(propertiesCodec()).apply(it, ::PlaqueBlock)
@@ -44,6 +54,40 @@ class PlaqueBlock(properties : Properties) : SixFaceRotationalBlock(properties)
         )
     }
 
+    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
+        builder.add(FACING, FACE, WATERLOGGED)
+    }
+
+    override fun getFluidState(blockState: BlockState): FluidState? {
+        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
+    }
+
+    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
+        val fluidState = context.level.getFluidState(context.clickedPos)
+        for (direction in context.nearestLookingDirections) {
+            val blockState: BlockState
+            if (direction.getAxis() === Direction.Axis.Y) {
+                blockState = (defaultBlockState()
+                    .setValue(FACE, if (direction == Direction.UP) AttachFace.CEILING else AttachFace.FLOOR) as BlockState)
+                    .setValue(FACING, context.horizontalDirection.opposite)
+                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
+                ) as BlockState
+            } else {
+                blockState = (defaultBlockState()
+                    .setValue(FACE, AttachFace.WALL) as BlockState)
+                    .setValue(FACING, direction.opposite)
+                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
+                ) as BlockState
+
+            }
+
+            if (blockState.canSurvive(context.getLevel(), context.getClickedPos())) {
+                return blockState
+            }
+        }
+        return null
+    }
+
     override fun codec(): MapCodec<PlaqueBlock> = CODEC
 
     override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
@@ -64,4 +108,21 @@ class PlaqueBlock(properties : Properties) : SixFaceRotationalBlock(properties)
                 } else CEILING_NORTH
         }
     }
+
+    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
+        if (state.getValue(WATERLOGGED)) {
+            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
+        }
+        return if (getConnectedDirection(state).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
+        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
+    }
+
+    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
+        return if (state.getValue(FACE) == AttachFace.CEILING) {
+            val direction = getConnectedDirection(state)
+            canSupportCenter(level, pos.relative(direction.opposite), direction)
+        } else {
+            super.canSurvive(state, level, pos)
+        }
+    }
 }

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

@@ -1,116 +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.decor
-
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.*
-import net.minecraft.world.level.block.HorizontalDirectionalBlock.FACING
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.BlockStateProperties
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.block.state.properties.Property
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class RingTargetBlock(settings: Properties) : TargetBlock(settings), SimpleWaterloggedBlock {
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.NORTH)
-            .setValue(WATERLOGGED, false)
-            .setValue(OUTPUT_POWER, 0))
-    }
-
-    override fun getStateForPlacement(ctx: BlockPlaceContext): BlockState? {
-        var blockState = defaultBlockState()
-            .setValue(WATERLOGGED, ctx.level.getFluidState(ctx.clickedPos).type == Fluids.WATER)
-        val worldView = ctx.level
-        val blockPos = ctx.clickedPos
-        ctx.nearestLookingDirections.forEach { direction ->
-            if (direction.axis.isHorizontal) {
-                blockState = blockState.setValue(FACING, direction.opposite) as BlockState
-                if (blockState.canSurvive(worldView, blockPos)) {
-                    return blockState
-                }
-            }
-        }
-        return null
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? {
-        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState)
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(FACING)
-        builder.add(WATERLOGGED)
-        builder.add(*arrayOf<Property<*>>(OUTPUT_POWER))
-    }
-
-    override fun getShape(
-        state: BlockState,
-        blockGetter: BlockGetter,
-        pos: BlockPos,
-        collisionContext: CollisionContext
-    ): VoxelShape {
-        return when (state.getValue(FACING)) {
-                    Direction.SOUTH -> FULL_PLANE_SOUTH
-                    Direction.WEST -> FULL_PLANE_WEST
-                    Direction.EAST -> FULL_PLANE_EAST
-                    else -> FULL_PLANE_NORTH
-        }
-    }
-
-    override fun updateShape(
-        state: BlockState,
-        direction: Direction,
-        neighborState: BlockState,
-        world: LevelAccessor,
-        pos: BlockPos,
-        neighborPos: BlockPos
-    ): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (direction.opposite == state.getValue(FACING) && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun rotate(state: BlockState, rotation: Rotation): BlockState {
-        return state.setValue(FACING, rotation.rotate(state.getValue(FACING)))
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return level.getBlockState(pos.relative(state.getValue(FACING).opposite)).isSolid
-    }
-
-    companion object {
-        val CODEC: MapCodec<RingTargetBlock> = RecordCodecBuilder.mapCodec {
-            it.group(
-                propertiesCodec()
-        ).apply(it, ::RingTargetBlock) }
-
-        val OUTPUT_POWER = BlockStateProperties.POWER;
-
-        val FULL_PLANE_NORTH = Shapes.box(0.0, 0.0, 0.925, 1.0, 1.0, 1.0)
-        val FULL_PLANE_WEST = Shapes.box(0.925, 0.0, 0.0, 1.0, 1.0, 1.0)
-        val FULL_PLANE_SOUTH = Shapes.box(0.0, 0.0, 0.0, 1.0, 1.0, 0.075)
-        val FULL_PLANE_EAST = Shapes.box(0.0, 0.0, 0.0, 0.075, 1.0, 1.0)
-    }
-}

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

@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block
-
-import com.mojang.serialization.MapCodec
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.FaceAttachedHorizontalDirectionalBlock
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.level.block.state.properties.AttachFace
-import net.minecraft.world.level.block.state.properties.BlockStateProperties.WATERLOGGED
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-
-open class SixFaceRotationalBlock(properties : Properties) : FaceAttachedHorizontalDirectionalBlock(properties), SimpleWaterloggedBlock {
-    companion object {
-        val CODEC = simpleCodec(::SixFaceRotationalBlock)
-    }
-
-    override fun codec(): MapCodec<out SixFaceRotationalBlock> = CODEC
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(FACING, FACE, WATERLOGGED)
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? {
-        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        for (direction in context.nearestLookingDirections) {
-            val blockState: BlockState
-            if (direction.getAxis() === Direction.Axis.Y) {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, if (direction == Direction.UP) AttachFace.CEILING else AttachFace.FLOOR) as BlockState)
-                    .setValue(FACING, context.horizontalDirection.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                ) as BlockState
-            } else {
-                blockState = (defaultBlockState()
-                    .setValue(FACE, AttachFace.WALL) as BlockState)
-                    .setValue(FACING, direction.opposite)
-                    .setValue(WATERLOGGED, fluidState.type === Fluids.WATER
-                ) as BlockState
-
-            }
-
-            if (blockState.canSurvive(context.getLevel(), context.getClickedPos())) {
-                return blockState
-            }
-        }
-        return null
-    }
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        if (state.getValue(WATERLOGGED)) {
-            world.scheduleTick(pos, Fluids.WATER, Fluids.WATER.getTickDelay(world))
-        }
-        return if (getConnectedDirection(state).opposite == direction && !state.canSurvive(world, pos)) Blocks.AIR.defaultBlockState()
-        else super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return if (state.getValue(FACE) == AttachFace.CEILING) {
-            val direction = getConnectedDirection(state)
-            canSupportCenter(level, pos.relative(direction.opposite), direction)
-        } else if (state.getValue(FACE) == AttachFace.WALL) {
-            level.getBlockState(pos.relative(state.getValue(FACING).opposite)).isSolid
-        } else {
-            super.canSurvive(state, level, pos)
-        }
-    }
-}

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

@@ -39,15 +39,7 @@ class StackableItemBlock(settings: Properties, val type: StackableItemBlockType)
         ETHER,
         MAX_POTION,
         POTION,
-        STATUS_RESTORE,
-        VITAMIN,
-        METAL_COAT,
-        IRON_BALL,
-        THROAT_SPRAY,
-        UPGRADE,
-        DICE,
-        GLASS_BOTTLE,
-        EXTENDER;
+        STATUS_RESTORE;
 
         override fun getSerializedName(): String = this.name.lowercase()
 
@@ -65,90 +57,98 @@ class StackableItemBlock(settings: Properties, val type: StackableItemBlockType)
             StackableItemBlockType.CODEC.fieldOf("type").forGetter(StackableItemBlock::type)
         ).apply(it, ::StackableItemBlock) }
 
-        val northShapeMap: Map<StackableItemBlockType, List<VoxelShape>>
-            get() = mapOf(
-                StackableItemBlockType.BATTLE_ITEM to listOf(
-                    Shapes.box(0.34375, 0.0, 0.34375, 0.65625, 0.4375, 0.65625),
-                    Shapes.box(0.09375, 0.0, 0.34375, 0.90625, 0.4375, 0.71875),
-                    Shapes.box(0.09375, 0.0, 0.09375, 0.90625, 0.4375, 0.90625),
-                    Shapes.box(0.09375, 0.0, 0.09375, 0.96875, 0.4375, 0.90625)
+        val northShapeMap: Map<StackableItemBlockType, List<VoxelShape>> = mapOf(
+            StackableItemBlockType.BATTLE_ITEM to listOf(
+                Shapes.box(0.34375, 0.0, 0.34375, 0.65625, 0.4375, 0.65625),
+                Shapes.or(
+                    Shapes.box(0.09375, 0.0, 0.34375, 0.40625, 0.4375, 0.65625),
+                    Shapes.box(0.59375, 0.0, 0.40625, 0.90625, 0.4375, 0.71875)
                 ),
-                StackableItemBlockType.ETHER to listOf(
-                    Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5, 0.6875),
-                    Shapes.box(0.125, 0.0, 0.3125, 0.875, 0.5, 0.75),
-                    Shapes.box(0.125, 0.0, 0.125, 0.875, 0.5, 1.0),
-                    Shapes.box(0.125, 0.0, 0.0625, 0.9375, 0.5, 1.0)
+                Shapes.or(
+                    Shapes.box(0.59375, 0.0, 0.59375, 0.90625, 0.4375, 0.90625),
+                    Shapes.box(0.09375, 0.0, 0.53125, 0.40625, 0.4375, 0.84375),
+                    Shapes.box(0.34375, 0.0, 0.09375, 0.65625, 0.4375, 0.40625)
                 ),
-                StackableItemBlockType.MAX_POTION to listOf(
-                    Shapes.box(0.34375, 0.0, 0.3125, 0.65625, 0.5, 0.6875),
-                    Shapes.box(0.09375, 0.0, 0.3125, 0.90625, 0.5, 0.75),
-                    Shapes.box(0.09375, 0.0, 0.0625, 0.90625, 0.5, 1.0),
-                    Shapes.box(0.09375, 0.0, 0.0625, 0.96875, 0.5, 1.0)
+                Shapes.or(
+                    Shapes.box(0.09375, 0.0, 0.09375, 0.40625, 0.4375, 0.40625),
+                    Shapes.box(0.59375, 0.0, 0.15625, 0.90625, 0.4375, 0.46875),
+                    Shapes.box(0.65625, 0.0, 0.59375, 0.96875, 0.4375, 0.90625),
+                    Shapes.box(0.15625, 0.0, 0.53125, 0.46875, 0.4375, 0.84375)
+                )
+            ),
+            StackableItemBlockType.ETHER to listOf(
+                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5, 0.6875),
+                Shapes.or(
+                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.5, 0.75),
+                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.5, 0.6875)
                 ),
-                StackableItemBlockType.POTION to listOf(
-                    Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5625, 0.75),
-                    Shapes.box(0.125, 0.0, 0.3125, 0.875, 0.5625, 0.8125),
-                    Shapes.box(0.125, 0.0, 0.0625, 0.875, 0.5625, 1.0),
-                    Shapes.box(0.125, 0.0, 0.0, 0.9375, 0.5625, 1.0)
+                Shapes.or(
+                    Shapes.box(0.375, 0.0, 0.125, 0.625, 0.5, 0.5),
+                    Shapes.box(0.125, 0.0, 0.5625, 0.375, 0.5, 0.9375),
+                    Shapes.box(0.625, 0.0, 0.625, 0.875, 0.5, 1.0)
                 ),
-                StackableItemBlockType.STATUS_RESTORE to listOf(
-                    Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.4375, 0.6875),
-                    Shapes.box(0.125, 0.0, 0.3125, 0.875, 0.4375, 0.75),
-                    Shapes.box(0.125, 0.0, 0.0625, 0.875, 0.4375, 0.9375),
-                    Shapes.box(0.125, 0.0, 0.0, 0.9375, 0.4375, 0.9375)
+                Shapes.or(
+                    Shapes.box(0.125, 0.0, 0.0625, 0.375, 0.5, 0.4375),
+                    Shapes.box(0.625, 0.0, 0.125, 0.875, 0.5, 0.5),
+                    Shapes.box(0.6875, 0.0, 0.625, 0.9375, 0.5, 1.0),
+                    Shapes.box(0.1875, 0.0, 0.5625, 0.4375, 0.5, 0.9375)
+                )
+            ),
+            StackableItemBlockType.MAX_POTION to listOf(
+                Shapes.box(0.34375, 0.0, 0.3125, 0.65625, 0.5, 0.6875),
+                Shapes.or(
+                    Shapes.box(0.09375, 0.0, 0.3125, 0.40625, 0.5, 0.6875),
+                    Shapes.box(0.59375, 0.0, 0.375, 0.90625, 0.5, 0.75)
                 ),
-                StackableItemBlockType.METAL_COAT to listOf(
-                    Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.375, 0.6875),
-                    Shapes.box(0.125, 0.0, 0.125, 0.875, 0.375, 0.875),
-                    Shapes.box(0.125, 0.0, 0.0625, 0.9375, 0.375, 0.875),
-                    Shapes.box(0.0625, 0.0, 0.0625, 0.9375, 0.375, 0.9375)
+                Shapes.or(
+                    Shapes.box(0.34375, 0.0, 0.0625, 0.65625, 0.5, 0.4375),
+                    Shapes.box(0.09375, 0.0, 0.5625, 0.40625, 0.5, 0.9375),
+                    Shapes.box(0.59375, 0.0, 0.625, 0.90625, 0.5, 1.0)
                 ),
-                StackableItemBlockType.VITAMIN to listOf(
-                    Shapes.box(0.375, 0.0, 0.375, 0.625, 0.4375, 0.625),
-                    Shapes.box(0.1875, 0.0, 0.3125, 0.8125, 0.4375, 0.6875),
-                    Shapes.box(0.1875, 0.0, 0.1875, 0.8125, 0.4375, 0.8125),
-                    Shapes.box(0.125, 0.0, 0.125, 0.875, 0.4375, 0.875)
+                Shapes.or(
+                    Shapes.box(0.09375, 0.0, 0.0625, 0.40625, 0.5, 0.4375),
+                    Shapes.box(0.15625, 0.0, 0.5625, 0.46875, 0.5, 0.9375),
+                    Shapes.box(0.65625, 0.0, 0.625, 0.96875, 0.5, 1.0),
+                    Shapes.box(0.59375, 0.0, 0.125, 0.90625, 0.5, 0.5)
+                ).singleEncompassing()
+            ),
+            StackableItemBlockType.POTION to listOf(
+                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.5625, 0.75),
+                Shapes.or(
+                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.5625, 0.75),
+                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.5625, 0.8125)
                 ),
-                StackableItemBlockType.IRON_BALL to listOf(
-                    Shapes.box(0.25, 0.0, 0.25, 0.75, 0.4375, 0.75),
-                    Shapes.box(0.0, 0.0, 0.1875, 1.0, 0.4375, 0.8125),
-                    Shapes.box(0.0, 0.0, 0.0, 1.0, 0.4375, 1.0),
-                    Shapes.or(
-                        Shapes.box(0.0, 0.0, 0.0, 1.0, 0.4375, 1.0),
-                        Shapes.box(0.25, 0.4375, 0.3125, 0.6875, 0.875, 0.75)
-                    )
+                Shapes.or(
+                    Shapes.box(0.375, 0.0, 0.0625, 0.625, 0.5625, 0.5),
+                    Shapes.box(0.625, 0.0, 0.5625, 0.875, 0.5625, 1.0),
+                    Shapes.box(0.125, 0.0, 0.5, 0.375, 0.5625, 0.9375)
                 ),
-                StackableItemBlockType.THROAT_SPRAY to listOf(
-                    Shapes.box(0.375, 0.0, 0.1875, 0.625, 0.5625, 0.75),
-                    Shapes.box(0.125, 0.0, 0.1875, 0.875, 0.5625, 0.8125),
-                    Shapes.box(0.125, 0.0, 0.0, 0.875, 0.5625, 1.0),
-                    Shapes.box(0.075, 0.0, 0.0, 0.9375, 0.5625, 1.0)
+                Shapes.or(
+                    Shapes.box(0.125, 0.0, 0.0, 0.375, 0.5625, 0.4375),
+                    Shapes.box(0.625, 0.0, 0.0625, 0.875, 0.5625, 0.5),
+                    Shapes.box(0.6875, 0.0, 0.5625, 0.9375, 0.5625, 1.0),
+                    Shapes.box(0.1875, 0.0, 0.5, 0.4375, 0.5625, 0.9375)
+                )
+            ),
+            StackableItemBlockType.STATUS_RESTORE to listOf(
+                Shapes.box(0.375, 0.0, 0.3125, 0.625, 0.4375, 0.6875),
+                Shapes.or(
+                    Shapes.box(0.125, 0.0, 0.3125, 0.375, 0.4375, 0.75),
+                    Shapes.box(0.625, 0.0, 0.375, 0.875, 0.4375, 0.75)
                 ),
-                StackableItemBlockType.UPGRADE to listOf(
-                    Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.125, 0.6875),
-                    Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.25, 0.6875),
-                    Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.375, 0.6875),
-                    Shapes.box(0.3125, 0.0, 0.3125, 0.6875, 0.5, 0.6875)
+                Shapes.or(
+                    Shapes.box(0.125, 0.0, 0.5, 0.375, 0.4375, 0.875),
+                    Shapes.box(0.625, 0.0, 0.5625, 0.875, 0.4375, 0.9375),
+                    Shapes.box(0.375, 0.0, 0.0625, 0.625, 0.4375, 0.4375)
                 ),
-                StackableItemBlockType.DICE to listOf(
-                    Shapes.box(0.125, 0.0, 0.6875, 0.3125, 0.1875, 0.875),
-                    Shapes.box(0.125, 0.0, 0.625, 0.5625, 0.1875, 0.875),
-                    Shapes.box(0.125, 0.0, 0.4375, 0.5625, 0.1875, 0.875),
-                    Shapes.box(0.125, 0.0, 0.4375, 0.5625, 0.375, 0.875)
-                ),
-                StackableItemBlockType.GLASS_BOTTLE to listOf(
-                    Shapes.box(0.375, 0.0, 0.375, 0.625, 0.375, 0.625),
-                    Shapes.box(0.1875, 0.0, 0.1875, 0.8125, 0.375, 0.6875),
-                    Shapes.box(0.125, 0.0, 0.125, 0.8125, 0.375, 0.875),
-                    Shapes.box(0.125, 0.0, 0.125, 0.875, 0.375, 0.875)
-                ),
-                StackableItemBlockType.EXTENDER to listOf(
-                    Shapes.box(0.25, 0.0, 0.375, 0.625, 0.5625, 0.625),
-                    Shapes.box(0.125, 0.0, 0.25, 0.875, 0.5625, 0.75),
-                    Shapes.box(0.0625, 0.0, 0.0625, 0.875, 0.5625, 0.875),
-                    Shapes.box(0.0625, 0.0, 0.0625, 0.9375, 0.5625, 0.9375)
+                Shapes.or(
+                    Shapes.box(0.1875, 0.0, 0.5, 0.4375, 0.4375, 0.875),
+                    Shapes.box(0.125, 0.0, 0.0, 0.375, 0.4375, 0.375),
+                    Shapes.box(0.625, 0.0, 0.0625, 0.875, 0.4375, 0.4375),
+                    Shapes.box(0.6875, 0.0, 0.5625, 0.9375, 0.4375, 0.9375)
                 )
             )
+        )
 
         fun getShape(type: StackableItemBlockType, count: Int): VoxelShape = northShapeMap[type]?.let { list -> list[(count - 1).coerceIn(0, list.lastIndex)] } ?: Shapes.block()
         fun getMaxAmount(type: StackableItemBlockType): Int = min(northShapeMap[type]?.size ?: 1 , MAX_AMOUNT)
@@ -184,7 +184,7 @@ class StackableItemBlock(settings: Properties, val type: StackableItemBlockType)
     }
 
     override fun getShape(state: BlockState, level: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape {
-        return getCollisionShape(state, level, pos, context)
+        return getCollisionShape(state, level, pos, context).singleEncompassing()
     }
 
     override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {

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

@@ -19,7 +19,6 @@ import net.minecraft.core.registries.BuiltInRegistries
 import net.minecraft.resources.ResourceLocation
 import net.minecraft.server.level.ServerLevel
 import net.minecraft.util.RandomSource
-import net.minecraft.util.StringRepresentable
 import net.minecraft.world.item.BlockItem
 import net.minecraft.world.item.ItemStack
 import net.minecraft.world.item.component.BlockItemStateProperties
@@ -34,8 +33,8 @@ import net.minecraft.world.level.block.Mirror
 import net.minecraft.world.level.block.Rotation
 import net.minecraft.world.level.block.state.BlockState
 import net.minecraft.world.level.block.state.StateDefinition
+import net.minecraft.world.level.block.state.properties.BooleanProperty
 import net.minecraft.world.level.block.state.properties.DirectionProperty
-import net.minecraft.world.level.block.state.properties.EnumProperty
 import net.minecraft.world.level.block.state.properties.IntegerProperty
 import net.minecraft.world.level.material.PushReaction
 import net.minecraft.world.level.storage.loot.LootParams
@@ -62,27 +61,22 @@ class TypeGemClusterBlock(
         }
         val gemToClusterMap: MutableMap<Block, TypeGemClusterBlock> = mutableMapOf()
 
+        val SHOULD_GROW: BooleanProperty = BooleanProperty.create("should_grow")
         val FACING: DirectionProperty = DirectionalBlock.FACING
         val STAGE: IntegerProperty = IntegerProperty.create("stage", 0, 3)
-        val GROWTH_TYPE: EnumProperty<GrowthType> = EnumProperty.create("growth_type", GrowthType::class.java)
+        val STUNTED: BooleanProperty = BooleanProperty.create("stunted")
 
         fun clusterFromGemBlock(gemBlock: Block): TypeGemClusterBlock? {
             return gemToClusterMap[gemBlock]
         }
     }
 
-    enum class GrowthType(private val label: String, val chance: Float): StringRepresentable {
-        DECORATION("none", 0.25f),
-        FULL("full", 0.5f),
-        STUNTED("stunted", 0.25f);
-        override fun getSerializedName(): String = label
-    }
-
     init {
         registerDefaultState(stateDefinition.any()
             .setValue(FACING, Direction.UP)
+            .setValue(SHOULD_GROW, true)
             .setValue(STAGE, 0)
-            .setValue(GROWTH_TYPE, GrowthType.FULL)
+            .setValue(STUNTED, false)
         )
     }
 
@@ -95,19 +89,15 @@ class TypeGemClusterBlock(
 
         return defaultBlockState()
             .setValue(FACING, facing)
+            .setValue(SHOULD_GROW, shouldGrow)
             .setValue(STAGE, 0)
-            .setValue(GROWTH_TYPE, if(shouldGrow) GrowthType.FULL else GrowthType.DECORATION)
+            .setValue(STUNTED, false)
     }
 
-    public override fun isRandomlyTicking(state: BlockState): Boolean {
-        // if growth type is either stunted or full, we need to tick
-        return state.getValue(GROWTH_TYPE) != GrowthType.DECORATION
-    }
+    public override fun isRandomlyTicking(state: BlockState): Boolean = state.getValue(SHOULD_GROW)
 
     override fun randomTick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        /*
         advanceGrowth(state, level, pos, random)
-        */
     }
 
     fun advanceGrowth(state: BlockState, level: LevelAccessor, pos: BlockPos, random: RandomSource) {
@@ -121,8 +111,15 @@ class TypeGemClusterBlock(
             return
         }
 
+        // At STAGE_3
+        val isStunted = state.getValue(STUNTED)
         val facing = state.getValue(FACING)
 
+        if (isStunted) {
+            level.setBlock(pos, state.setValue(SHOULD_GROW, false), UPDATE_ALL)
+            return
+        }
+
         // Check neighboring gem blocks
         val hasConflict = Direction.entries
                 .filter { it != facing.opposite }
@@ -135,36 +132,61 @@ class TypeGemClusterBlock(
         if (hasConflict) {
             level.setBlock(
                 pos,
-                state.setValue(GROWTH_TYPE, GrowthType.STUNTED),
+                state.setValue(STUNTED, true).setValue(SHOULD_GROW, false),
                 UPDATE_ALL
             )
-        }
+        } else {
             var nextState = nextStage.defaultBlockState()
             if (nextState.hasProperty(FACING)) {
                 nextState = nextState.setValue(FACING, facing)
             }
             level.setBlock(pos, nextState, UPDATE_ALL)
-            if (isGem(nextState)) {
-                TypeGemCoreBlock.addClustersToBlock(state, pos, level, random)
-            }
+            attachDecorativeClusters(level, pos, random)
+        }
     }
 
     private fun isGem(state: BlockState): Boolean {
         return state.`is`(CobblemonBlockTags.TYPE_GEM_BLOCKS)
     }
 
+    private fun attachDecorativeClusters(level: LevelAccessor, gemPos: BlockPos, random: RandomSource) {
+        val openDirections = Direction.entries.filter { direction ->
+            level.getBlockState(gemPos.relative(direction)).isAir
+        }.toMutableList()
+
+        if (openDirections.isEmpty()) {
+            return
+        }
+
+        val minClusters = maxOf(1, (openDirections.size * 0.75f).toInt())
+        val clusterCount = random.nextInt(minClusters, openDirections.size + 1)
+
+        repeat(clusterCount) {
+            if (openDirections.isEmpty()) return@repeat
+
+            val index = random.nextInt(openDirections.size)
+            val direction = openDirections.removeAt(index)
+            val clusterPos = gemPos.relative(direction)
+            val stage = random.nextInt(0, 4)
+
+            val clusterState = defaultBlockState()
+                .setValue(FACING, direction)
+                .setValue(STAGE, stage)
+                .setValue(SHOULD_GROW, false) // so we can reduce lag... hopefully
+                .setValue(STUNTED, false)
+
+            level.setBlock(clusterPos, clusterState, UPDATE_ALL)
+        }
+    }
 
     fun gemClusterCanGrow(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        if (state.getValue(GROWTH_TYPE) == GrowthType.DECORATION) return false
-        if (state.getValue(GROWTH_TYPE) == GrowthType.STUNTED
-            && state.getValue(STAGE) == 3) return false
+        if (!state.getValue(SHOULD_GROW)) return false
 
         val supportPos = pos.relative(state.getValue(FACING).opposite)
         val supportBlock = level.getBlockState(supportPos).block
         return CobblemonBlocks.typeGemBlocks().containsValue(supportBlock) || (supportBlock == CobblemonBlocks.TYPE_GEM_CORE) // Cannot grow if not on any gem blocks
     }
 
-
     override fun getDrops(state: BlockState, params: LootParams.Builder): List<ItemStack> {
         val drops = super.getDrops(state, params)
 
@@ -178,7 +200,8 @@ class TypeGemClusterBlock(
                 DataComponents.BLOCK_STATE,
                 BlockItemStateProperties.EMPTY
                     .with(STAGE, state.getValue(STAGE))
-                    .with(GROWTH_TYPE, GrowthType.DECORATION)
+                    .with(SHOULD_GROW, false)
+                    .with(STUNTED, false)
             )
             stack.set(
                 DataComponents.CUSTOM_MODEL_DATA,
@@ -249,7 +272,7 @@ class TypeGemClusterBlock(
 
     override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
         super.createBlockStateDefinition(builder)
-        builder.add(FACING, STAGE, GROWTH_TYPE)
+        builder.add(FACING, SHOULD_GROW, STAGE, STUNTED)
     }
 
     override fun getCloneItemStack(level: LevelReader, pos: BlockPos, state: BlockState): ItemStack {
@@ -260,7 +283,8 @@ class TypeGemClusterBlock(
                 DataComponents.BLOCK_STATE,
                 BlockItemStateProperties.EMPTY
                     .with(STAGE, state.getValue(STAGE))
-                    .with(GROWTH_TYPE, GrowthType.DECORATION)
+                    .with(SHOULD_GROW, false)
+                    .with(STUNTED, false)
             )
             stack.set(
                 DataComponents.CUSTOM_MODEL_DATA,

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

@@ -11,10 +11,8 @@ package com.cobblemon.mod.common.block
 import com.cobblemon.mod.common.Cobblemon
 import com.cobblemon.mod.common.CobblemonBlocks
 import com.cobblemon.mod.common.api.tags.CobblemonBlockTags
-import com.cobblemon.mod.common.block.TypeGemClusterBlock.Companion.FACING
-import com.cobblemon.mod.common.block.TypeGemClusterBlock.Companion.GROWTH_TYPE
-import com.cobblemon.mod.common.block.TypeGemClusterBlock.Companion.STAGE
-import com.cobblemon.mod.common.block.TypeGemClusterBlock.GrowthType
+import com.cobblemon.mod.common.block.TypeGemClusterBlock.Companion.SHOULD_GROW
+import com.cobblemon.mod.common.block.TypeGemClusterBlock.Companion.STUNTED
 import net.minecraft.core.BlockPos
 import net.minecraft.core.Direction
 import net.minecraft.core.registries.BuiltInRegistries
@@ -23,8 +21,8 @@ import net.minecraft.server.level.ServerLevel
 import net.minecraft.util.RandomSource
 import net.minecraft.world.level.BlockGetter
 import net.minecraft.world.level.LevelAccessor
+import net.minecraft.world.level.WorldGenLevel
 import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.Blocks
 import net.minecraft.world.level.block.DirectionalBlock
 import net.minecraft.world.level.block.state.BlockState
 import java.util.*
@@ -32,6 +30,13 @@ import java.util.*
 class TypeGemCoreBlock(properties: Properties) : Block(properties) {
 
     companion object {
+        const val MAX_CONNECTED_GEMS = 7
+        const val MIN_DISTANCE_BETWEEN_GEMS = 1
+        const val CONTINUATION_CHANCE = 0.8f
+
+        // Upper safety check to prevent infinite loops
+        const val MAX_FORCE_GROW_ATTEMPTS = 64
+
         val BLOCK_TO_CLUSTER: Map<ResourceLocation, Block> by lazy {
             mapOf(
                 ResourceLocation.parse("cobblemon:normal_gem_block") to CobblemonBlocks.TYPE_GEM_CLUSTER_NORMAL,
@@ -55,6 +60,28 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
             )
         }
 
+        fun setStuntState(level: LevelAccessor, gemBlocks: List<Pair<BlockState, BlockPos>>, stunted: Boolean) {
+            for ((_, gemPos) in gemBlocks) {
+                for (dir in Direction.entries) {
+                    val neighborPos = gemPos.relative(dir)
+                    val neighborState = level.getBlockState(neighborPos)
+
+                    if (neighborState.block is TypeGemClusterBlock) {
+                        if (neighborState.hasProperty(STUNTED) && neighborState.getValue(STUNTED) != stunted) {
+
+                            var updatedState = neighborState.setValue(STUNTED, stunted)
+
+                            if (updatedState.hasProperty(SHOULD_GROW)) {
+                                updatedState = updatedState.setValue(SHOULD_GROW, !stunted)
+                            }
+
+                            level.setBlock(neighborPos, updatedState, 3)
+                        }
+                    }
+                }
+            }
+        }
+
         fun getConnectedGemBlocks(level: BlockGetter, pos: BlockPos): List<Pair<BlockState, BlockPos>> {
             val connectedGems = mutableListOf<Pair<BlockState, BlockPos>>()
             val visited = mutableSetOf<BlockPos>()
@@ -80,159 +107,119 @@ class TypeGemCoreBlock(properties: Properties) : Block(properties) {
             }
             return connectedGems
         }
-
-        fun addClustersToBlock(state: BlockState, pos: BlockPos, level: LevelAccessor, random: RandomSource) {
-            Direction.entries.forEach {
-                if (random.nextFloat() < Cobblemon.config.typeGemGrowthChance) {
-                    val faceState = level.getBlockState(pos.relative(it))
-                    val randomGrowthType = decideClusterGrowthType(level, pos)
-                    val newState = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(state.block)]?.defaultBlockState()
-                        ?.setValue(DirectionalBlock.FACING, it)
-                        ?.setValue(GROWTH_TYPE, randomGrowthType)
-                        ?: return
-
-                    if (faceState.`is`(Blocks.AIR)) {
-                        level.setBlock(pos.relative(it), newState, 3)
-                    }
-                }
-
-            }
-        }
-
-        private fun decideClusterGrowthType(level: LevelAccessor, pos: BlockPos, random: RandomSource = RandomSource.create()): GrowthType {
-            val growthTypes = if (getConnectedGemBlocks(level, pos).size > Cobblemon.config.typeGemMaxConnected) {
-                listOf(GrowthType.DECORATION, GrowthType.STUNTED)
-            } else {
-                GrowthType.entries
-            }
-            val totalChance = growthTypes.sumOf { it.chance.toDouble() }
-            var roll = random.nextDouble() * totalChance
-
-            for (type in growthTypes) {
-                roll -= type.chance.toDouble()
-                if (roll <= 0.0) {
-                    return type
-                }
-            }
-
-            return GrowthType.DECORATION
-        }
-    }
-
-    private fun getConnectedClusters(level: LevelAccessor, pos: BlockPos): List<Pair<BlockState, BlockPos>> {
-        val gemBlocks = getConnectedGemBlocks(level, pos)
-        val clusters = mutableListOf<Pair<BlockState, BlockPos>>()
-        val visited = mutableSetOf<BlockPos>()
-
-        for ((gemState, gemPos) in gemBlocks) {
-            val expectedCluster = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(gemState.block)] ?: continue
-
-            for (direction in Direction.entries) {
-                val clusterPos = gemPos.relative(direction)
-                if (!visited.add(clusterPos)) continue
-
-                val clusterState = level.getBlockState(clusterPos)
-                if (clusterState.block == expectedCluster) {
-                    clusters += clusterState to clusterPos
-                }
-            }
-        }
-        return clusters
     }
 
     override fun randomTick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        // should we tick at all?
-        if (random.nextFloat() >= Cobblemon.config.typeGemTickChance) {
-            return
-        }
-        val gemCount = getConnectedGemBlocks(level, pos).size
+        grow(level, pos, random)
+    }
 
-        // if growth has stopped fully but min growth hasn't been reached, randomly set a stopped bud to GROWTH_TYPE full
-        val clusters = getConnectedClusters(level, pos)
-        val fullClusterCount = clusters.count { (clusterState, _) ->
-            clusterState.getValue(GROWTH_TYPE) == GrowthType.FULL
+    fun forceGrow(level: WorldGenLevel, pos: BlockPos, random: RandomSource, percentage: Float) {
+        val desiredLength = MAX_CONNECTED_GEMS * percentage
+
+        repeat(MAX_FORCE_GROW_ATTEMPTS) {
+            val (grown, clusterSize) = grow(level, pos, random, true)
+            if (!grown || clusterSize >= desiredLength) return
         }
 
-        if (fullClusterCount == 0) {
-            if (gemCount < Cobblemon.config.typeGemMinGrowth && clusters.isNotEmpty()) {
-                println("Force set a cluster to FULL at size $gemCount")
-                val randomCluster = clusters.random()
-                level.setBlockAndUpdate(randomCluster.second, randomCluster.first.setValue(GROWTH_TYPE, GrowthType.FULL))
+        Cobblemon.LOGGER.warn(
+            "Forced type gem growth at {} stopped after {} attempts without reaching its target size; keeping the partial formation.",
+            pos,
+            MAX_FORCE_GROW_ATTEMPTS
+        )
+    }
+
+    private fun grow(
+        level: WorldGenLevel,
+        pos: BlockPos,
+        random: RandomSource,
+        forced: Boolean = false
+    ): Pair<Boolean, Int> {
+        val connectedGems = getConnectedGemBlocks(level, pos) // maybe we can store this and access it for better performance? check for changes in list rather than checking each time grow is called? idk
+        val gemCount = connectedGems.size
+        val overLimit = gemCount >= MAX_CONNECTED_GEMS
+
+        if (overLimit) {
+            // if there is no open air pockets to grow any new clusters then exit early
+            if (!hasBreathingRoom(level, connectedGems)) {
+                return Pair(false, gemCount)
+            }
+            // max type gem block count met, tell clusters to grow but not turn into blocks
+            setStuntState(level, connectedGems, true)
+            //return Pair(false, gemCount)
+        } else {
+            // make sure connected clusters know they can grow and turn into blocks
+            setStuntState(level, connectedGems, false)
+        }
+
+        val javaRandom = java.util.Random(random.nextLong())
+
+        for ((gemState, gemPos) in connectedGems.shuffled(javaRandom)) {
+            val registryKey = BuiltInRegistries.BLOCK.getKey(gemState.block)
+            val clusterBlock = BLOCK_TO_CLUSTER[registryKey] ?: continue // If there is no block to grow, skip the block
+
+            for (dir in Direction.entries.shuffled(javaRandom)) {
+                val targetPos = gemPos.relative(dir)
+                val targetState = level.getBlockState(targetPos)
+
+                if (!targetState.isAir) continue
+                if (!isPositionValidForGrowth(level, targetPos)) continue
+
+                // Place gem cluster
+                val placeState = clusterBlock.defaultBlockState()
+                    .setValue(DirectionalBlock.FACING, dir)
+                    .setValue(TypeGemClusterBlock.STAGE, 0)
+                    .setValue(SHOULD_GROW, true)
+
+                level.setBlock(targetPos, placeState, UPDATE_ALL)
+
+                // During world gen, the region silently discards writes into neighboring chunks that are already fully generated.
+                // Through ImposterProtoChunk with writes set to disabled. Checks if the block is still air after the write and skips if so as it can't be filled.
+                // Preventing infinite loops.
+                if (!level.getBlockState(targetPos).`is`(clusterBlock)) continue
+
+                if (forced) {
+                    forceAdvanceClusterGrowth(level, targetPos, random)
+                }
+
+                val updatedGemCount = if (forced) getConnectedGemBlocks(level, pos).size else connectedGems.size
+                return Pair(true, updatedGemCount)
             }
         }
 
-
-        expand(level, pos, random)
+        // println("[TypeGemCoreBlock] No valid spot found for gem placement.")
+        return Pair(false, connectedGems.size)
     }
 
-    fun expand(level: LevelAccessor, pos: BlockPos, random: RandomSource) {
-        getConnectedGemBlocks(level, pos).forEach {
-            val state = it.first
-            val pos = it.second
-            addClustersToBlock(state, pos, level, random)
-            growClusters(pos, level, random)
+    private fun forceAdvanceClusterGrowth(level: WorldGenLevel, clusterPos: BlockPos, random: RandomSource) {
+        repeat(5) {
+            val clusterState = level.getBlockState(clusterPos)
+            val clusterBlock = clusterState.block as? TypeGemClusterBlock ?: return
+            clusterBlock.advanceGrowth(clusterState, level, clusterPos, random)
         }
     }
 
-    private fun growClusters(pos: BlockPos, level: LevelAccessor, random: RandomSource) {
-        Direction.entries.forEach { direction ->
-            val relativePos = pos.relative(direction)
-            val relativeState = level.getBlockState(relativePos)
-            val clusterBlock = relativeState.block as? TypeGemClusterBlock ?: return@forEach
-
-            if (relativeState.getValue(DirectionalBlock.FACING) == direction &&
-                random.nextFloat() < Cobblemon.config.typeGemGrowthChance
-            ) {
-                clusterBlock.advanceGrowth(relativeState, level, relativePos, random)
+    private fun hasBreathingRoom(level: WorldGenLevel, gems: List<Pair<BlockState, BlockPos>>): Boolean {
+        for ((_, gemPos) in gems) {
+            for (dir in Direction.entries) {
+                if (level.getBlockState(gemPos.relative(dir)).isAir) {
+                    return true
+                }
             }
         }
+        return false
     }
 
-    private fun addInitialClusters(pos: BlockPos, level: ServerLevel, clusterType: TypeGemClusterBlock) {
-        Direction.entries.forEach {
-            val faceState = level.getBlockState(pos.relative(it))
-
-            if (faceState.`is`(Blocks.AIR)) {
-                level.setBlockAndUpdate(pos.relative(it), clusterType.defaultBlockState().setValue(
-                    DirectionalBlock.FACING, it)
-                    .setValue(GROWTH_TYPE, GrowthType.FULL)
-                )
-            }
+    private fun isPositionValidForGrowth(level: WorldGenLevel, pos: BlockPos): Boolean {
+        return Direction.entries.none { dir ->
+            val nearby = pos.relative(dir)
+            isGem(level.getBlockState(nearby)) &&
+                    pos.distManhattan(nearby) < MIN_DISTANCE_BETWEEN_GEMS
         }
     }
 
+    private fun isGem(state: BlockState): Boolean {
+        return state.`is`(CobblemonBlockTags.TYPE_GEM_BLOCKS)
+    }
+
     override fun isRandomlyTicking(state: BlockState): Boolean = true
-
-    private fun attachDecorativeClusters(level: LevelAccessor, gemPos: BlockPos, random: RandomSource) {
-        val openDirections = Direction.entries.filter { direction ->
-            level.getBlockState(gemPos.relative(direction)).isAir
-        }.toMutableList()
-
-        if (openDirections.isEmpty()) {
-            return
-        }
-
-        val gemState = level.getBlockState(gemPos)
-        val clusterBlock = BLOCK_TO_CLUSTER[BuiltInRegistries.BLOCK.getKey(gemState.block)] ?: return
-
-        val minClusters = maxOf(1, (openDirections.size * 0.75f).toInt())
-        val clusterCount = random.nextInt(minClusters, openDirections.size + 1)
-
-        repeat(clusterCount) {
-            if (openDirections.isEmpty()) return@repeat
-
-            val index = random.nextInt(openDirections.size)
-            val direction = openDirections.removeAt(index)
-            val clusterPos = gemPos.relative(direction)
-            val stage = random.nextInt(0, 4)
-
-            val clusterState = clusterBlock.defaultBlockState()
-                .setValue(FACING, direction)
-                .setValue(STAGE, stage)
-                .setValue(GROWTH_TYPE, GrowthType.DECORATION)
-
-            level.setBlock(clusterPos, clusterState, UPDATE_ALL)
-        }
-    }
-}
-
+}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/LobailaFlowerBlock.kt

@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.decor
-
-import net.minecraft.core.BlockPos
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.SimpleWaterloggedBlock
-import net.minecraft.world.level.block.TallFlowerBlock
-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.WATERLOGGED
-import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
-import net.minecraft.world.level.material.FluidState
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-
-class LobailaFlowerBlock(properties: Properties?) : TallFlowerBlock(properties), SimpleWaterloggedBlock {
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HALF, DoubleBlockHalf.LOWER)
-            .setValue(WATERLOGGED, false))
-    }
-
-    override fun getFluidState(blockState: BlockState): FluidState? {
-        return if (blockState.getValue(WATERLOGGED)) Fluids.WATER.getSource(false) else super.getFluidState(blockState);
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HALF, WATERLOGGED)
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState? {
-        val fluidState = context.level.getFluidState(context.clickedPos)
-        return this.defaultBlockState()
-            .setValue(
-                WATERLOGGED,
-                fluidState.type === Fluids.WATER
-            )
-    }
-
-    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
-
-    companion object {
-        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
-    }
-
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/MistleafFlowerBlock.kt

@@ -1,87 +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.decor
-
-import com.cobblemon.mod.common.CobblemonBlockEntities
-import com.cobblemon.mod.common.block.entity.MistleafFlowerBlockEntity
-import net.minecraft.core.BlockPos
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.BaseEntityBlock
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.EntityBlock
-import net.minecraft.world.level.block.SoundType
-import net.minecraft.world.level.block.TallFlowerBlock
-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.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.DoubleBlockHalf
-import net.minecraft.world.level.block.state.properties.IntegerProperty
-import net.minecraft.world.level.material.MapColor
-import net.minecraft.world.level.material.PushReaction
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class MistleafFlowerBlock(lightLevel: (BlockState) -> Int) :
-    EntityBlock,
-    TallFlowerBlock(
-        Properties.of()
-            .mapColor(MapColor.PLANT)
-            .noCollission()
-            .instabreak()
-            .sound(SoundType.GRASS)
-            .offsetType(OffsetType.XZ)
-            .ignitedByLava()
-            .pushReaction(PushReaction.DESTROY)
-            .lightLevel(lightLevel)
-    ) {
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HALF, DoubleBlockHalf.LOWER)
-            .setValue(GLOWING, 0))
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HALF, GLOWING)
-    }
-    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
-        return false
-    }
-
-    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
-
-    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity? {
-        return MistleafFlowerBlockEntity(pos, state)
-    }
-
-    override fun <T : BlockEntity?> getTicker(
-        level: Level,
-        state: BlockState,
-        blockEntityType: BlockEntityType<T?>
-    ): BlockEntityTicker<T?>? {
-        return if (level.isClientSide) null else BaseEntityBlock.createTickerHelper(blockEntityType as BlockEntityType<*>,
-            CobblemonBlockEntities.MISTLEAF_FLOWER, MistleafFlowerBlockEntity::serverTick) as BlockEntityTicker<T?>?
-    }
-
-    companion object {
-        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
-        val GLOWING = IntegerProperty.create("glowing", 0, 8)
-    }
-
-    override fun hasAnalogOutputSignal(state: BlockState): Boolean { return true }
-    override fun getAnalogOutputSignal(state: BlockState, level: Level, pos: BlockPos): Int {
-        return state.getValue(GLOWING) as Int
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/PauvilleaFlowerBlock.kt

@@ -1,104 +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.decor
-
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.RandomSource
-import net.minecraft.world.item.ItemStack
-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.Block
-import net.minecraft.world.level.block.Blocks
-import net.minecraft.world.level.block.BonemealableBlock
-import net.minecraft.world.level.block.DirectionalBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.level.block.state.StateDefinition
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class PauvilleaFlowerBlock(properties: Properties?) : DirectionalBlock(properties), BonemealableBlock {
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(FACING, Direction.DOWN))
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(FACING)
-    }
-
-    override fun getStateForPlacement(ctx: BlockPlaceContext): BlockState? {
-        var blockState = defaultBlockState()
-        val worldView = ctx.level
-        val blockPos = ctx.clickedPos
-        blockState = blockState.setValue(FACING, ctx.clickedFace) as BlockState
-        if (blockState.canSurvive(worldView, blockPos)) {
-            return blockState
-        }
-        return null
-    }
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, level: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        val facing = state.getValue(FACING)
-        if (direction == facing.opposite && !canSurvive(state, level, pos)) {
-            return Blocks.AIR.defaultBlockState()
-        }
-        return super.updateShape(state, direction, neighborState, level, pos, neighborPos)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        val direction = state.getValue(FACING) as Direction
-        val blockState = level.getBlockState(pos.relative(direction.opposite))
-        return blockState.isCollisionShapeFullBlock(level, pos) or blockState.canOcclude()
-    }
-
-    override fun codec(): MapCodec<PauvilleaFlowerBlock> = CODEC
-
-    override fun getShape(state: BlockState, blockGetter: BlockGetter, pos: BlockPos, collisionContext: CollisionContext): VoxelShape {
-        return when (state.getValue(FACING)) {
-            Direction.DOWN -> CEILING
-            Direction.NORTH -> WALL_NORTH
-            Direction.EAST -> WALL_EAST
-            Direction.SOUTH -> WALL_SOUTH
-            Direction.WEST -> WALL_WEST
-            Direction.UP -> FLOOR
-        }
-    }
-
-    companion object {
-        val CODEC: MapCodec<PauvilleaFlowerBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::PauvilleaFlowerBlock)
-        }
-        val FLOOR = Shapes.box(0.075, 0.0, 0.075, 0.925, 0.4375, 0.925)
-        val WALL_NORTH = Shapes.box(0.0, 0.0, 0.8125, 1.0, 1.0, 1.0)
-        val WALL_EAST = Shapes.box(0.0, 0.0, 0.0, 0.1875, 1.0, 1.0)
-        val WALL_SOUTH = Shapes.box(0.0, 0.0, 0.0, 1.0, 1.0, 0.1875)
-        val WALL_WEST = Shapes.box(0.8125, 0.0, 0.0, 1.0, 1.0, 1.0)
-        val CEILING = Shapes.box(0.075, 0.0, 0.075, 0.925, 1.0, 0.925)
-    }
-
-    override fun isValidBonemealTarget(level: LevelReader?, pos: BlockPos?, state: BlockState?): Boolean {
-        return true
-    }
-
-    override fun isBonemealSuccess(level: Level?, random: RandomSource?, pos: BlockPos?, state: BlockState?): Boolean {
-        return true
-    }
-
-    override fun performBonemeal(level: ServerLevel, random: RandomSource?, pos: BlockPos, state: BlockState?) {
-        popResource(level, pos, ItemStack(this))
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/PomohanaFlowerBlock.kt

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.decor
-
-
-import net.minecraft.core.BlockPos
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.block.PinkPetalsBlock
-import net.minecraft.world.level.block.state.BlockState
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-
-class PomohanaFlowerBlock(properties: Properties?) : PinkPetalsBlock(properties) {
-
-    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
-
-    companion object {
-        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
-    }
-
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/TerrainPlantBlock.kt

@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.decor
-
-import com.cobblemon.mod.common.CobblemonBlockEntities
-import com.cobblemon.mod.common.CobblemonBlocks
-import com.cobblemon.mod.common.block.entity.TerrainPlantBlockEntity
-import net.minecraft.core.BlockPos
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.RandomSource
-import net.minecraft.world.entity.Entity
-import net.minecraft.world.level.BlockGetter
-import net.minecraft.world.level.Level
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.BaseEntityBlock
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.EntityBlock
-import net.minecraft.world.level.block.TallFlowerBlock
-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.BooleanProperty
-import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.Shapes
-import net.minecraft.world.phys.shapes.VoxelShape
-
-class TerrainPlantBlock(properties: Properties) : TallFlowerBlock(properties), EntityBlock {
-
-    init {
-        registerDefaultState(stateDefinition.any()
-            .setValue(HALF, DoubleBlockHalf.LOWER)
-            .setValue(GLOWING, false))
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(HALF, GLOWING)
-    }
-    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
-        return false
-    }
-
-    override fun tick(state: BlockState, level: ServerLevel, pos: BlockPos, random: RandomSource) {
-        if (state.`is`(CobblemonBlocks.LUCIBELL)) { this.checkInside(level, pos, state) }
-    }
-
-    private fun checkInside(level: Level, pos: BlockPos, state: BlockState) {
-        // Only lower will handle this
-        val upperState = level.getBlockState(pos.above()).takeIf { it.`is`(CobblemonBlocks.LUCIBELL) && it.getValue(HALF) == DoubleBlockHalf.UPPER }
-
-        val entityInside = level.getEntities(null, state.getShape(level, pos).bounds().move(pos)).isNotEmpty()
-                || upperState?.let { level.getEntities(null, it.getShape(level, pos.above()).bounds().move(pos.above())).isNotEmpty() } ?: false
-
-        val glowingState = state.getValue(GLOWING)
-        if (glowingState != entityInside) {
-            level.setBlock(pos, state.setValue(GLOWING, entityInside), UPDATE_CLIENTS)
-            upperState?.let { level.setBlock(pos.above(), it.setValue(GLOWING, entityInside), UPDATE_CLIENTS) }
-        }
-        if (entityInside) level.scheduleTick(pos, this, 30) // tick occasionally to check if player inside
-    }
-
-    override fun entityInside(state: BlockState, level: Level, pos: BlockPos, entity: Entity) {
-        // Lucibell lower block will be our 'driver'
-        if (!level.isClientSide && !state.getValue(GLOWING) && state.`is`(CobblemonBlocks.LUCIBELL)) {
-            val halfState = state.getValue(HALF)
-            if (halfState == DoubleBlockHalf.UPPER) {
-                val lowerState = level.getBlockState(pos.below())
-                    .takeIf { it.`is`(CobblemonBlocks.LUCIBELL) && it.getValue(HALF) == DoubleBlockHalf.LOWER }
-                    ?: return
-                (lowerState.block as TerrainPlantBlock).checkInside(level, pos.below(), lowerState)
-            } else {
-                checkInside(level, pos, state)
-            }
-        }
-    }
-
-    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape = AABB
-
-    override fun newBlockEntity(pos: BlockPos, state: BlockState): BlockEntity {
-        return TerrainPlantBlockEntity(pos, state)
-    }
-
-    override fun <T : BlockEntity> getTicker(
-        level: Level,
-        state: BlockState,
-        blockEntityType: BlockEntityType<T?>
-    ): BlockEntityTicker<T?>? {
-        return if (level.isClientSide) null else BaseEntityBlock.createTickerHelper(blockEntityType as BlockEntityType<*>,
-            CobblemonBlockEntities.TERRAIN_PLANT, TerrainPlantBlockEntity::serverTick) as BlockEntityTicker<T?>?
-    }
-
-    companion object {
-        private val AABB = Shapes.box(0.125, 0.0, 0.125, 0.875, 1.0, 0.875)
-        val GLOWING = BooleanProperty.create("glowing")
-
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/TerrainSeedBlock.kt

@@ -1,273 +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.decor
-
-import com.cobblemon.mod.common.CobblemonBlocks
-import com.cobblemon.mod.common.CobblemonItems
-import com.cobblemon.mod.common.CobblemonSounds
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.RandomSource
-import net.minecraft.util.StringRepresentable
-import net.minecraft.world.entity.player.Player
-import net.minecraft.world.item.Item
-import net.minecraft.world.item.ItemStack
-import net.minecraft.world.level.*
-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
-import net.minecraft.world.level.block.state.properties.DoubleBlockHalf
-import net.minecraft.world.level.block.state.properties.EnumProperty
-import net.minecraft.world.level.block.state.properties.IntegerProperty
-import net.minecraft.world.level.material.Fluids
-import net.minecraft.world.phys.shapes.CollisionContext
-import net.minecraft.world.phys.shapes.VoxelShape
-
-@Suppress("OVERRIDE_DEPRECATION")
-class TerrainSeedBlock(private val terrainSeedType: TerrainSeedType, settings: Properties) : CropBlock(settings) {
-    companion object {
-        val CODEC: MapCodec<TerrainSeedBlock> = RecordCodecBuilder.mapCodec { it.group(
-            TerrainSeedType.CODEC.fieldOf("terrainSeedType").forGetter(TerrainSeedBlock::terrainSeedType),
-            propertiesCodec()
-        ).apply(it, ::TerrainSeedBlock) }
-        const val MATURE_AGE = 4
-        val AGE: IntegerProperty = IntegerProperty.create("age", 0, MATURE_AGE)
-        val HALF: EnumProperty<DoubleBlockHalf> = BlockStateProperties.DOUBLE_BLOCK_HALF
-
-        val AGE_TO_SHAPE = arrayOf(
-            box(2.0, 0.0, 2.0, 14.0, 6.0, 14.0), // Stage 0
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 1
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 2
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 3
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0),  // Stage 4
-        )
-
-        val AGE_TO_SHAPE_TOP = arrayOf(
-            box(2.0, 0.0, 2.0, 14.0, 1.0, 14.0), // Stage 0
-            box(2.0, 0.0, 2.0, 14.0, 1.0, 14.0), // Stage 1
-            box(2.0, 0.0, 2.0, 14.0, 8.0, 14.0), // Stage 2
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0), // Stage 3
-            box(2.0, 0.0, 2.0, 14.0, 16.0, 14.0),  // Stage 4
-        )
-    }
-
-    override fun codec(): MapCodec<out CropBlock> {
-        return CODEC
-    }
-
-    init {
-        this.registerDefaultState(
-            this.stateDefinition.any()
-                .setValue(AGE, 0)
-                .setValue(HALF, DoubleBlockHalf.LOWER)
-        )
-    }
-
-    override fun getAgeProperty(): IntegerProperty = AGE
-
-    override fun getMaxAge(): Int = MATURE_AGE
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(AGE, HALF)
-    }
-
-    override fun getBaseSeedId(): ItemLike = this.terrainSeedType.getSeed()
-
-    override fun getShape(state: BlockState, world: BlockGetter, pos: BlockPos, context: CollisionContext): VoxelShape =
-        if (state.getValue(HALF) == DoubleBlockHalf.UPPER) AGE_TO_SHAPE_TOP[getAge(state)] else AGE_TO_SHAPE[this.getAge(state)]
-
-    override fun randomTick(state: BlockState, world: ServerLevel, pos: BlockPos, random: RandomSource) {
-        if (state.getValue(HALF) == DoubleBlockHalf.UPPER || !canGrow(world, pos, state)) return
-
-        if (hasSufficientLight(world, pos) && random.nextInt(32) == 0) {
-            grow(world, pos, state, 1)
-        }
-    }
-
-    private fun canGrow(world: LevelReader, pos: BlockPos, state: BlockState): Boolean {
-        return !this.isMaxAge(state) && canSurvive(state, world, pos) && !(!canGrowInto(world, pos.above()) && state.getValue(AGE) >= 4)
-    }
-
-    private fun canGrowInto(world: LevelReader, pos: BlockPos): Boolean {
-        val blockState = world.getBlockState(pos)
-        return blockState.isAir || blockState.`is`(this.terrainSeedType.getCropBlock())
-    }
-
-    override fun updateShape(state: BlockState, direction: Direction, neighborState: BlockState, world: LevelAccessor, pos: BlockPos, neighborPos: BlockPos): BlockState {
-        return if (state.getValue(AGE) >= 2) {
-            super.updateShape(state, direction, neighborState, world, pos, neighborPos)
-        } else {
-            if (state.canSurvive(world, pos)) state else Blocks.AIR.defaultBlockState()
-        }
-    }
-
-    override fun isValidBonemealTarget(level: LevelReader, pos: BlockPos, state: BlockState): Boolean {
-        val posAndState = getLowerHalf(level, pos, state)
-        return if (posAndState == null) false else this.canGrow(
-            level,
-            posAndState.first,
-            posAndState.second
-        )
-    }
-
-    override fun performBonemeal(level: ServerLevel, random: RandomSource, pos: BlockPos, state: BlockState) {
-        val posAndState = getLowerHalf(level, pos, state)
-        if (posAndState != null) {
-            grow(level, posAndState.first, posAndState.second, getBonemealAgeIncrease(level))
-        }
-    }
-
-    fun grow(world: Level, pos: BlockPos, state: BlockState, increment: Int) {
-        if (!canGrow(world, pos, state)) return
-
-        val newAge = (this.getAge(state) + increment).coerceAtMost(this.maxAge)
-        world.setBlock(pos, state.setValue(this.ageProperty, newAge), UPDATE_CLIENTS)
-
-        val abovePos = pos.above()
-        val stateAbove = world.getBlockState(abovePos)
-        // Set top half depending on age
-        if (newAge >= (2)) {
-            if (stateAbove.isAir) {
-                world.setBlock(
-                    abovePos,
-                    this.defaultBlockState().setValue(AGE, newAge).setValue(HALF, DoubleBlockHalf.UPPER),
-                    UPDATE_CLIENTS
-                )
-            }
-            else if (stateAbove.hasProperty(HALF) && stateAbove.getValue(HALF) == DoubleBlockHalf.UPPER) {
-                world.setBlock(
-                    abovePos,
-                    stateAbove.setValue(AGE, newAge),
-                    UPDATE_CLIENTS
-                )
-            }
-        }
-        // Swaps blocks to the actual Flower when fully grown
-        if (newAge == this.maxAge) {
-            val nextStateLower = this.terrainSeedType.getFlowerBlock().defaultBlockState().setValue(HALF, DoubleBlockHalf.LOWER)
-            val nextStateUpper = this.terrainSeedType.getFlowerBlock().defaultBlockState().setValue(HALF, DoubleBlockHalf.UPPER)
-            world.setBlock(abovePos, nextStateUpper, UPDATE_CLIENTS)
-            world.setBlock(pos, nextStateLower, UPDATE_CLIENTS)
-        }
-    }
-
-    override fun getBonemealAgeIncrease(level: Level): Int {
-        return 1
-    }
-
-    override fun canSurvive(state: BlockState, world: LevelReader, pos: BlockPos): Boolean {
-        return when (state.getValue(HALF)) {
-            DoubleBlockHalf.LOWER -> {
-                val floorBlock = pos.below()
-                val floor = world.getBlockState(floorBlock)
-
-                floor.`is`(Blocks.FARMLAND)
-            }
-            DoubleBlockHalf.UPPER -> {
-                getLowerHalf(world, pos, state) != null
-                // Upper part survives only if the lower part is valid
-            }
-        }
-    }
-
-    private fun getLowerHalf(level: LevelReader, pos: BlockPos, state: BlockState): Pair<BlockPos, BlockState>? {
-        if (isLower(state)) {
-            return Pair(pos, state)
-        } else {
-            val blockPos = pos.below()
-            val blockState = level.getBlockState(blockPos)
-            return if (isLower(blockState)) Pair(
-                blockPos,
-                blockState
-            ) else null
-        }
-    }
-
-    private fun isLower(state: BlockState): Boolean =
-        state.`is`(this.terrainSeedType.getCropBlock()) && state.getValue(HALF) == DoubleBlockHalf.LOWER
-
-    override fun getSoundType(state: BlockState): SoundType {
-        return CobblemonSounds.HEARTY_GRAINS_SOUNDS
-    }
-
-    @Suppress("unused")
-    enum class TerrainSeedType : StringRepresentable {
-        ELECTRIC,
-        PSYCHIC,
-        MISTY,
-        GRASSY;
-        fun getSeed(): Item = when (this) {
-            ELECTRIC -> CobblemonItems.ELECTRIC_SEED
-            PSYCHIC -> CobblemonItems.PSYCHIC_SEED
-            MISTY -> CobblemonItems.MISTY_SEED
-            GRASSY -> CobblemonItems.GRASSY_SEED
-        }
-        fun getCropBlock(): TerrainSeedBlock = when (this) {
-            ELECTRIC -> CobblemonBlocks.ELECTRIC_SEED
-            PSYCHIC -> CobblemonBlocks.PSYCHIC_SEED
-            MISTY -> CobblemonBlocks.MISTY_SEED
-            GRASSY -> CobblemonBlocks.GRASSY_SEED
-        }
-        fun getFlowerBlock(): Block = when (this) {
-            ELECTRIC -> CobblemonBlocks.VOLTACONIA
-            PSYCHIC -> CobblemonBlocks.LUCIBELL
-            MISTY -> CobblemonBlocks.MISTLEAF
-            GRASSY -> CobblemonBlocks.VERDROOT
-        }
-
-        override fun getSerializedName(): String = this.name.lowercase()
-
-        companion object {
-            val CODEC = StringRepresentable.fromEnum(::values)
-        }
-    }
-
-    override fun playerWillDestroy(level: Level, pos: BlockPos, state: BlockState, player: Player): BlockState {
-        if (!level.isClientSide) {
-            if (player.isCreative()) {
-                preventDropFromBottomPart(level, pos, state, player)
-            } else {
-                dropResources(state, level, pos, null as BlockEntity?, player, player.getMainHandItem())
-            }
-        }
-
-        return super.playerWillDestroy(level, pos, state, player)
-    }
-
-    override fun playerDestroy(
-        level: Level,
-        player: Player,
-        pos: BlockPos,
-        state: BlockState,
-        blockEntity: BlockEntity?,
-        tool: ItemStack
-    ) {
-        super.playerDestroy(level, player, pos, Blocks.AIR.defaultBlockState(), blockEntity, tool)
-    }
-
-    fun preventDropFromBottomPart(level: Level, pos: BlockPos, state: BlockState, player: Player?) {
-        val doubleblockhalf = state.getValue<DoubleBlockHalf?>(DoublePlantBlock.HALF) as DoubleBlockHalf
-        if (doubleblockhalf == DoubleBlockHalf.UPPER) {
-            val blockpos = pos.below()
-            val blockstate = level.getBlockState(blockpos)
-            if (blockstate.`is`(state.getBlock()) && blockstate.getValue<DoubleBlockHalf?>(DoublePlantBlock.HALF) == DoubleBlockHalf.LOWER) {
-                val blockstate1 = if (blockstate.getFluidState()
-                        .`is`(Fluids.WATER)
-                ) Blocks.WATER.defaultBlockState() else Blocks.AIR.defaultBlockState()
-                level.setBlock(blockpos, blockstate1, 35)
-                level.levelEvent(player, 2001, blockpos, getId(blockstate))
-            }
-        }
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerBlock.kt

@@ -1,80 +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.decor
-
-import com.cobblemon.mod.common.CobblemonBlocks
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.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.BooleanProperty
-
-interface WistensuFlowerBlock {
-    fun additionalBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        builder.add(BlockStateProperties.FACING)
-        builder.add(ROOT)
-    }
-
-    fun adjustStateForPlacement(context: BlockPlaceContext, defaultState: BlockState): BlockState {
-        val upperBlock = context.level.getBlockState(context.clickedPos.relative(Direction.UP))
-        if (upperBlock.`is`(CobblemonBlocks.WISTENSU) || upperBlock.`is`(CobblemonBlocks.WISTENSU_VINE)) {
-            return defaultState
-                .setValue(BlockStateProperties.FACING, Direction.DOWN)
-                .setValue(ROOT, false)
-        } else {
-            var placeDirection = context.clickedFace
-            if (placeDirection == Direction.UP) placeDirection = Direction.DOWN
-            return defaultState
-                .setValue(BlockStateProperties.FACING, placeDirection)
-                .setValue(ROOT, true)
-        }
-    }
-
-    fun copyStateValues(target: BlockState, source: BlockState): BlockState {
-        return target
-            .setValue(ROOT, source.getValue(ROOT))
-            .setValue(BlockStateProperties.FACING, source.getValue(BlockStateProperties.FACING))
-    }
-
-    fun wisternCanSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        if (state.getValue(ROOT)) {
-            val facing = state.getValue(BlockStateProperties.FACING)
-            val targetPos = pos.relative(facing.opposite)
-            val directionState = level.getBlockState(targetPos)
-            return directionState.isFaceSturdy(level, targetPos, facing)
-        } else {
-            val topState = level.getBlockState(pos.relative(Direction.UP))
-            return topState.`is`(CobblemonBlocks.WISTENSU) || topState.`is`(CobblemonBlocks.WISTENSU_VINE)
-        }
-    }
-
-    fun wisternUpdateShape(state: BlockState, direction: Direction, neighborState: BlockState, level: LevelAccessor, pos: BlockPos, neighborPos: BlockPos, block: Block): BlockState? {
-        if (!wisternCanSurvive(state, level, pos)) {
-            level.scheduleTick(pos, block, 1)
-        }
-
-        if (direction == Direction.UP &&
-            (neighborState.`is`(CobblemonBlocks.WISTENSU) || neighborState.`is`(CobblemonBlocks.WISTENSU_VINE))) {
-            return state
-                .setValue(ROOT, false)
-                .setValue(BlockStateProperties.FACING, Direction.DOWN)
-        }
-
-        return null
-    }
-
-    companion object {
-        val ROOT = BooleanProperty.create("root")
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerHeadBlock.kt

@@ -1,114 +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.decor
-
-
-import com.cobblemon.mod.common.CobblemonBlocks
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.server.level.ServerLevel
-import net.minecraft.util.RandomSource
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.GrowingPlantHeadBlock
-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.phys.shapes.VoxelShape
-import kotlin.math.min
-
-//TODO: Root/connection shit
-class WistensuFlowerHeadBlock(properties: Properties?) : GrowingPlantHeadBlock(properties, Direction.DOWN, SHAPE, false, 0.1), WistensuFlowerBlock {
-    companion object {
-        val CODEC: MapCodec<WistensuFlowerHeadBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::WistensuFlowerHeadBlock)
-        }
-        val SHAPE: VoxelShape = box(1.0, 2.0, 1.0, 15.0, 16.0, 15.0)
-    }
-    override fun codec(): MapCodec<WistensuFlowerHeadBlock> = CODEC
-
-    override fun getBlocksToGrowWhenBonemealed(random: RandomSource): Int {
-        var d = 1.0
-        var i = 0
-        while (random.nextDouble() < d) {
-            d *= 0.826
-            ++i
-        }
-        return i
-    }
-
-    override fun canGrowInto(state: BlockState): Boolean {
-        return state.isAir
-    }
-
-    override fun getBodyBlock(): Block {
-        return CobblemonBlocks.WISTENSU_VINE
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        super.createBlockStateDefinition(builder)
-        additionalBlockStateDefinition(builder)
-    }
-
-    override fun updateShape(
-        state: BlockState,
-        direction: Direction,
-        neighborState: BlockState,
-        level: LevelAccessor,
-        pos: BlockPos,
-        neighborPos: BlockPos
-    ): BlockState {
-        val updateState = wisternUpdateShape(state, direction, neighborState, level, pos, neighborPos, this)
-        if (updateState != null) return updateState
-
-        if (direction == Direction.DOWN &&
-            (neighborState.`is`(CobblemonBlocks.WISTENSU) || neighborState.`is`(CobblemonBlocks.WISTENSU_VINE))) {
-            return updateBodyAfterConvertedFromHead(state, bodyBlock.defaultBlockState())
-        }
-        return state
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState {
-        val defaultState = super.getStateForPlacement(context)!!
-        return adjustStateForPlacement(context, defaultState)
-    }
-
-    override fun getGrowIntoState(state: BlockState, random: RandomSource): BlockState {
-        return super.getGrowIntoState(state, random)
-            .setValue(WistensuFlowerBlock.ROOT, false)
-            .setValue(BlockStateProperties.FACING, Direction.DOWN)
-    }
-
-    override fun updateBodyAfterConvertedFromHead(head: BlockState, body: BlockState): BlockState {
-        return copyStateValues(body, head)
-    }
-
-    override fun performBonemeal(level: ServerLevel, random: RandomSource, pos: BlockPos, state: BlockState) {
-        var blockPos = pos.relative(growthDirection)
-        var i = min(state.getValue(AGE), MAX_AGE)
-        val j = getBlocksToGrowWhenBonemealed(random)
-        var currentState = state
-
-        for (k in 0..<j) {
-            if (!canGrowInto(level.getBlockState(blockPos))) break
-            level.setBlockAndUpdate(blockPos, getGrowIntoState(currentState, random))
-            currentState = level.getBlockState(blockPos)
-            blockPos = blockPos.relative(growthDirection)
-            i = min(i + 1, MAX_AGE)
-        }
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return wisternCanSurvive(state, level, pos)
-    }
-}

common/src/main/kotlin/com/cobblemon/mod/common/block/decor/WistensuFlowerVineBlock.kt

@@ -1,77 +0,0 @@
-/*
- * Copyright (C) 2023 Cobblemon Contributors
- *
- * This Source Code Form is subject to the terms of the Mozilla Public
- * License, v. 2.0. If a copy of the MPL was not distributed with this
- * file, You can obtain one at https://mozilla.org/MPL/2.0/.
- */
-
-package com.cobblemon.mod.common.block.decor
-
-import com.cobblemon.mod.common.CobblemonBlocks
-import com.mojang.serialization.MapCodec
-import com.mojang.serialization.codecs.RecordCodecBuilder
-import net.minecraft.core.BlockPos
-import net.minecraft.core.Direction
-import net.minecraft.world.item.context.BlockPlaceContext
-import net.minecraft.world.level.LevelAccessor
-import net.minecraft.world.level.LevelReader
-import net.minecraft.world.level.block.Block
-import net.minecraft.world.level.block.GrowingPlantBodyBlock
-import net.minecraft.world.level.block.GrowingPlantHeadBlock
-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.phys.shapes.VoxelShape
-
-//TODO: Root/connection shit
-class WistensuFlowerVineBlock(properties: Properties?) : GrowingPlantBodyBlock(properties, Direction.DOWN, SHAPE, false), WistensuFlowerBlock
-{
-    companion object {
-        val CODEC: MapCodec<WistensuFlowerVineBlock> = RecordCodecBuilder.mapCodec {
-            it.group(propertiesCodec()).apply(it, ::WistensuFlowerVineBlock)
-        }
-        val SHAPE: VoxelShape = box(1.0, 0.0, 1.0, 15.0, 16.0, 15.0)
-    }
-    override fun codec(): MapCodec<WistensuFlowerVineBlock> = CODEC
-
-    override fun getHeadBlock(): GrowingPlantHeadBlock {
-        return CobblemonBlocks.WISTENSU
-    }
-
-    override fun createBlockStateDefinition(builder: StateDefinition.Builder<Block, BlockState>) {
-        super.createBlockStateDefinition(builder)
-        additionalBlockStateDefinition(builder)
-    }
-
-    override fun updateShape(
-        state: BlockState,
-        direction: Direction,
-        neighborState: BlockState,
-        level: LevelAccessor,
-        pos: BlockPos,
-        neighborPos: BlockPos
-    ): BlockState {
-        val updateState = wisternUpdateShape(state, direction, neighborState, level, pos, neighborPos, this)
-        if (updateState != null) return updateState
-
-        if (direction == Direction.DOWN &&
-                !neighborState.`is`(CobblemonBlocks.WISTENSU) && !neighborState.`is`(CobblemonBlocks.WISTENSU_VINE)) {
-            return updateHeadAfterConvertedFromBody(state, headBlock.getStateForPlacement(level))
-        }
-        return state
-    }
-
-    override fun getStateForPlacement(context: BlockPlaceContext): BlockState {
-        val defaultState = super.getStateForPlacement(context)!!
-        return adjustStateForPlacement(context, defaultState)
-    }
-
-    override fun updateHeadAfterConvertedFromBody(head: BlockState, body: BlockState): BlockState {
-        return copyStateValues(body, head)
-    }
-
-    override fun canSurvive(state: BlockState, level: LevelReader, pos: BlockPos): Boolean {
-        return wisternCanSurvive(state, level, pos)
-    }
-}

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

@@ -128,7 +128,6 @@ class DiscShelfBlockEntity(pos: BlockPos, state: BlockState) : BlockEntity(Cobbl
 
     fun isValidItem(stack: ItemStack): Boolean {
         return stack.item is TechnicalMachineItem
-                || stack.item == CobblemonItems.BLANK_TM
                 || stack.item == CobblemonItems.UPGRADE
                 || stack.item == CobblemonItems.DUBIOUS_DISC
                 || stack.has(DataComponents.JUKEBOX_PLAYABLE)