isaac-typescript-definitions
Version:
TypeScript definitions for The Binding of Isaac: Repentance.
943 lines (942 loc) • 34.5 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ModCallback = void 0;
var ModCallback;
(function (ModCallback) {
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postNPCUpdate(npc: EntityNPC): void {}
* ```
*/
ModCallback[ModCallback["POST_NPC_UPDATE"] = 0] = "POST_NPC_UPDATE";
/**
* You cannot filter this callback.
*
* ```ts
* function postUpdate(): void {}
* ```
*/
ModCallback[ModCallback["POST_UPDATE"] = 1] = "POST_UPDATE";
/**
* You cannot filter this callback.
*
* ```ts
* function postRender(): void {}
* ```
*/
ModCallback[ModCallback["POST_RENDER"] = 2] = "POST_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `CollectibleType` provided.
*
* ```ts
* function useItem(
* collectibleType: CollectibleType,
* rng: RNG,
* player: EntityPlayer,
* useFlags: BitFlags<UseFlag>,
* activeSlot: int,
* customVarData: int,
* ):
* | boolean
* | { Discharge: boolean; Remove: boolean; ShowAnim: boolean }
* | undefined;
* ```
*/
ModCallback[ModCallback["POST_USE_ITEM"] = 3] = "POST_USE_ITEM";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PlayerType` provided.
*
* ```ts
* function postPEffectUpdate(player: EntityPlayer): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_PEFFECT_UPDATE"] = 4] = "POST_PEFFECT_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `CardType` provided.
*
* ```ts
* function postUseCard(
* cardType: CardType,
* player: EntityPlayer,
* useFlags: BitFlags<UseFlag>,
* ): void {}
* ```
*/
ModCallback[ModCallback["POST_USE_CARD"] = 5] = "POST_USE_CARD";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `FamiliarVariant` provided.
*
* ```ts
* function postFamiliarUpdate(familiar: EntityFamiliar): void {}
* ```
*/
ModCallback[ModCallback["POST_FAMILIAR_UPDATE"] = 6] = "POST_FAMILIAR_UPDATE";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `FamiliarVariant` provided.
*
* ```ts
* function postFamiliarInit(familiar: EntityFamiliar): void {}
* ```
*/
ModCallback[ModCallback["POST_FAMILIAR_INIT"] = 7] = "POST_FAMILIAR_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `CacheFlag` provided.
*
* Note that you can only use single `CacheFlag` values as a third argument. (You cannot use a
* combination of two or more `CacheFlag`.)
*
* ```ts
* function evaluateCache(player: EntityPlayer, cacheFlag: CacheFlag): void {}
* ```
*/
ModCallback[ModCallback["EVALUATE_CACHE"] = 8] = "EVALUATE_CACHE";
/**
* This will fire at the beginning of a run, upon continuing a saved run, and when a player enters
* a Genesis room.
*
* For most cases of general purpose player initialization, you should use the
* `POST_PLAYER_INIT_FIRST` custom callback instead (in order to exclude the case of a player
* continuing a saved run).
*
* This callback has a special property where most `EntityPlayer` methods (such as e.g.
* `EntityPlayer.AddCollectible`) will silently fail if the player is continuing a saved run.
* (This behavior was introduced in Repentance.) See the docs for more details about which
* specific methods are affected.
*
* The `isChildPlayer` helper function does not work in this callback (because
* `EntityPlayer.Parent` is not initialized yet at this point). If you want to exclude non-real
* players, use the `POST_PLAYER_INIT_FIRST` or the `POST_PLAYER_INIT_LATE` custom callbacks
* instead.
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PlayerVariant` provided.
*
* ```ts
* function postPlayerInit(player: EntityPlayer): void {}
* ```
*/
ModCallback[ModCallback["POST_PLAYER_INIT"] = 9] = "POST_PLAYER_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PillEffect` provided.
*
* ```ts
* function postUsePill(
* pillEffect: PillEffect,
* player: EntityPlayer,
* useFlags: BitFlags<UseFlag>,
* ): void {}
* ```
*/
ModCallback[ModCallback["POST_USE_PILL"] = 10] = "POST_USE_PILL";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function entityTakeDmg(
* entity: Entity,
* amount: float,
* damageFlags: BitFlags<DamageFlag>,
* source: EntityRef,
* countdownFrames: int,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["ENTITY_TAKE_DMG"] = 11] = "ENTITY_TAKE_DMG";
/**
* You cannot filter this callback.
*
* ```ts
* function postCurseEval(curses: BitFlags<LevelCurse>): BitFlags<LevelCurse> | undefined {}
* ```
*/
ModCallback[ModCallback["POST_CURSE_EVAL"] = 12] = "POST_CURSE_EVAL";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `InputHook` provided.
*
* ```ts
* function inputAction(
* entity: Entity | undefined,
* inputHook: InputHook,
* buttonAction: ButtonAction,
* ): boolean | float | undefined {}
* ```
*/
ModCallback[ModCallback["INPUT_ACTION"] = 13] = "INPUT_ACTION";
/**
* You cannot filter this callback.
*
* ```ts
* function postGameStarted(isContinued: boolean): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_GAME_STARTED_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_GAME_STARTED"] = 15] = "POST_GAME_STARTED";
/**
* You cannot filter this callback.
*
* ```ts
* function postGameEnd(isGameOver: boolean): void {}
* ```
*/
ModCallback[ModCallback["POST_GAME_END"] = 16] = "POST_GAME_END";
/**
* You cannot filter this callback.
*
* ```ts
* function preGameExit(shouldSave: boolean): void {}
* ```
*/
ModCallback[ModCallback["PRE_GAME_EXIT"] = 17] = "PRE_GAME_EXIT";
/**
* Unlike the `POST_GAME_STARTED` callback, this callback does not fire when resuming a saved run.
*
* You cannot filter this callback.
*
* ```ts
* function postNewLevel(): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_NEW_LEVEL_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_NEW_LEVEL"] = 18] = "POST_NEW_LEVEL";
/**
* You cannot filter this callback.
*
* ```ts
* function postNewRoom(): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_NEW_ROOM_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_NEW_ROOM"] = 19] = "POST_NEW_ROOM";
/**
* You cannot filter this callback.
*
* ```ts
* function getCard(
* rng: RNG,
* cardType: CardType,
* includePlayingCards: boolean,
* includeRunes: boolean,
* onlyRunes: boolean,
* ): CardType | undefined {}
* ```
*/
ModCallback[ModCallback["GET_CARD"] = 20] = "GET_CARD";
/**
* You cannot filter this callback.
*
* ```ts
* function getShaderParams(shaderName: string): Record<string, unknown> {}
* ```
*/
ModCallback[ModCallback["GET_SHADER_PARAMS"] = 21] = "GET_SHADER_PARAMS";
/**
* You cannot filter this callback.
*
* ```ts
* function executeCmd(
* command: string,
* parameters: string,
* player: EntityPlayer,
* ): void {}
* ```
*/
ModCallback[ModCallback["EXECUTE_CMD"] = 22] = "EXECUTE_CMD";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `CollectibleType` provided.
*
* ```ts
* function preUseItem(
* collectibleType: CollectibleType,
* rng: RNG,
* player: EntityPlayer,
* useFlags: BitFlags<UseFlag>,
* activeSlot: ActiveSlot,
* customVarData: int,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_USE_ITEM"] = 23] = "PRE_USE_ITEM";
/**
* If you want to prevent an entity from spawning, you cannot return an `EntityType` of 0, since
* that will cause the game to crash.
*
* Sometimes, if you return a type other than the original type (e.g. replacing a pickup with an
* effect), the game will crash. Thus, you should replace a pickup with a new pickup, and so on.
*
* You cannot filter this callback.
*
* ```ts
* function preEntitySpawn(
* entityType: EntityType,
* variant: int,
* subType: int,
* position: Vector,
* velocity: Vector,
* spawner: Entity | undefined,
* initSeed: Seed,
* ): [entityType: EntityType, variant: int, subType: int, initSeed: Seed] | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_ENTITY_SPAWN"] = 24] = "PRE_ENTITY_SPAWN";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `FamiliarVariant` provided.
*
* ```ts
* function postFamiliarRender(
* entityFamiliar: EntityFamiliar,
* renderOffset: Vector,
* ): void {}
* ```
*/
ModCallback[ModCallback["POST_FAMILIAR_RENDER"] = 25] = "POST_FAMILIAR_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `FamiliarVariant` provided.
*
* ```ts
* function preFamiliarCollision(
* familiar: EntityFamiliar,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_FAMILIAR_COLLISION"] = 26] = "PRE_FAMILIAR_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postNPCInit(npc: EntityNPC): void {}
* ```
*/
ModCallback[ModCallback["POST_NPC_INIT"] = 27] = "POST_NPC_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postNPCRender(npc: EntityNPC, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_NPC_RENDER"] = 28] = "POST_NPC_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postNPCDeath(npc: EntityNPC): void {}
* ```
*/
ModCallback[ModCallback["POST_NPC_DEATH"] = 29] = "POST_NPC_DEATH";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function preNPCCollision(
* npc: EntityNPC,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_NPC_COLLISION"] = 30] = "PRE_NPC_COLLISION";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PlayerVariant` provided.
*
* ```ts
* function postPlayerUpdate(player: EntityPlayer): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_PLAYER_UPDATE_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_PLAYER_UPDATE"] = 31] = "POST_PLAYER_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PlayerVariant` provided.
*
* ```ts
* function postPlayerRender(player: EntityPlayer, renderOffset: Vector): void {}
* ```
*
* @deprecated Consider using the `ModCallbackCustom.POST_PLAYER_RENDER_REORDERED` callback from
* `isaacscript-common` instead, since it will fire in the correct order and prevent
* bugs relating to data structures not being properly initialized.
*/
ModCallback[ModCallback["POST_PLAYER_RENDER"] = 32] = "POST_PLAYER_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PlayerVariant` provided.
*
* ```ts
* function prePlayerCollision(
* player: EntityPlayer,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_PLAYER_COLLISION"] = 33] = "PRE_PLAYER_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PickupVariant` provided.
*
* ```ts
* function postPickupInit(pickup: EntityPickup): void {}
* ```
*/
ModCallback[ModCallback["POST_PICKUP_INIT"] = 34] = "POST_PICKUP_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PickupVariant` provided.
*
* ```ts
* function postPickupUpdate(pickup: EntityPickup): void {}
* ```
*/
ModCallback[ModCallback["POST_PICKUP_UPDATE"] = 35] = "POST_PICKUP_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PickupVariant` provided.
*
* ```ts
* function postPickupRender(pickup: EntityPickup, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_PICKUP_RENDER"] = 36] = "POST_PICKUP_RENDER";
/**
* You cannot filter this callback.
*
* ```ts
* function postPickupSelection(
* pickup: EntityPickup,
* variant: PickupVariant,
* subType: int,
* ): [pickupVariant: PickupVariant, subType: int] | undefined {}
* ```
*/
ModCallback[ModCallback["POST_PICKUP_SELECTION"] = 37] = "POST_PICKUP_SELECTION";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `PickupVariant` provided.
*
* ```ts
* function prePickupCollision(
* pickup: EntityPickup,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_PICKUP_COLLISION"] = 38] = "PRE_PICKUP_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `TearVariant` provided.
*
* ```ts
* function postTearInit(tear: EntityTear): void {}
* ```
*/
ModCallback[ModCallback["POST_TEAR_INIT"] = 39] = "POST_TEAR_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `TearVariant` provided.
*
* ```ts
* function postTearUpdate(tear: EntityTear): void {}
* ```
*/
ModCallback[ModCallback["POST_TEAR_UPDATE"] = 40] = "POST_TEAR_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `TearVariant` provided.
*
* ```ts
* function postTearRender(tear: EntityTear, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_TEAR_RENDER"] = 41] = "POST_TEAR_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `TearVariant` provided.
*
* ```ts
* function preTearCollision(
* tear: EntityTear,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_TEAR_COLLISION"] = 42] = "PRE_TEAR_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `ProjectileVariant` provided.
*
* ```ts
* function postProjectileInit(projectile: EntityProjectile): void {}
* ```
*/
ModCallback[ModCallback["POST_PROJECTILE_INIT"] = 43] = "POST_PROJECTILE_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `ProjectileVariant` provided.
*
* ```ts
* function postProjectileUpdate(projectile: EntityProjectile): void {}
* ```
*/
ModCallback[ModCallback["POST_PROJECTILE_UPDATE"] = 44] = "POST_PROJECTILE_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `ProjectileVariant` provided.
*
* ```ts
* function postProjectileRender(
* projectile: EntityProjectile,
* renderOffset: Vector,
* ): void {}
* ```
*/
ModCallback[ModCallback["POST_PROJECTILE_RENDER"] = 45] = "POST_PROJECTILE_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `ProjectileVariant` provided.
*
* ```ts
* function preProjectileCollision(
* projectile: EntityProjectile,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_PROJECTILE_COLLISION"] = 46] = "PRE_PROJECTILE_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `LaserVariant` provided.
*
* ```ts
* function postLaserInit(laser: EntityLaser): void {}
* ```
*/
ModCallback[ModCallback["POST_LASER_INIT"] = 47] = "POST_LASER_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `LaserVariant` provided.
*
* ```ts
* function postLaserUpdate(laser: EntityLaser): void {}
* ```
*/
ModCallback[ModCallback["POST_LASER_UPDATE"] = 48] = "POST_LASER_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `LaserVariant` provided.
*
* ```ts
* function postLaserRender(laser: EntityLaser, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_LASER_RENDER"] = 49] = "POST_LASER_RENDER";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
* expect!)
*
* ```ts
* function postKnifeInit(knife: EntityKnife): void {}
* ```
*/
ModCallback[ModCallback["POST_KNIFE_INIT"] = 50] = "POST_KNIFE_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
* expect!)
*
* ```ts
* function postKnifeUpdate(knife: EntityKnife): void {}
* ```
*/
ModCallback[ModCallback["POST_KNIFE_UPDATE"] = 51] = "POST_KNIFE_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
* expect!)
*
* ```ts
* function postKnifeRender(knife: EntityKnife, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_KNIFE_RENDER"] = 52] = "POST_KNIFE_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the sub-type provided. (This is bugged and is NOT the `KnifeVariant` like you would
* expect!)
*
* ```ts
* function preKnifeCollision(
* knife: EntityKnife,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_KNIFE_COLLISION"] = 53] = "PRE_KNIFE_COLLISION";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EffectVariant` provided.
*
* ```ts
* function postEffectInit(effect: EntityEffect): void {}
* ```
*/
ModCallback[ModCallback["POST_EFFECT_INIT"] = 54] = "POST_EFFECT_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EffectVariant` provided.
*
* ```ts
* function postEffectUpdate(effect: EntityEffect): void {}
* ```
*/
ModCallback[ModCallback["POST_EFFECT_UPDATE"] = 55] = "POST_EFFECT_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EffectVariant` provided.
*
* ```ts
* function postEffectRender(effect: EntityEffect, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_EFFECT_RENDER"] = 56] = "POST_EFFECT_RENDER";
/**
* Unlike in Afterbirth+, in Repentance this callback properly populates the following fields:
*
* - `Position`
* - `SpawnerEntity`
* - `SpawnerType`
* - `SpawnerVariant`
* - `Velocity`
*
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `BombVariant` provided.
*
* ```ts
* function postBombInit(bomb: EntityBomb): void {}
* ```
*/
ModCallback[ModCallback["POST_BOMB_INIT"] = 57] = "POST_BOMB_INIT";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `BombVariant` provided.
*
* ```ts
* function postBombUpdate(bomb: EntityBomb): void {}
* ```
*/
ModCallback[ModCallback["POST_BOMB_UPDATE"] = 58] = "POST_BOMB_UPDATE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `BombVariant` provided.
*
* ```ts
* function postBombRender(bomb: EntityBomb, renderOffset: Vector): void {}
* ```
*/
ModCallback[ModCallback["POST_BOMB_RENDER"] = 59] = "POST_BOMB_RENDER";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `BombVariant` provided.
*
* ```ts
* function preBombCollision(
* bomb: EntityBomb,
* collider: Entity,
* low: boolean,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_BOMB_COLLISION"] = 60] = "PRE_BOMB_COLLISION";
/**
* You cannot filter this callback.
*
* ```ts
* function postFireTear(tear: EntityTear): void {}
* ```
*/
ModCallback[ModCallback["POST_FIRE_TEAR"] = 61] = "POST_FIRE_TEAR";
/**
* You cannot filter this callback.
*
* ```ts
* function preGetCollectible(
* itemPoolType: ItemPoolType,
* decrease: boolean,
* seed: Seed,
* ): CollectibleType | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_GET_COLLECTIBLE"] = 62] = "PRE_GET_COLLECTIBLE";
/**
* You cannot filter this callback.
*
* ```ts
* function postGetCollectible(
* collectibleType: CollectibleType,
* itemPoolType: ItemPoolType,
* decrease: boolean,
* seed: Seed,
* ): CollectibleType | undefined {}
* ```
*/
ModCallback[ModCallback["POST_GET_COLLECTIBLE"] = 63] = "POST_GET_COLLECTIBLE";
/**
* You cannot filter this callback.
*
* ```ts
* function getPillColor(seed: Seed): PillColor | undefined {}
* ```
*/
ModCallback[ModCallback["GET_PILL_COLOR"] = 64] = "GET_PILL_COLOR";
/**
* You cannot filter this callback.
*
* ```ts
* function getPillEffect(
* pillEffect: PillEffect,
* pillColor: PillColor,
* ): PillEffect | undefined {}
* ```
*/
ModCallback[ModCallback["GET_PILL_EFFECT"] = 65] = "GET_PILL_EFFECT";
/**
* You cannot filter this callback.
*
* ```ts
* function getTrinket(
* trinketType: TrinketType,
* rng: RNG,
* ): TrinketType | undefined {}
* ```
*/
ModCallback[ModCallback["GET_TRINKET"] = 66] = "GET_TRINKET";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postEntityRemove(entity: Entity): void {}
* ```
*/
ModCallback[ModCallback["POST_ENTITY_REMOVE"] = 67] = "POST_ENTITY_REMOVE";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function postEntityKill(entity: Entity): void {}
* ```
*/
ModCallback[ModCallback["POST_ENTITY_KILL"] = 68] = "POST_ENTITY_KILL";
/**
* When registering this callback with the `Mod.AddCallback` method:
* - You can provide an optional third argument that will make the callback only fire if it
* matches the `EntityType` provided.
*
* ```ts
* function preNPCUpdate(entity: Entity): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_NPC_UPDATE"] = 69] = "PRE_NPC_UPDATE";
/**
* In vanilla, this is `PRE_SPAWN_CLEAN_AWARD`, which is a typo.
*
* You cannot filter this callback.
*
* ```ts
* function preSpawnClearAward(
* rng: RNG,
* spawnPosition: Vector,
* ): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_SPAWN_CLEAR_AWARD"] = 70] = "PRE_SPAWN_CLEAR_AWARD";
/**
* You can use the `isGridEntityXMLType` helper function to convert the
* `entityTypeOrGridEntityXMLType` argument to an `EntityType` or `GridEntityXMLType`, if needed.
*
* You cannot filter this callback.
*
* ```ts
* function preRoomEntitySpawn(
* entityTypeOrGridEntityXMLType: EntityType | GridEntityXMLType,
* variant: int,
* subType: int,
* gridIndex: int,
* initSeed: Seed,
* ): [type: EntityType | GridEntityXMLType, variant: int, subType: int] | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_ROOM_ENTITY_SPAWN"] = 71] = "PRE_ROOM_ENTITY_SPAWN";
/**
* You cannot filter this callback.
*
* ```ts
* function preEntityDevolve(entity: Entity): boolean | undefined {}
* ```
*/
ModCallback[ModCallback["PRE_ENTITY_DEVOLVE"] = 72] = "PRE_ENTITY_DEVOLVE";
/**
* You cannot filter this callback.
*
* ```ts
* function preModUnload(mod: Mod): void {}
* ```
*/
ModCallback[ModCallback["PRE_MOD_UNLOAD"] = 73] = "PRE_MOD_UNLOAD";
})(ModCallback || (exports.ModCallback = ModCallback = {}));