roleplayer/dist/index.d.mts

A library for building table top role playing game worlds, and managing campaigns in those worlds

type Id = string;
declare function generateId(): Id;

type ResourceDefinition = {
    id: Id;
    name: string;
    defaultMax?: number;
};
/**
 * @module core/actor
 */
type Resource = {
    resourceTypeId: ResourceDefinition["id"];
    amount: number;
    max: number;
    min: number;
};
/**
 * @module core/actor
 */
type ResourceGeneration = {
    resourceTypeId: ResourceDefinition["id"];
    amount: number;
};
declare const MovementSpeedResourceTypeName = "Movement speed";
declare const HealthResourceTypeName = "Health";
declare const PrimaryActionResourceTypeName = "Primary action";
declare const SecondaryActionResourceTypeName = "Secondary action";

type NonFunctionKeyNames<T> = Exclude<
  {
    [key in keyof T]: T[key] extends Function ? never : key;
  }[keyof T],
  undefined
>;

type OmitFunctions<T> = Pick<T, NonFunctionKeyNames<T>>;

/**
 * Required
 * @desc From `T` make a set of properties by key `K` become required
 * @example
 *    type Props = {
 *      name?: string;
 *      age?: number;
 *      visible?: boolean;
 *    };
 *
 *    // Expect: { name: string; age: number; visible: boolean; }
 *    type Props = Required<Props>;
 *
 *    // Expect: { name?: string; age: number; visible: boolean; }
 *    type Props = Required<Props, 'age' | 'visible'>;
 */
type WithRequired<T extends object, K extends keyof T = keyof T> = Omit<T, K> & Required<Pick<T, K>>;

/**
 * @module core/actions
 */
type StatusDefinition = {
    id: Id;
    name: string;
    type: StatusType;
    appliesEffects: {
        effect: EffectEventDefinition;
        appliesAt: RoleplayerEvent["type"];
    }[];
    durationType: StatusDurationType;
    duration?: number;
};
/**
 * @module core/actions
 */
declare enum StatusType {
    Curse = "Curse",
    Poison = "Poison",
    Magic = "Magic",
    Physical = "Physical"
}
/**
 * @module core/actions
 */
declare enum StatusDurationType {
    Permanent = "Permanent",
    UntilLongRest = "UntilLongRest",
    UntilShortRest = "UntilShortRest",
    NumberOfRounds = "NumberOfRounds"
}

type Party = {
    id: Id;
};

type Func<TEvent = unknown> = (event: TEvent) => void;
declare class Observable<TEvent = unknown> {
    private observers;
    subscribe(func: Func<TEvent>): () => void;
    unsubscribe(func: Func<TEvent>): void;
    notify(event: TEvent): void;
}

interface Logger {
    info(...args: any[]): void;
    debug(...args: any[]): void;
    warn(...args: any[]): void;
    error(...args: any[]): void;
}

declare enum Rarity {
    Common = "Common",
    Uncommon = "Uncommon",
    Rare = "Rare",
    Epic = "Epic",
    Legendary = "Legendary",
    Artifact = "Artifact"
}

declare enum ItemType {
    Equipment = "Equipment",
    Consumable = "Consumable"
}
declare enum ItemEquipmentType {
    None = "None",
    Shield = "Shield",
    OneHandWeapon = "OneHandWeapon",
    TwoHandWeapon = "TwoHandWeapon",
    BodyArmor = "BodyArmor"
}
declare enum ItemSlot {
    Inventory = "Inventory",
    MainHand = "MainHand",
    OffHand = "OffHand",
    Head = "Head",
    Feet = "Feet",
    Chest = "Chest"
}
type EquipmentSlotDefinition = {
    id: Id;
    name: string;
    eligibleEquipmentTypes: ItemEquipmentType[];
};
type ItemDefinition = {
    id: Id;
    name: string;
    type: ItemType;
    rarity: Rarity;
    description: string;
    stats: CharacterAttribute[];
    equipmentType: ItemEquipmentType;
    weightUnits: number;
    /**
     * Actions available for the item.
     */
    actions: ActionDefinition[];
    /**
     * An item may occupy additional slots while equipped.
     */
    occupiesSlots: ItemSlot[];
};

type Dispatcher = (...events: CampaignEvent[]) => void;
type StateGetter = () => Roleplayer;
type ActionDispatch<T = void> = (dispatch: Dispatcher, getState: StateGetter) => T;
declare function startCampaign(): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function addCharacterItem(characterId: Actor["id"], itemDefinitionId: ItemDefinition["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function removeCharacterItem(characterId: Actor["id"], characterInventoryItemId: CharacterInventoryItem["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function addCharacterEquipmentSlot(characterId: Actor["id"], equipmentSlotId: EquipmentSlotDefinition["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterUnEquipItem(characterId: Actor["id"], equipmentSlotId: EquipmentSlotDefinition["id"], itemId?: ItemDefinition["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterEquipItem(characterId: Actor["id"], equipmentSlotId: EquipmentSlotDefinition["id"], itemId: ItemDefinition["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function addActionToCharacter(characterId: Actor["id"], actionId: ActionDefinition["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function setCharacterStats(characterId: Actor["id"], stats: CharacterAttribute[]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterResourceGain(characterId: Actor["id"], resourceTypeId: ResourceDefinition["id"], amount: number): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function setCharacterClasses(characterId: Actor["id"], classes: CharacterClass[]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function setCharacterName(characterId: Actor["id"], name: string): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterGainExperience(characterId: Actor["id"], experience: number): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function addCharacterToCurrentBattle(characterId: Actor["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function spawnCharacterFromTemplate(templateId: Actor["id"]): ActionDispatch<string>;
declare function characterDespawn(actorId: Actor["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterBattleEnter(actorId: Actor["id"], battleId: Battle["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function characterBattleLeave(actorId: Actor["id"], battleId: Battle["id"]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function createCharacterWithDefaults(characterId: Actor["id"], name: string): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function nextRound(battleId?: Battle["id"]): (dispatch: Dispatcher, getState: StateGetter) => string;
declare function endRound(): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function startBattle(): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function endBattle(battleId: string): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function performCharacterAttack(attacker: Actor, actionDef: ActionDefinition, targets: Actor[]): (dispatch: Dispatcher, getState: StateGetter) => void;
declare function endCharacterTurn(actor: Actor): (dispatch: Dispatcher, getState: StateGetter) => void;

type RoleplayerCampaignParameters = Omit<ConstructorParameters<typeof CampaignState>[0], "roleplayer" | "ruleset">;
/**
 * The core of this library contains a few systems that are common for most or all roleplaying games.
 * It is designed to be extended and customized to fit the needs of a roleplaying game.
 *
 * - Action and effects system
 * - Battle system
 *    - NPC actions
 *    - Resource generation system
 *    - Round action tracking
 * - Character system
 *    - Resource system
 *    - Inventory system
 *    - Stats system
 *    - Level progression system
 * - World building system
 * - NPC system
 *    - Relationship system
 * - Dice rolling system
 * - Campaign system
 *    - Factions/relationships system
 *    - Quest system
 *    - Exploration system
 *
 * It is all backed up by a rich event system where subsystems can subscribe and publish events.
 *
 */
declare class Roleplayer extends Observable<RoleplayerEvent> {
    ruleset: Ruleset;
    events: RoleplayerEvent[];
    campaign: CampaignState;
    logger?: Logger;
    constructor(config: WithRequired<Partial<Roleplayer>, "ruleset">, initialCampaignConfig: RoleplayerCampaignParameters);
    setLogger(logger: Logger): void;
    nextSerialNumber(): number;
    dispatchAction<T>(action: ActionDispatch<T>): T;
    dispatchEvents(...events: CampaignEvent[]): void;
    dispatch(event: CampaignEvent): void;
    reduce(event: RoleplayerEvent): void;
    debugEvent(event: RoleplayerEvent): void;
    debugEventProcessing(events: RoleplayerEvent[]): void;
}

declare class Battle {
    id: Id;
    name: string;
    roleplayer: Roleplayer;
    ruleset: Ruleset;
    actors: Actor[];
    actorToAct: Actor | undefined;
    actorsThatHaveActed: Actor[];
    unsubscribe: (() => void) | undefined;
    constructor(b: WithRequired<Partial<Omit<Battle, "ruleset">>, "name" | "id" | "roleplayer">);
    isBattleOver(): boolean;
    addBattleActor(actor: Actor): void;
    getActingOrder(): Actor[];
    removeBattleActor(actor: Actor): void;
    calculateTargetsCone(position: Position, range: number, radius: number, angle: number): Actor[];
    calculateTargetsLine(position: Position, range: number, radius: number, angle: number): Actor[];
    calculateTargetsCircle(position: Position, range: number, radius: number, angle: number): Actor[];
    performAction(actor: Actor, actionDef: ActionDefinition, targets: Actor[]): boolean;
    reduce(event: RoleplayerEvent): void;
    dispose(): void;
}

type Round = {
    id: Id;
    roundNumber: number;
};

declare enum Alignment {
    NeutralEvil = "NeutralEvil",
    LawfulEvil = "LawfulEvil",
    ChaoticEvil = "ChaoticEvil",
    NeutralNeutral = "NeutralNeutral",
    EvilNeutral = "EvilNeutral",
    GoodNeutral = "GoodNeutral",
    NeutralGood = "NeutralGood",
    LawfulGood = "LawfulGood",
    ChaoticGood = "ChaoticGood"
}
type ElementDefinition = {
    id: Id;
    name: string;
};
type LevelProgression = {
    id: Id;
    requiredXp: number;
    unlocksLevel: number;
};
type ClassLevelProgression = {
    unlockedAtLevel: number;
    actionDefinitionId: ActionDefinition["id"];
};
type Race = {
    id: Id;
    name: string;
};
type Clazz = {
    id: Id;
    name: string;
    levelProgression: ClassLevelProgression[];
};
type CharacterStatType = {
    id: Id;
    name: string;
};
/**
 * A ruleset should implement rules from a table top game system.
 *
 * - Level progression definition (how much xp per level, what is unlocked at each level)
 * - Stat types (str, dex, con, int, wis, cha -- what does what?)
 * - Professions (classes)
 * - Character resources (health, mana, movement, etc)
 * - Equipment / inventory slots (main hand, off hand, head, chest, etc)
 * - Effects (what happens when a character gets hit, what happens when a character hits)
 * - Elements (fire, water, earth, air, psychic, physical, etc)
 * - Battle rules, who acts first, what determines a hit or a dodge on attack
 *
 */
interface Ruleset {
    getLevelProgression(): LevelProgression[];
    getCharacterStatTypes(): CharacterStatType[];
    getCharacterResourceTypes(): ResourceDefinition[];
    getCharacterEquipmentSlots(): EquipmentSlotDefinition[];
    getClassDefinitions(): Clazz[];
    getElementDefinitions(): ElementDefinition[];
    getCurrentActorTurn(battle: Battle): Actor | undefined;
    getActingOrder(actors: Actor[]): Actor[];
    characterHit(attacker: Actor, action: ActionDefinition, defender: Actor): boolean;
    characterHitDamage(source: Actor, action: ActionDefinition, target: Actor, effect: CharacterResourceLossEffect): number;
    characterResistanceMultiplier(actor: Actor, damageType: ElementDefinition): number;
    characterResistanceAbsolute(actor: Actor, damageType: ElementDefinition): number;
    characterResourceGeneration(actor: Actor): ResourceGeneration[];
    characterElementDamageMultiplier(actor: Actor, damageType: ElementDefinition): number;
    characterIsDead(actor: Actor): boolean;
}

type EventIdentifier = {
    id: Id;
    serialNumber: number;
};
type RoundEvent = {
    roundId: Round["id"];
    battleId?: Battle["id"];
};
type BattleCampaignEvent = CampaignEvent & {
    battleId: Battle["id"];
};
type CampaignEvent = SystemEvent | CharacterEvent;
type RoleplayerEvent = EventIdentifier & RoundEvent & CampaignEvent;
declare enum CharacterEventTypes {
    CharacterSpawned = "CharacterSpawned",
    CharacterNameSet = "CharacterNameSet",
    CharacterResourceMaxSet = "CharacterResourceMaxSet",
    CharacterResourceGain = "CharacterResourceGain",
    CharacterResourceLoss = "CharacterResourceLoss",
    CharacterStatChange = "CharacterStatChange",
    CharacterExperienceChanged = "CharacterExperienceChanged",
    CharacterExperienceSet = "CharacterExperienceSet",
    CharacterDespawn = "CharacterDespawn",
    CharacterMovement = "CharacterMovement",
    CharacterEndTurn = "CharacterEndTurn",
    CharacterActionGain = "CharacterActionGain",
    CharacterEquipmentSlotGain = "CharacterEquipmentSlotGain",
    CharacterInventoryItemGain = "CharacterInventoryItemGain",
    CharacterInventoryItemLoss = "CharacterInventoryItemLoss",
    CharacterInventoryItemEquip = "CharacterInventoryItemEquip",
    CharacterInventoryItemUnEquip = "CharacterInventoryItemUnEquip",
    CharacterPositionSet = "CharacterPositionSet",
    CharacterStatusGain = "CharacterStatusGain",
    CharacterAttackAttackerHit = "CharacterAttackAttackerHit",
    CharacterAttackAttackerMiss = "CharacterAttackAttackerMiss",
    CharacterAttackDefenderHit = "CharacterAttackDefenderHit",
    CharacterAttackDefenderDodge = "CharacterAttackDefenderDodge",
    CharacterAttackDefenderParry = "CharacterAttackDefenderParry",
    CharacterClassReset = "CharacterClassReset",
    CharacterClassLevelGain = "CharacterClassLevelGain"
}
declare enum SystemEventType {
    Unknown = "Unknown",
    CampaignStarted = "CampaignStarted",
    RoundStarted = "RoundStarted",
    RoundEnded = "RoundEnded",
    BattleStarted = "BattleStarted",
    BattleEnded = "BattleEnded",
    CharacterBattleEnter = "CharacterBattleEnter",
    CharacterBattleLeave = "CharacterBattleLeave"
}
type RoleplayerEventTypes = typeof CharacterEventTypes & typeof SystemEventType;
type SystemEvent = {
    type: SystemEventType.Unknown;
} | {
    type: SystemEventType.CampaignStarted;
} | {
    type: SystemEventType.RoundStarted;
    roundId: Round["id"];
    battleId?: Battle["id"];
} | {
    type: SystemEventType.RoundEnded;
} | {
    type: SystemEventType.BattleStarted;
    battleId: Battle["id"];
} | {
    type: SystemEventType.BattleEnded;
    battleId: Battle["id"];
} | {
    type: SystemEventType.CharacterBattleEnter;
    characterId: Actor["id"];
    battleId: Battle["id"];
} | {
    type: SystemEventType.CharacterBattleLeave;
    characterId: Actor["id"];
    battleId: Battle["id"];
};
type CharacterEvent = {
    type: CharacterEventTypes.CharacterSpawned;
    characterId: Actor["id"];
    templateCharacterId?: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterNameSet;
    characterId: Actor["id"];
    name: string;
} | {
    type: CharacterEventTypes.CharacterResourceMaxSet;
    characterId: Actor["id"];
    resourceTypeId: ResourceDefinition["id"];
    max: number;
} | {
    type: CharacterEventTypes.CharacterResourceGain;
    characterId: Actor["id"];
    amount: number;
    resourceTypeId: ResourceDefinition["id"];
    actionId?: ActionDefinition["id"];
    sourceId?: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterResourceLoss;
    characterId: Actor["id"];
    amount: number;
    resourceTypeId: ResourceDefinition["id"];
    actionId?: ActionDefinition["id"];
    sourceId?: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterStatChange;
    characterId: Actor["id"];
    amount: number;
    statId: CharacterStatType["id"];
} | {
    type: CharacterEventTypes.CharacterExperienceChanged;
    characterId: Actor["id"];
    experience: number;
} | {
    type: CharacterEventTypes.CharacterExperienceSet;
    characterId: Actor["id"];
    experience: number;
} | {
    type: CharacterEventTypes.CharacterDespawn;
    characterId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterMovement;
    characterId: Actor["id"];
    targetPosition: Position;
    sourceId?: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterEndTurn;
    characterId: Actor["id"];
    battleId: Battle["id"];
} | {
    type: CharacterEventTypes.CharacterActionGain;
    characterId: Actor["id"];
    actionId: Id;
} | {
    type: CharacterEventTypes.CharacterEquipmentSlotGain;
    characterId: Actor["id"];
    equipmentSlotId: Id;
} | {
    type: CharacterEventTypes.CharacterInventoryItemGain;
    characterId: Actor["id"];
    itemDefinitionId: ItemDefinition["id"];
    itemInstanceId: CharacterInventoryItem["id"];
} | {
    type: CharacterEventTypes.CharacterInventoryItemLoss;
    characterId: Actor["id"];
    characterInventoryItemId: ItemDefinition["id"];
} | {
    type: CharacterEventTypes.CharacterInventoryItemEquip;
    characterId: Actor["id"];
    itemId: ItemDefinition["id"];
    equipmentSlotId: Id;
} | {
    type: CharacterEventTypes.CharacterInventoryItemUnEquip;
    characterId: Actor["id"];
    itemId?: ItemDefinition["id"];
    equipmentSlotId: Id;
} | {
    type: CharacterEventTypes.CharacterPositionSet;
    characterId: Actor["id"];
    targetPosition: Position;
} | {
    type: CharacterEventTypes.CharacterStatusGain;
    characterId: Actor["id"];
    actionId: ActionDefinition["id"];
    sourceId?: Actor["id"];
    statusId: Id;
} | {
    type: CharacterEventTypes.CharacterAttackAttackerHit;
    characterId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterAttackAttackerMiss;
    characterId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterAttackDefenderHit;
    attackerId: Actor["id"];
    characterId: Actor["id"];
    actionDefinitionId: ActionDefinition["id"];
} | {
    type: CharacterEventTypes.CharacterAttackDefenderDodge;
    characterId: Actor["id"];
    actionId: ActionDefinition["id"];
    attackerId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterAttackDefenderParry;
    characterId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterClassReset;
    characterId: Actor["id"];
} | {
    type: CharacterEventTypes.CharacterClassLevelGain;
    characterId: Actor["id"];
    classId: Clazz["id"];
};
declare function isBattleEvent(event: CampaignEvent): event is BattleCampaignEvent;

/**
 * @module core/actor
 */
type Position = {
    x: number;
    y: number;
    z: number;
};
/**
 * @module core/actor
 */
type CharacterClass = {
    level: number;
    classId: Clazz["id"];
};
/**
 * @module core/actor
 */
type CharacterEquipmentSlot = {
    item?: CharacterInventoryItem;
    slotId: EquipmentSlotDefinition["id"];
};
type CharacterInventoryItem = {
    id: Id;
    definition: ItemDefinition;
};
/**
 * @module core/actor
 */
type Reaction = {
    id: Id;
    name: string;
    type: ReactionEventType;
    eventType: RoleplayerEvent["type"];
    action: ActionDefinition;
};
/**
 * @module core/actor
 */
declare enum ReactionEventType {
    OnHit = "OnHit",
    OnDodge = "OnDodge"
}
/**
 * @module core/actor
 */
type ReactionResource = {
    reactionId: Reaction["id"];
    targetId: Actor["id"];
};
/**
 * @module core/actor
 *
 * Character attributes represents numerically measurable qualities of a character are persistent over time, for example between battles. Stuff like strength, agility, etc.
 *
 * For expendable/regenerative attributes, see character resources.
 */
type CharacterAttribute = {
    statId: CharacterStatType["id"];
    amount: number;
};
declare function isCharacterEvent(event: RoleplayerEvent): event is Extract<RoleplayerEvent, {
    characterId: Actor["id"];
}>;
/**
 * Actor template type, inherited from Actor, with campaign being a required property and all methods stripped.
 */
type ActorTemplate = OmitFunctions<Required<Omit<ConstructorParameters<typeof Actor>[0], "campaign">>>;
/**
 * @module core/actor
 */
declare class Actor {
    id: Id;
    party: Party["id"];
    exists: boolean;
    templateCharacterId?: Actor["id"];
    characterType: "Player" | "NPC" | "Monster";
    xp: number;
    name: string;
    race: Race["id"];
    description?: string;
    alignment: Alignment;
    classes: CharacterClass[];
    inventory: CharacterInventoryItem[];
    equipment: CharacterEquipmentSlot[];
    stats: CharacterAttribute[];
    actions: ActionDefinition[];
    statuses: StatusDefinition[];
    position: Position;
    resources: Resource[];
    reactionsRemaining: ReactionResource[];
    reactions: Reaction[];
    campaign: CampaignState;
    unsubscribe: (() => void) | undefined;
    constructor(a: WithRequired<Partial<Actor>, "campaign">);
    resetResources(generation: ResourceGeneration[]): void;
    action(actionDefinition: ActionDefinition): {
        rolls: {
            name: string;
            roll: number;
        }[];
    };
    /**
     * Get all available actions for the characters, based on equipment, class, spells, etc.
     * @returns A list of available actions
     */
    getAvailableActions(): ActionDefinition[];
    getDamageAmplify(elementType: ElementDefinition): number;
    getResistance(element: ElementDefinition, damage: number): number;
    tryHit(target: Actor): boolean;
    reduce(event: RoleplayerEvent): void;
    dispose(): void;
}

type EffectParameters = unknown;
type CharacterResourceLossEffect = {
    eventType: "CharacterResourceLoss";
    roll: DiceRoll;
    resourceTypeId: ResourceDefinition["id"];
    elementTypeId: ElementDefinition["id"];
};
type CharacterStatusGainEffect = {
    eventType: "CharacterStatusGain";
    statusId: StatusDefinition["id"];
};
type UnkownEffect = {
    eventType: string;
    parameters: EffectParameters;
};
type EffectEventDefinition = CharacterResourceLossEffect | CharacterStatusGainEffect | UnkownEffect;
declare function mapEffect(effect: EffectEventDefinition, actionDef: ActionDefinition, attacker: Actor, target: Actor, ruleset: Ruleset): CampaignEvent;

declare enum TargetType {
    Self = "Self",
    Character = "Character",
    Friendly = "Friendly",
    Hostile = "Hostile",
    Environment = "Environment"
}
/**
 * @module core/actions
 *
 * Represents an action, with targets, and some effect that will be applied
 */
type ActionDefinition = {
    id: Id;
    name: string;
    description: string;
    appliesEffects: EffectEventDefinition[];
    eligibleTargets: TargetType[];
    rangeDistanceUnits: number;
    requiresResources: {
        resourceTypeId: ResourceDefinition["id"];
        amount: number;
    }[];
};

/**
 * Represent a campaign current state, after applying all events related to the campaign
 */
declare class CampaignState {
    id: Id;
    ruleset: Ruleset;
    roleplayer: Roleplayer;
    started: boolean;
    battles: Battle[];
    rounds: Round[];
    characters: Actor[];
    itemTemplates: ItemDefinition[];
    actorTemplates: ActorTemplate[];
    races: Race[];
    actions: ActionDefinition[];
    statuses: StatusDefinition[];
    classes: Clazz[];
    constructor(c: WithRequired<Partial<CampaignState>, "id" | "roleplayer" | "ruleset">);
    getRoundEvents(round: Round): RoleplayerEvent[];
    getCharacterRoundEvents(round: Round, characterId: Actor["id"]): RoleplayerEvent[];
    getCharacterEvents(characterId: Actor["id"]): RoleplayerEvent[];
    getCharacterEligibleTargets(actor: Actor, action: ActionDefinition): Actor[];
    getCurrentBattle(): Battle | undefined;
    characterHasResource(actor: Actor, resourceType: ResourceDefinition["id"]): boolean;
    getCurrentRound(): Round;
    allCharactersHaveActed(events: RoleplayerEvent[]): boolean;
    reduce(event: RoleplayerEvent): void;
}

declare const D2: Dice;
declare const D4: Dice;
declare const D6: Dice;
declare const D8: Dice;
declare const D10: Dice;
declare const D20: Dice;
type Dice = number;
type DiceRollStatic = `+${number}` | "";
type DiceSize = `D${number}`;
type NumberOfDice = `${number | ""}`;
/**
 * We recommend using RPG Dice Roller for dice rolling, since it has a rich API and is well maintained, see https://github.com/dice-roller/rpg-dice-roller
 */
type DiceRoll = `${NumberOfDice}${DiceSize}${DiceRollStatic}`;
type Roll = (dice: DiceRoll) => number;
declare const defaultRoll: Roll;

type CampaignMap = {
    id: Id;
    name: string;
};

declare class DnDRuleset implements Ruleset {
    roll: Roll;
    constructor(roll?: Roll);
    getActingOrder(actors: Actor[]): Actor[];
    getCurrentActorTurn(battle: Battle): Actor | undefined;
    getLevelProgression(): LevelProgression[];
    getCharacterStatTypes(): CharacterStatType[];
    getCharacterResourceTypes(): ResourceDefinition[];
    getCharacterEquipmentSlots(): EquipmentSlotDefinition[];
    getClassDefinitions(): Clazz[];
    getElementDefinitions(): ElementDefinition[];
    characterAttributeTotal(character: Actor, attribute: CharacterStatType): number | undefined;
    characterHitDamage(source: Actor, action: ActionDefinition, target: Actor, effect: CharacterResourceLossEffect): number;
    characterHit(attacker: Actor, actionDef: ActionDefinition, defender: Actor): boolean;
    characterElementDamageMultiplier(actor: Actor, damageType: ElementDefinition): number;
    characterResistanceMultiplier(actor: Actor, damageType: ElementDefinition): number;
    characterResistanceAbsolute(actor: Actor, damageType: ElementDefinition): number;
    characterResourceGeneration(actor: Actor): ResourceGeneration[];
    characterIsDead(actor: Actor): boolean;
    characterBattleActionOrder(actor: Actor): number;
}
declare function getAbilityModifier(abilityScore: number, fallback?: number): number;

declare class LeagueOfDungeoneersRuleset implements Ruleset {
    getActingOrder(actors: Actor[]): Actor[];
    getCurrentActorTurn(battle: Battle): Actor;
    characterHit(attacker: Actor, action: ActionDefinition, defender: Actor): boolean;
    characterIsDead(actor: Actor): boolean;
    roll(dice: number): number;
    getLevelProgression(): LevelProgression[];
    getCharacterStatTypes(): CharacterStatType[];
    getCharacterResourceTypes(): ResourceDefinition[];
    getCharacterEquipmentSlots(): EquipmentSlotDefinition[];
    getClassDefinitions(): Clazz[];
    getElementDefinitions(): ElementDefinition[];
    characterBattleActionOrder(actor: Actor): number;
    characterHitDamage(source: Actor, action: ActionDefinition, target: Actor, effect: EffectEventDefinition): number;
    characterResistanceMultiplier(actor: Actor, damageType: ElementDefinition): number;
    characterResistanceAbsolute(actor: Actor, damageType: ElementDefinition): number;
    characterResourceGeneration(actor: Actor): ResourceGeneration[];
    characterElementDamageMultiplier(actor: Actor, damageType: ElementDefinition): number;
}

declare function getRuleSet(ruleset: string): DnDRuleset | LeagueOfDungeoneersRuleset;

declare const Version = "0.0.0";

export { type ActionDefinition, type ActionDispatch, Actor, type ActorTemplate, Alignment, Battle, type BattleCampaignEvent, type CampaignEvent, type CampaignMap, CampaignState, type CharacterAttribute, type CharacterClass, type CharacterEquipmentSlot, type CharacterEvent, CharacterEventTypes, type CharacterInventoryItem, type CharacterResourceLossEffect, type CharacterStatType, type CharacterStatusGainEffect, type ClassLevelProgression, type Clazz, D10, D2, D20, D4, D6, D8, type Dice, type DiceRoll, DnDRuleset, type EffectEventDefinition, type ElementDefinition, type EquipmentSlotDefinition, HealthResourceTypeName, type Id, type ItemDefinition, ItemEquipmentType, ItemSlot, ItemType, LeagueOfDungeoneersRuleset, type LevelProgression, MovementSpeedResourceTypeName, type Party, type Position, PrimaryActionResourceTypeName, type Race, Rarity, type Reaction, ReactionEventType, type ReactionResource, type Resource, type ResourceDefinition, type ResourceGeneration, Roleplayer, type RoleplayerEvent, type RoleplayerEventTypes, type Roll, type Round, type Ruleset, SecondaryActionResourceTypeName, type StatusDefinition, StatusDurationType, StatusType, type SystemEvent, SystemEventType, TargetType, type UnkownEffect, Version, addActionToCharacter, addCharacterEquipmentSlot, addCharacterItem, addCharacterToCurrentBattle, characterBattleEnter, characterBattleLeave, characterDespawn, characterEquipItem, characterGainExperience, characterResourceGain, characterUnEquipItem, createCharacterWithDefaults, defaultRoll, endBattle, endCharacterTurn, endRound, generateId, getAbilityModifier, getRuleSet, isBattleEvent, isCharacterEvent, mapEffect, nextRound, performCharacterAttack, removeCharacterItem, setCharacterClasses, setCharacterName, setCharacterStats, spawnCharacterFromTemplate, startBattle, startCampaign };