API publica para usuarios DLL

Si esta usando los niveles Lite, Basic, Pro u Online de MCE, el motor se distribuye como una DLL compilada sin codigo fuente. Esta guia explica la superficie de API publica que puede usar para interactuar con y extender MCE desde sus propios scripts C#.

El namespace SDK

MCE expone su API publica a traves del namespace OpenMon.MCE.SDK. Este contiene interfaces limpias que proporcionan acceso a los subsistemas del motor sin acoplar su codigo a implementaciones internas.

IMonsterCaptureEngine

El punto de entrada principal. Todas las demas interfaces se acceden a traves de esta:

using OpenMon.MCE.SDK;

public class MyGameManager : MonoBehaviour
{
    [Inject] private IMonsterCaptureEngine engine;

    private void Start()
    {
        Debug.Log($"MCE Version: {engine.Version}");
        Debug.Log($"Monsters in DB: {engine.Database.MonsterCount}");
        Debug.Log($"Player name: {engine.Player.PlayerName}");
    }
}

Propiedades:

Propiedad	Tipo	Descripcion
Database	IMonsterDatabase	Acceso de solo lectura a la base de datos de monstruos/movimientos/objetos
Battle	IBattleSystem	Estado de batalla y eventos
Player	IPlayerData	Equipo del jugador, dinero, nombre, medallas
SaveSystem	ISaveSystem	Operaciones de guardado y carga
Version	string	Cadena de version del motor MCE

IMonsterDatabase

Consultar monstruos, movimientos, habilidades, objetos y tipos:

IMonsterDatabase db = engine.Database;

// Get a monster by dex number
MonsterEntry flameleon = db.GetMonster(152);

// Get a monster by name
MonsterEntry sparkbit = db.GetMonster("Sparkbit");

// Get all monsters
IReadOnlyList<MonsterEntry> allMonsters = db.GetAllMonsters();

// Get a move
Move thunderbolt = db.GetMove("Thunderbolt");

// Get all moves
IReadOnlyList<Move> allMoves = db.GetAllMoves();

// Get type effectiveness
float effectiveness = db.GetTypeEffectiveness(
    MonsterType.Electric,
    MonsterType.Water
);
// Returns 2.0 (super effective)

// Get all types
IReadOnlyList<MonsterType> types = db.GetAllTypes();

// Get total count
int count = db.MonsterCount;

IBattleSystem

Monitorear el estado de batalla y responder a eventos de batalla:

IBattleSystem battle = engine.Battle;

// Check if a battle is in progress
if (battle.IsInBattle)
{
    // Do something during battle
}

// Subscribe to battle events
battle.OnBattleStarted += HandleBattleStarted;
battle.OnBattleEnded += HandleBattleEnded;

private void HandleBattleStarted()
{
    // Battle just started - maybe pause a timer, hide UI, etc.
}

private void HandleBattleEnded(bool playerWon)
{
    // Battle ended - playerWon tells you the result
    if (playerWon)
    {
        // Update custom win counter, trigger achievement, etc.
    }
}

IPlayerData

Acceder al estado actual del jugador:

IPlayerData player = engine.Player;

// Player's monster team
Roster roster = player.PlayerRoster;
int teamSize = roster.Count;
MonsterInstance firstMonster = roster[0];

// Player's money
int money = player.Money;

// Player's name
string name = player.PlayerName;

// Player's badge count
int badges = player.BadgeCount;

ISaveSystem

Controlar operaciones de guardado y carga:

ISaveSystem saves = engine.SaveSystem;

// Save to slot 1
saves.Save(1);

// Load from slot 1
saves.Load(1);

// Check if a slot has data
bool hasData = saves.HasSaveData(1);

// Delete save data
saves.DeleteSave(1);

// Listen for save/load events
saves.OnSaved += (slot) => Debug.Log($"Saved to slot {slot}");
saves.OnLoaded += (slot) => Debug.Log($"Loaded from slot {slot}");

Inyeccion de dependencias

MCE usa Zenject (Extenject) para inyeccion de dependencias. Para acceder a las interfaces del SDK en sus scripts, use el atributo [Inject]:

using Zenject;
using OpenMon.MCE.SDK;

public class MyCustomFeature : MonoBehaviour
{
    [Inject] private IMonsterCaptureEngine engine;
    [Inject] private IMonsterDatabase database;
    [Inject] private IBattleSystem battle;

    // Zenject will automatically inject these before Start() is called
}

Sin experiencia con Zenject?

Si es nuevo en la inyeccion de dependencias, aqui esta la version simple: anade [Inject] sobre un campo privado del tipo de interfaz, y Zenject lo rellenara automaticamente. No necesita llamar a GetComponent o FindObjectOfType. El campo sera poblado antes de que se ejecute Start().

Si su script no es un MonoBehaviour gestionado por Zenject, puede resolver manualmente:

var engine = ProjectContext.Instance.Container.Resolve<IMonsterCaptureEngine>();

Opciones configurables por Inspector

Muchos sistemas de MCE exponen configuracion a traves del Inspector de Unity sin requerir codigo:

Configuracion por ScriptableObject

Asset	Proposito	Ubicacion
BattleConfigurationFile	Velocidad de batalla, multiplicadores de XP, tasas de captura	Runtime/Configuration/
MonsterEntry	Datos de especies de monstruos	MonsterDatabase/
Move	Definiciones de movimientos	MonsterDatabase/Moves/
WildEncountersSet	Tablas de encuentros	Assets por mapa
BattleAI	Configuracion de estrategia de IA	Battle/AI/

Configuracion de componentes

La mayoria de los componentes de MCE exponen ajustes clave en el Inspector:

• PlayerCharacter: Velocidad de caminata, velocidad de carrera, puede correr, tiene bicicleta.
• EncounterTile: Tasa de encuentro, referencia al conjunto de encuentros.
• BattleLauncher: Referencia de escena de batalla, ajustes de transicion.
• SceneInfo: Nombre del mapa, BGM, region, encuentros predeterminados.

UnityEvents y callbacks

MCE expone varios UnityEvents en sus componentes que puede conectar en el Inspector sin codigo:

Eventos de PlayerCharacter

Evento	Se dispara cuando
OnStepTaken	El jugador da un paso
OnDirectionChanged	El jugador cambia la direccion en que mira
OnInteraction	El jugador presiona el boton de interaccion

Eventos de Actor

Los actores (NPCs, objetos) tienen eventos de callback:

Evento	Se dispara cuando
OnInteracted	El jugador interactua con el actor
OnGraphCompleted	El CommandGraph termina su ejecucion

Conecte estos en el Inspector arrastrando su MonoBehaviour al slot del evento y seleccionando el metodo a llamar.

Extender MCE sin codigo fuente

Patron 1: Escucha de eventos

Cree un MonoBehaviour que escuche eventos de MCE y active su propia logica:

public class AchievementTracker : MonoBehaviour
{
    [Inject] private IBattleSystem battle;
    [Inject] private IPlayerData player;

    private int battlesWon;

    private void OnEnable()
    {
        battle.OnBattleEnded += OnBattleEnded;
    }

    private void OnDisable()
    {
        battle.OnBattleEnded -= OnBattleEnded;
    }

    private void OnBattleEnded(bool playerWon)
    {
        if (playerWon)
        {
            battlesWon++;
            if (battlesWon >= 100)
                UnlockAchievement("Battle Master");
        }
    }
}

Patron 2: Consulta de base de datos

Use la API de base de datos para construir funcionalidades personalizadas:

public class TypeMatchupHelper : MonoBehaviour
{
    [Inject] private IMonsterDatabase database;

    public List<MonsterType> GetWeaknesses(MonsterType type)
    {
        var weaknesses = new List<MonsterType>();
        foreach (var attackType in database.GetAllTypes())
        {
            if (database.GetTypeEffectiveness(attackType, type) > 1f)
                weaknesses.Add(attackType);
        }
        return weaknesses;
    }
}

Patron 3: Integracion con guardado

Conectese al sistema de guardado para datos personalizados:

public class CustomSaveData : MonoBehaviour
{
    [Inject] private ISaveSystem saveSystem;

    private void OnEnable()
    {
        saveSystem.OnSaved += OnGameSaved;
        saveSystem.OnLoaded += OnGameLoaded;
    }

    private void OnGameSaved(int slot)
    {
        // Save your custom data alongside MCE's save
        string json = JsonUtility.ToJson(myCustomData);
        PlayerPrefs.SetString($"custom_data_slot_{slot}", json);
    }

    private void OnGameLoaded(int slot)
    {
        // Load your custom data
        string json = PlayerPrefs.GetString($"custom_data_slot_{slot}");
        myCustomData = JsonUtility.FromJson<MyData>(json);
    }
}

Patron 4: CommandGraph + scripts personalizados

Combine eventos de CommandGraph con sus MonoBehaviours personalizados:

1. Cree su script con un metodo publico.
2. En el CommandGraph, anade un nodo de evento de Actor.
3. En el Inspector, conecte el evento al metodo de su script.

Esto le permite activar logica C# personalizada desde scripting visual sin modificar las partes internas de MCE.

Lo que no puede hacer sin codigo fuente

Limitacion	Alternativa
Modificar la formula de dano	Use multiplicadores de configuracion en BattleConfigurationFile
Anadir nuevos modulos de batalla	Use la API de eventos de batalla para reaccionar al estado de batalla
Cambiar la fisica de movimiento	Ajuste parametros de velocidad y colision via Inspector
Anadir nuevos tipos de nodos de CommandGraph	Cree MonoBehaviours personalizados activados por eventos de Actor
Modificar disenos de UI	Sobreescriba prefabs (si estan expuestos) o superponga su propia UI encima

Necesita mas control?

Si encuentra la API publica demasiado limitante para su proyecto, considere actualizar al nivel Source. Incluye el codigo fuente C# completo y documentacion de arquitectura para personalizacion profunda.

Referencias de assembly

Para referenciar tipos de MCE en sus scripts, su definicion de assembly (.asmdef) debe referenciar:

{
    "references": [
        "OpenMon.MCE.Runtime"
    ]
}

Si no esta usando definiciones de assembly, los tipos de MCE estan disponibles globalmente a traves de la DLL.

Mejores practicas

1. Dependa de interfaces, no de implementaciones. Use IMonsterCaptureEngine, no clases concretas.
2. Desuscrbase de eventos. Siempre elimine manejadores de eventos en OnDisable u OnDestroy para prevenir fugas de memoria.
3. No almacene datos obsoletos en cache. Consulte el SDK cada vez que necesite datos actuales, especialmente para IPlayerData.
4. Use inyeccion de Zenject. Evite FindObjectOfType o singletons para acceder a MCE.
5. Consulte la referencia de API. Las interfaces del SDK tienen documentacion XML en cada miembro. Su IDE mostrara tooltips.