isaacscript-common 2.3.0 → 2.3.1

package/src/callbacks/postItemDischarged.ts

@@ -1,149 +0,0 @@
-import {
-  ActiveSlot,
-  CollectibleType,
-  EntityType,
-  ModCallback,
-  SuckerVariant,
-} from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getTotalCharge } from "../functions/charge";
-import { getEnumValues } from "../functions/enums";
-import {
-  defaultMapGetPlayer,
-  mapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postItemDischargeFire,
-  postItemDischargeHasSubscriptions,
-} from "./subscriptions/postItemDischarged";
-
-type ActiveSlotToCollectibleTypeMap = DefaultMap<
-  ActiveSlot,
-  CollectibleType,
-  [int]
->;
-type ActiveSlotToChargeMap = DefaultMap<ActiveSlot, int, [int]>;
-
-const v = {
-  run: {
-    playersActiveItemMap: new DefaultMap<
-      PlayerIndex,
-      ActiveSlotToCollectibleTypeMap
-    >(() => new DefaultMap((collectibleType) => collectibleType)),
-    playersActiveChargeMap: new DefaultMap<PlayerIndex, ActiveSlotToChargeMap>(
-      () => new DefaultMap((charge) => charge),
-    ),
-  },
-
-  room: {
-    playersBulbLastCollisionFrame: new Map<PlayerIndex, int>(),
-  },
-};
-
-export function postItemDischargeCallbackInit(mod: ModUpgraded): void {
-  saveDataManager("postItemDischarge", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PEFFECT_UPDATE, postPEffectUpdate); // 4
-  mod.AddCallback(
-    ModCallback.PRE_NPC_COLLISION,
-    preNPCCollisionSucker,
-    EntityType.SUCKER,
-  ); // 30
-}
-
-function hasSubscriptions(): boolean {
-  return postItemDischargeHasSubscriptions();
-}
-
-// ModCallback.POST_PEFFECT_UPDATE (4)
-function postPEffectUpdate(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const activeItemMap = defaultMapGetPlayer(v.run.playersActiveItemMap, player);
-  const chargeMap = defaultMapGetPlayer(v.run.playersActiveChargeMap, player);
-
-  for (const activeSlot of getEnumValues(ActiveSlot)) {
-    const currentActiveItem = player.GetActiveItem();
-    const previousActiveItem = activeItemMap.getAndSetDefault(
-      activeSlot,
-      currentActiveItem,
-    );
-    activeItemMap.set(activeSlot, currentActiveItem);
-
-    if (currentActiveItem !== previousActiveItem) {
-      // The player swapped out their active item for something else, so it should be impossible for
-      // the discharge callback to fire on this frame.
-      continue;
-    }
-
-    const currentCharge = getTotalCharge(player, activeSlot);
-    const previousCharge = chargeMap.getAndSetDefault(
-      activeSlot,
-      currentCharge,
-    );
-    chargeMap.set(activeSlot, currentCharge);
-
-    if (playerRecentlyCollidedWithBulb(player)) {
-      continue;
-    }
-
-    if (currentCharge < previousCharge) {
-      const collectibleType = player.GetActiveItem(activeSlot);
-      postItemDischargeFire(player, collectibleType, activeSlot);
-    }
-  }
-}
-
-/**
- * If the player collided with a Bulb on either this frame or the last frame, then assume a zap has
- * occurred. (We do not want to fire the discharge callback if this is the case.)
- */
-function playerRecentlyCollidedWithBulb(player: EntityPlayer) {
-  const gameFrameCount = game.GetFrameCount();
-  const bulbLastCollisionFrame = mapGetPlayer(
-    v.room.playersBulbLastCollisionFrame,
-    player,
-  );
-  const collidedOnThisFrame = gameFrameCount === bulbLastCollisionFrame;
-  const collidedOnLastFrame = gameFrameCount - 1 === bulbLastCollisionFrame;
-  return collidedOnThisFrame || collidedOnLastFrame;
-}
-
-/**
- * ModCallback.PRE_NPC_COLLISION (30)
- * EntityType.SUCKER (61)
- *
- * The algorithm for detecting a discharge is checking if the current charge is less than the charge
- * on the previous frame. Thus, when a Bulb zaps a player and drains their charge, this will be a
- * false position, so Bulbs have to be handled.
- *
- * When Bulbs zap a player, they go to `NpcState.STATE_JUMP` for a frame. However, this only happens
- * on the frame after the player is discharged, which is too late to be of any use.
- *
- * Instead, we track the frames that Bulbs collide with players and assume that a collision means a
- * zap has occurred.
- */
-function preNPCCollisionSucker(npc: EntityNPC, collider: Entity) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  if (npc.Variant !== (SuckerVariant.BULB as int)) {
-    return;
-  }
-
-  const player = collider.ToPlayer();
-  if (player === undefined) {
-    return;
-  }
-
-  const gameFrameCount = game.GetFrameCount();
-  mapSetPlayer(v.room.playersBulbLastCollisionFrame, player, gameFrameCount);
-}

package/src/callbacks/postKnifeInitLate.ts

@@ -1,36 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postKnifeInitLateFire,
-  postKnifeInitLateHasSubscriptions,
-} from "./subscriptions/postKnifeInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postKnifeInitLateCallbackInit(mod: Mod): void {
-  saveDataManager("postKnifeInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_KNIFE_UPDATE, postKnifeUpdate); // 51
-}
-
-function hasSubscriptions() {
-  return postKnifeInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_KNIFE_UPDATE (51)
-function postKnifeUpdate(knife: EntityKnife) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(knife);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postKnifeInitLateFire(knife);
-  }
-}

package/src/callbacks/postLaserInitLate.ts

@@ -1,36 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postLaserInitLateFire,
-  postLaserInitLateHasSubscriptions,
-} from "./subscriptions/postLaserInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postLaserInitLateCallbackInit(mod: Mod): void {
-  saveDataManager("postLaserInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_LASER_UPDATE, postLaserUpdate); // 35
-}
-
-function hasSubscriptions() {
-  return postLaserInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_LASER_UPDATE (48)
-function postLaserUpdate(laser: EntityLaser) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(laser);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postLaserInitLateFire(laser);
-  }
-}

package/src/callbacks/postNPCInitLate.ts

@@ -1,36 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postNPCInitLateFire,
-  postNPCInitLateHasSubscriptions,
-} from "./subscriptions/postNPCInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postNPCInitLateCallbackInit(mod: Mod): void {
-  saveDataManager("postNPCInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_NPC_UPDATE, postNPCUpdate); // 0
-}
-
-function hasSubscriptions() {
-  return postNPCInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_NPC_UPDATE (0)
-function postNPCUpdate(npc: EntityNPC) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(npc);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postNPCInitLateFire(npc);
-  }
-}

package/src/callbacks/postNPCStateChanged.ts

@@ -1,42 +0,0 @@
-import { ModCallback, NpcState } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postNPCStateChangedFire,
-  postNPCStateChangedHasSubscriptions,
-} from "./subscriptions/postNPCStateChanged";
-
-const v = {
-  run: {
-    npcStateMap: new DefaultMap<PtrHash, NpcState, [NpcState]>(
-      (state) => state, // eslint-disable-line isaacscript/strict-enums
-    ),
-  },
-};
-
-/** @internal */
-export function postNPCStateChangedCallbackInit(mod: Mod): void {
-  saveDataManager("postNPCStateChanged", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_NPC_UPDATE, postNPCUpdate); // 0
-}
-
-function hasSubscriptions() {
-  return postNPCStateChangedHasSubscriptions();
-}
-
-// ModCallback.POST_NPC_UPDATE (0)
-function postNPCUpdate(npc: EntityNPC) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const ptrHash = GetPtrHash(npc);
-  const previousState = v.run.npcStateMap.getAndSetDefault(ptrHash, npc.State);
-  const currentState = npc.State;
-  v.run.npcStateMap.set(ptrHash, currentState);
-
-  if (previousState !== currentState) {
-    postNPCStateChangedFire(npc, previousState, currentState);
-  }
-}

package/src/callbacks/postNewRoomEarly.ts

@@ -1,90 +0,0 @@
-import { GridEntityType, ModCallback } from "isaac-typescript-definitions";
-import { game } from "../cachedClasses";
-import { getTopLeftWallGridIndex, spawnGrid } from "../functions/gridEntity";
-import { logError } from "../functions/log";
-import {
-  postNewRoomEarlyFire,
-  postNewRoomEarlyHasSubscriptions,
-} from "./subscriptions/postNewRoomEarly";
-
-let currentRoomTopLeftWallPtrHash: PtrHash | null = null;
-
-/**
- * The wall entity directly to the right of the top-left wall. We use this as a test to see if it
- * improves the consistency of the callback firing.
- */
-let currentRoomTopLeftWallPtrHash2: PtrHash | null = null;
-
-/** @internal */
-export function postNewRoomEarlyCallbackInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_NEW_ROOM, postNewRoom); // 19
-  mod.AddCallback(ModCallback.PRE_ENTITY_SPAWN, preEntitySpawn); // 24
-}
-
-function hasSubscriptions() {
-  return postNewRoomEarlyHasSubscriptions();
-}
-
-// ModCallback.POST_NEW_ROOM (19)
-function postNewRoom() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  checkRoomChanged();
-}
-
-// ModCallback.PRE_ENTITY_SPAWN (24)
-function preEntitySpawn() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  checkRoomChanged();
-}
-
-function checkRoomChanged() {
-  const room = game.GetRoom();
-  const topLeftWallGridIndex = getTopLeftWallGridIndex();
-  const rightOfTopWallGridIndex = topLeftWallGridIndex + 1;
-
-  let topLeftWall = room.GetGridEntity(topLeftWallGridIndex);
-  let topLeftWall2 = room.GetGridEntity(rightOfTopWallGridIndex);
-
-  // Sometimes, the PreEntitySpawn callback can fire before any grid entities in the room have
-  // spawned, which means that the top-left wall will not exist. If ths is the case, then simply
-  // spawn the top-left wall early.
-  if (topLeftWall === undefined) {
-    topLeftWall = spawnGrid(GridEntityType.WALL, topLeftWallGridIndex);
-    if (topLeftWall === undefined) {
-      logError(
-        "Failed to spawn a new wall (1) for the PostNewRoomEarly callback.",
-      );
-      return;
-    }
-  }
-
-  // For some reason, the above check will rarely fail. We duplicate the check with another wall
-  // segment to go from 99% to 100% reliability.
-  if (topLeftWall2 === undefined) {
-    topLeftWall2 = spawnGrid(GridEntityType.WALL, rightOfTopWallGridIndex);
-    if (topLeftWall2 === undefined) {
-      logError(
-        "Failed to spawn a new wall (2) for the PostNewRoomEarly callback.",
-      );
-      return;
-    }
-  }
-
-  const topLeftWallPtrHash = GetPtrHash(topLeftWall);
-  const topLeftWallPtrHash2 = GetPtrHash(topLeftWall2);
-  if (
-    topLeftWallPtrHash !== currentRoomTopLeftWallPtrHash ||
-    topLeftWallPtrHash2 !== currentRoomTopLeftWallPtrHash2
-  ) {
-    currentRoomTopLeftWallPtrHash = topLeftWallPtrHash;
-    currentRoomTopLeftWallPtrHash2 = topLeftWallPtrHash2;
-
-    postNewRoomEarlyFire();
-  }
-}

package/src/callbacks/postPickupCollect.ts

@@ -1,48 +0,0 @@
-// Some pickup properties cannot be retrieved properly in the PostPickupInit callback and must be
-// checked in the PostPickupUpdate callback. This fires on the first update frame.
-
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getClosestPlayer } from "../functions/player";
-import {
-  postPickupCollectFire,
-  postPickupCollectHasSubscriptions,
-} from "./subscriptions/postPickupCollect";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postPickupCollectCallbackInit(mod: Mod): void {
-  saveDataManager("postPickupCollect", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PICKUP_RENDER, postPickupRender); // 36
-}
-
-function hasSubscriptions() {
-  return postPickupCollectHasSubscriptions();
-}
-
-// ModCallback.POST_PICKUP_RENDER (36)
-function postPickupRender(pickup: EntityPickup) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const sprite = pickup.GetSprite();
-  const animation = sprite.GetAnimation();
-  if (animation !== "Collect") {
-    return;
-  }
-
-  const index = GetPtrHash(pickup);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-
-    const player = getClosestPlayer(pickup.Position);
-    postPickupCollectFire(pickup, player);
-  }
-}

package/src/callbacks/postPickupInitLate.ts

@@ -1,36 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postPickupInitLateFire,
-  postPickupInitLateHasSubscriptions,
-} from "./subscriptions/postPickupInitLate";
-
-const v = {
-  room: {
-    firedSet: new Set<PtrHash>(),
-  },
-};
-
-/** @internal */
-export function postPickupInitLateCallbackInit(mod: Mod): void {
-  saveDataManager("postPickupInitLate", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
-}
-
-function hasSubscriptions() {
-  return postPickupInitLateHasSubscriptions();
-}
-
-// ModCallback.POST_PICKUP_UPDATE (35)
-function postPickupUpdate(pickup: EntityPickup) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const index = GetPtrHash(pickup);
-  if (!v.room.firedSet.has(index)) {
-    v.room.firedSet.add(index);
-    postPickupInitLateFire(pickup);
-  }
-}

package/src/callbacks/postPickupStateChanged.ts

@@ -1,43 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  postPickupStateChangedFire,
-  postPickupStateChangedHasSubscriptions,
-} from "./subscriptions/postPickupStateChanged";
-
-const v = {
-  run: {
-    pickupStateMap: new DefaultMap<PtrHash, int, [int]>((state) => state),
-  },
-};
-
-/** @internal */
-export function postPickupStateChangedCallbackInit(mod: Mod): void {
-  saveDataManager("postPickupStateChanged", v, hasSubscriptions);
-
-  mod.AddCallback(ModCallback.POST_PICKUP_UPDATE, postPickupUpdate); // 35
-}
-
-function hasSubscriptions() {
-  return postPickupStateChangedHasSubscriptions();
-}
-
-// ModCallback.POST_PICKUP_UPDATE (35)
-function postPickupUpdate(pickup: EntityPickup) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const ptrHash = GetPtrHash(pickup);
-  const previousState = v.run.pickupStateMap.getAndSetDefault(
-    ptrHash,
-    pickup.State,
-  );
-  const currentState = pickup.State;
-  v.run.pickupStateMap.set(ptrHash, currentState);
-
-  if (previousState !== currentState) {
-    postPickupStateChangedFire(pickup, previousState, currentState);
-  }
-}

package/src/callbacks/postPitRender.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPits } from "../functions/gridEntitySpecific";
-import {
-  postPitRenderFire,
-  postPitRenderHasSubscriptions,
-} from "./subscriptions/postPitRender";
-
-/** @internal */
-export function postPitRenderInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_RENDER, postRender); // 2
-}
-
-function hasSubscriptions() {
-  return postPitRenderHasSubscriptions();
-}
-
-// ModCallback.POST_RENDER (2)
-function postRender() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const pit of getPits()) {
-    postPitRenderFire(pit);
-  }
-}

package/src/callbacks/postPitUpdate.ts

@@ -1,26 +0,0 @@
-import { ModCallback } from "isaac-typescript-definitions";
-import { getPits } from "../functions/gridEntitySpecific";
-import {
-  postPitUpdateFire,
-  postPitUpdateHasSubscriptions,
-} from "./subscriptions/postPitUpdate";
-
-/** @internal */
-export function postPitUpdateInit(mod: Mod): void {
-  mod.AddCallback(ModCallback.POST_UPDATE, postUpdate); // 1
-}
-
-function hasSubscriptions() {
-  return postPitUpdateHasSubscriptions();
-}
-
-// ModCallback.POST_UPDATE (1)
-function postUpdate() {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  for (const pit of getPits()) {
-    postPitUpdateFire(pit);
-  }
-}

package/src/callbacks/postPlayerChangeHealth.ts

@@ -1,62 +0,0 @@
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { HealthType } from "../enums/HealthType";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import { getEnumValues } from "../functions/enums";
-import { getPlayerHealthType } from "../functions/playerHealth";
-import { getPlayerIndex } from "../functions/playerIndex";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerChangeHealthFire,
-  postPlayerChangeHealthHasSubscriptions,
-} from "./subscriptions/postPlayerChangeHealth";
-
-const v = {
-  run: {
-    playersHealthMap: new DefaultMap<PlayerIndex, Map<HealthType, int>>(
-      () => new Map(),
-    ),
-  },
-};
-
-/** @internal */
-export function postPlayerChangeHealthCallbackInit(mod: ModUpgraded): void {
-  saveDataManager("postPlayerChangeHealth", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postPlayerChangeHealthHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  // We call the "getPlayerIndex" function with the "differentiateForgottenAndSoul" argument. If we
-  // don't differentiate between The Forgotten and The Soul, the callback will fire every time the
-  // player switches between the two.
-  const playerIndex = getPlayerIndex(player, true);
-  const playerHealthMap = v.run.playersHealthMap.getAndSetDefault(playerIndex);
-
-  for (const healthType of getEnumValues(HealthType)) {
-    const storedHealthValue = playerHealthMap.get(healthType);
-    const currentHealthValue = getPlayerHealthType(player, healthType);
-    playerHealthMap.set(healthType, currentHealthValue);
-
-    if (
-      storedHealthValue !== undefined &&
-      storedHealthValue !== currentHealthValue
-    ) {
-      const amount = currentHealthValue - storedHealthValue;
-      postPlayerChangeHealthFire(player, healthType, amount);
-    }
-  }
-}

package/src/callbacks/postPlayerChangeType.ts

@@ -1,56 +0,0 @@
-import { PlayerType } from "isaac-typescript-definitions";
-import { DefaultMap } from "../classes/DefaultMap";
-import { ModUpgraded } from "../classes/ModUpgraded";
-import { ModCallbackCustom } from "../enums/ModCallbackCustom";
-import { saveDataManager } from "../features/saveDataManager/exports";
-import {
-  defaultMapGetPlayer,
-  mapSetPlayer,
-} from "../functions/playerDataStructures";
-import { PlayerIndex } from "../types/PlayerIndex";
-import {
-  postPlayerChangeTypeFire,
-  postPlayerChangeTypeHasSubscriptions,
-} from "./subscriptions/postPlayerChangeType";
-
-const v = {
-  run: {
-    playersCharacterMap: new DefaultMap<
-      PlayerIndex,
-      PlayerType,
-      [character: PlayerType]
-    >((character: PlayerType) => character), // eslint-disable-line isaacscript/strict-enums
-  },
-};
-
-/** @internal */
-export function postPlayerChangeTypeCallbackInit(mod: ModUpgraded): void {
-  saveDataManager("postPlayerChangeType", v, hasSubscriptions);
-
-  mod.AddCallbackCustom(
-    ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED,
-    postPEffectUpdateReordered,
-  );
-}
-
-function hasSubscriptions() {
-  return postPlayerChangeTypeHasSubscriptions();
-}
-
-// ModCallbackCustom.POST_PEFFECT_UPDATE_REORDERED
-function postPEffectUpdateReordered(player: EntityPlayer) {
-  if (!hasSubscriptions()) {
-    return;
-  }
-
-  const character = player.GetPlayerType();
-  const storedCharacter = defaultMapGetPlayer(
-    v.run.playersCharacterMap,
-    player,
-    character,
-  );
-  if (character !== storedCharacter) {
-    mapSetPlayer(v.run.playersCharacterMap, player, character);
-    postPlayerChangeTypeFire(player, storedCharacter, character);
-  }
-}