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

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):

{
  "depends": {
    "wild_battle_api": "*"
  }
}

NeoForge (META-INF/neoforge.mods.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:

dependencies {
    modCompileOnly files("libs/wild_battle_api-fabric-1.0.0.jar")
}

NeoForge example:

dependencies {
    compileOnly files("libs/wild_battle_api-neoforge-1.0.0.jar")
}

Use the loader-appropriate jar for your environment.

Registering a Provider

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:

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.

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

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