Wild Battle API

Minecraft 版本： 1.21.1

平台： fabric

标签： library

Please consider supporting me on ko-fi if you like the mod and can afford it, I appreciate even 1 dollar.

---

I grant permission to anyone seeking to add my mod to a modpack

---

Wild Battle API

Wild Battle API is a shared wild battle AI framework for Cobblemon.

For players and pack authors, it provides configurable smarter wild battle behavior with built-in presets and admin tools. For developers, it exposes a supported public API for registering custom wild BattleAI implementations without replacing Cobblemon internals directly.

Wild Battle API installs a delegating AI on wild battle actors at battle start. On each AI decision:

• Higher-priority providers are checked first.
• The first provider that returns a non-null BattleAI is used.
• Returning null defers to lower-priority providers.
• If no provider claims the context, the actor's original Cobblemon AI is used as fallback.

This lets multiple mods cooperate safely while keeping a reliable fallback path when no custom provider applies.

Included Features

• Shared API for wild battle AI extensions
• Priority-based provider resolution
• Safe fallback to the actor's original Cobblemon AI
• Built-in configurable smart wild AI behavior
• Difficulty presets from easy to extreme
• Admin UI and debug commands
• Fabric and NeoForge support for Minecraft 1.21.1

Admin Commands

Wild Battle API includes operator/admin commands for testing and configuration.

Commands:

• /wildbattleapi ui
• /wildbattleapi difficulty <easy|medium|hard|extreme>
• /wildbattleapi debug on
• /wildbattleapi debug off
• /wildbattleapi debug status

Aliases:

• /wba ui
• /wba difficulty <easy|medium|hard|extreme>
• /wba debug on|off|status

These commands require permission level 2.

Developer Usage ## Developer Usage ### Supported Public API Use only these classes for third-party integrations: - `com.github.raguto.wildbattleapi.api.WildBattleAPI` - `com.github.raguto.wildbattleapi.api.WildAIProvider` - `com.github.raguto.wildbattleapi.api.WildAIContext` Do not depend on internal packages such as `impl`, `mixin`, `config`, or `network`. ### Runtime Dependency Install Wild Battle API anywhere your dependent mod loads. In normal modpacks, that means both client and server. Mod ID: - `wild_battle_api` Also declare it as a dependency in your mod metadata. Fabric (`fabric.mod.json`): ```json { "depends": { "wild_battle_api": "*" } } ``` NeoForge (`META-INF/neoforge.mods.toml`): ```toml [[dependencies.your_mod_id]] modId = "wild_battle_api" type = "required" versionRange = "[1.0.0,)" ordering = "AFTER" side = "BOTH" ``` Adjust the minimum version to the first Wild Battle API version your mod supports. ### Compile-Time Dependency If you are not consuming a published Maven artifact, compile against the loader-specific jar directly. Fabric example: ```gradle dependencies { modCompileOnly files("libs/wild_battle_api-fabric-1.0.0.jar") } ``` NeoForge example: ```gradle dependencies { compileOnly files("libs/wild_battle_api-neoforge-1.0.0.jar") } ``` Use the loader-appropriate jar for your environment. ### Registering a Provider Register your provider once during your mod's common initialization. ```java import com.github.raguto.wildbattleapi.api.WildBattleAPI; import com.github.raguto.wildbattleapi.api.WildAIContext; public final class MyWildAIRegistration { public static void init() { WildBattleAPI.registerProvider(150, context -> { if (shouldUseMyAI(context)) { return new MyCustomWildBattleAI(); } return null; }); } private static boolean shouldUseMyAI(WildAIContext context) { return context.getBattle() != null && context.getActor() != null; } } ``` You can also register at the default priority: ```java WildBattleAPI.registerProvider(context -> null); ``` ### Priority Guidance - `0`: catch-all or default provider - `50`: standard override - `100+`: high-priority or boss-specific override - `200+`: hard override, use carefully If your provider only handles specific cases, return `null` for everything else. ### Implementing Your Own BattleAI You may provide any class that implements Cobblemon's `BattleAI`. ```java import com.cobblemon.mod.common.api.battles.model.PokemonBattle; import com.cobblemon.mod.common.api.battles.model.ai.BattleAI; import com.cobblemon.mod.common.battles.ActiveBattlePokemon; import com.cobblemon.mod.common.battles.BattleSide; import com.cobblemon.mod.common.battles.PassActionResponse; import com.cobblemon.mod.common.battles.ShowdownActionResponse; import com.cobblemon.mod.common.battles.ShowdownMoveset; import com.cobblemon.mod.common.net.messages.client.battle.BattleHealthChangePacket; import org.jetbrains.annotations.Nullable; public final class MyCustomWildBattleAI implements BattleAI { @Override public ShowdownActionResponse choose( ActiveBattlePokemon activeBattlePokemon, PokemonBattle battle, BattleSide side, @Nullable ShowdownMoveset moveset, boolean forceSwitch ) { if (forceSwitch || moveset == null) { return PassActionResponse.INSTANCE; } // Replace this with your own move or switch logic. return PassActionResponse.INSTANCE; } @Override public void onHealthChange(BattleHealthChangePacket packet) { // Optional state tracking. } } ``` ### WildAIContext `WildAIContext` gives providers the information needed to decide whether to claim a wild battle actor. Always available: - `getActor()` - `getPokemonList()` - `getBattle()` - `isForceSwitch()` Nullable depending on the current decision: - `getActiveBattlePokemon()` - `getAiSide()` - `getMoveset()` Guard nullable fields before using them. ### Integration Notes - Keep provider logic fast and predictable. - Return `null` when your mod does not want to claim the current context. - Avoid throwing exceptions from provider or AI logic. - Test in both dedicated server and integrated singleplayer. - If multiple mods register providers, higher numeric priority is checked first.

Licensing

Wild Battle API code and binaries are All Rights Reserved.

Third-party usage and distribution permissions are defined by the author policy on the mod page.