ah_sce_unpacked/unpacked/Bag All Player Cards 15bb07/Card Book of Living Myths c5fb1f.ttslua

-- Bundled by luabundle {"version":"1.6.0"}
local __bundle_require, __bundle_loaded, __bundle_register, __bundle_modules = (function(superRequire)
	local loadingPlaceholder = {[{}] = true}

	local register
	local modules = {}

	local require
	local loaded = {}

	register = function(name, body)
		if not modules[name] then
			modules[name] = body
		end
	end

	require = function(name)
		local loadedModule = loaded[name]

		if loadedModule then
			if loadedModule == loadingPlaceholder then
				return nil
			end
		else
			if not modules[name] then
				if not superRequire then
					local identifier = type(name) == 'string' and '\"' .. name .. '\"' or tostring(name)
					error('Tried to require ' .. identifier .. ', but no such module has been registered')
				else
					return superRequire(name)
				end
			end

			loaded[name] = loadingPlaceholder
			loadedModule = modules[name](require, loaded, register, modules)
			loaded[name] = loadedModule
		end

		return loadedModule
	end

	return require, loaded, register, modules
end)(nil)
__bundle_register("chaosbag/ChaosBagApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local ChaosBagApi = {}

  -- respawns the chaos bag with a new state of tokens
  ---@param tokenList table List of chaos token ids
  ChaosBagApi.setChaosBagState = function(tokenList)
    Global.call("setChaosBagState", tokenList)
  end

  -- returns a Table List of chaos token ids in the current chaos bag
  -- requires copying the data into a new table because TTS is weird about handling table return values in Global
  ChaosBagApi.getChaosBagState = function()
    local chaosBagContentsCatcher = Global.call("getChaosBagState")
    local chaosBagContents = {}
    for _, v in ipairs(chaosBagContentsCatcher) do
      table.insert(chaosBagContents, v)
    end
    return chaosBagContents
  end

  -- checks scripting zone for chaos bag (also called by a lot of objects!)
  ChaosBagApi.findChaosBag = function()
    return Global.call("findChaosBag")
  end

  -- returns a table of object references to the tokens in play (does not include sealed tokens!)
  ChaosBagApi.getTokensInPlay = function()
    return Global.call("getChaosTokensinPlay")
  end

  -- returns all sealed tokens on cards to the chaos bag
  ---@param playerColor string Color of the player to show the broadcast to
  ChaosBagApi.releaseAllSealedTokens = function(playerColor)
    Global.call("releaseAllSealedTokens", playerColor)
  end

  -- returns all drawn tokens to the chaos bag
  ChaosBagApi.returnChaosTokens = function()
    Global.call("returnChaosTokens")
  end

  -- removes the specified chaos token from the chaos bag
  ---@param id string ID of the chaos token
  ChaosBagApi.removeChaosToken = function(id)
    Global.call("removeChaosToken", id)
  end

  -- returns a chaos token to the bag and calls all relevant functions
  ---@param token tts__Object Chaos token to return
  ---@param fromBag boolean whether or not the token to return was in the middle of being drawn (true) or elsewhere (false)
  ChaosBagApi.returnChaosTokenToBag = function(token, fromBag)
    Global.call("returnChaosTokenToBag", { token = token, fromBag = fromBag })
  end

  -- spawns the specified chaos token and puts it into the chaos bag
  ---@param id string ID of the chaos token
  ChaosBagApi.spawnChaosToken = function(id)
    Global.call("spawnChaosToken", id)
  end

  -- Checks to see if the chaos bag can be manipulated.  If a player is searching the bag when tokens
  -- are drawn or replaced a TTS bug can cause those tokens to vanish.  Any functions which change the
  -- contents of the bag should check this method before doing so.
  -- This method will broadcast a message to all players if the bag is being searched.
  ---@return any: True if the bag is manipulated, false if it should be blocked.
  ChaosBagApi.canTouchChaosTokens = function()
    return Global.call("canTouchChaosTokens")
  end

  -- draws a chaos token to a playermat
  ---@param mat tts__Object Playermat that triggered this
  ---@param drawAdditional boolean Controls whether additional tokens should be drawn
  ---@param tokenType? string Name of token (e.g. "Bless") to be drawn from the bag
  ---@param guidToBeResolved? string GUID of the sealed token to be resolved instead of drawing a token from the bag
  ---@param takeParameters? table Position and rotation of the location where the new token should be drawn to, usually to replace a returned token
  ---@return tts__Object: Object reference to the token that was drawn
  ChaosBagApi.drawChaosToken = function(mat, drawAdditional, tokenType, guidToBeResolved, takeParameters)
    return Global.call("drawChaosToken", {
      mat = mat,
      drawAdditional = drawAdditional,
      tokenType = tokenType,
      guidToBeResolved = guidToBeResolved,
      takeParameters = takeParameters
    })
  end

  -- returns a Table List of chaos token ids in the current chaos bag
  -- requires copying the data into a new table because TTS is weird about handling table return values in Global
  ChaosBagApi.getIdUrlMap = function()
    return Global.getTable("ID_URL_MAP")
  end

  return ChaosBagApi
end
end)
__bundle_register("playermat/PlayermatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local PlayermatApi = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")
  local searchLib = require("util/SearchLib")
  local localInvestigatorPosition = { x = -1.17, y = 1, z = -0.01 }

  -- Convenience function to look up a mat's object by color, or get all mats.
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@return table: Single-element if only single playermat is requested
  local function getMatForColor(matColor)
    if matColor == "All" then
      return guidReferenceApi.getObjectsByType("Playermat")
    else
      return { matColor = guidReferenceApi.getObjectByOwnerAndType(matColor, "Playermat") }
    end
  end

  -- Returns the color of the closest playermat
  ---@param startPos table Starting position to get the closest mat from
  PlayermatApi.getMatColorByPosition = function(startPos)
    local result, smallestDistance
    for matColor, mat in pairs(getMatForColor("All")) do
      local distance = Vector.between(startPos, mat.getPosition()):magnitude()
      if smallestDistance == nil or distance < smallestDistance then
        smallestDistance = distance
        result = matColor
      end
    end
    return result
  end

  -- Returns the color of the player's hand that is seated next to the playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getPlayerColor = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getVar("playerColor")
    end
  end

  -- Returns the color of the playermat that owns the playercolor's hand
  ---@param handColor string Color of the playermat
  PlayermatApi.getMatColor = function(handColor)
    for matColor, mat in pairs(getMatForColor("All")) do
      local playerColor = mat.getVar("playerColor")
      if playerColor == handColor then
        return matColor
      end
    end
  end

  -- Instructs a playermat to check for DES
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.checkForDES = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("checkForDES")
    end
  end

  -- Returns if there is the card "Dream-Enhancing Serum" on the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  ---@return boolean: whether DES is present on the playermat
  PlayermatApi.hasDES = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getVar("hasDES")
    end
  end

  -- gets the slot data for the playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getSlotData = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getTable("slotData")
    end
  end

  -- sets the slot data for the playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  ---@param newSlotData table New slot data for the playermat
  PlayermatApi.loadSlotData = function(matColor, newSlotData)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.setTable("slotData", newSlotData)
      mat.call("redrawSlotSymbols")
      return
    end
  end

  -- Performs a search of the deck area of the requested playermat and returns the result as table
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getDeckAreaObjects = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.call("getDeckAreaObjects")
    end
  end

  -- Flips the top card of the deck (useful after deck manipulation for Norman Withers)
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.flipTopCardFromDeck = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.call("flipTopCardFromDeck")
    end
  end

  -- Returns the position of the discard pile of the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getDiscardPosition = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.call("returnGlobalDiscardPosition")
    end
  end

  -- Returns the position of the draw pile of the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getDrawPosition = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.call("returnGlobalDrawPosition")
    end
  end

  -- Transforms a local position into a global position
  ---@param localPos table Local position to be transformed
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.transformLocalPosition = function(localPos, matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.positionToWorld(localPos)
    end
  end

  -- Returns the rotation of the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.returnRotation = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getRotation()
    end
  end

  -- Returns a table with spawn data (position and rotation) for a helper object
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@param helperName string Name of the helper object
  PlayermatApi.getHelperSpawnData = function(matColor, helperName)
    local resultTable = {}
    local localPositionTable = {
      ["Hand Helper"] = {0.05, 0, -1.182},
      ["Search Assistant"] = {-0.3, 0, -1.182}
    }
    
    for color, mat in pairs(getMatForColor(matColor)) do
      resultTable[color] = {
        position = mat.positionToWorld(localPositionTable[helperName]),
        rotation = mat.getRotation()
      }
    end
    return resultTable
  end


  -- Triggers the Upkeep for the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@param playerColor string Color of the calling player (for messages)
  PlayermatApi.doUpkeepFromHotkey = function(matColor, playerColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("doUpkeepFromHotkey", playerColor)
    end
  end

  -- Handles discarding for the requested playermat for the provided list of objects
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  ---@param objList table List of objects to discard
  PlayermatApi.discardListOfObjects = function(matColor, objList)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("discardListOfObjects", objList)
    end
  end

  -- Returns the active investigator id
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.returnInvestigatorId = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getVar("activeInvestigatorId")
    end
  end

  -- Returns the class of the active investigator
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.returnInvestigatorClass = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.getVar("activeInvestigatorClass")
    end
  end

  -- Returns the position for encounter card drawing
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  ---@param stack boolean If true, returns the leftmost position instead of the first empty from the right
  PlayermatApi.getEncounterCardDrawPosition = function(matColor, stack)
    for _, mat in pairs(getMatForColor(matColor)) do
      return Vector(mat.call("getEncounterCardDrawPosition", stack))
    end
  end

  -- Sets the requested playermat's snap points to limit snapping to matching card types or not.  If
  -- matchTypes is true, the main card slot snap points will only snap assets, while the
  -- investigator area point will only snap Investigators.  If matchTypes is false, snap points will
  -- be reset to snap all cards.
  ---@param matchCardTypes boolean Whether snap points should only snap for the matching card types
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("setLimitSnapsByType", matchCardTypes)
    end
  end

  -- Sets the requested playermat's draw 1 button to visible
  ---@param isDrawButtonVisible boolean Whether the draw 1 button should be visible or not
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.showDrawButton = function(isDrawButtonVisible, matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("showDrawButton", isDrawButtonVisible)
    end
  end

  -- Shows or hides the clickable clue counter for the requested playermat
  ---@param showCounter boolean Whether the clickable counter should be present or not
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.clickableClues = function(showCounter, matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("clickableClues", showCounter)
    end
  end

  -- Toggles the use of class textures for the requested playermat
  ---@param state boolean Whether the class texture should be used or not
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.useClassTexture = function(state, matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("useClassTexture", state)
    end
  end

  -- Removes all clues (to the trash for tokens and counters set to 0) for the requested playermat
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.removeClues = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("removeClues")
    end
  end

  -- Reports the clue count for the requested playermat
  ---@param useClickableCounters boolean Controls which type of counter is getting checked
  PlayermatApi.getClueCount = function(useClickableCounters, matColor)
    local count = 0
    for _, mat in pairs(getMatForColor(matColor)) do
      count = count + mat.call("getClueCount", useClickableCounters)
    end
    return count
  end

  -- Updates the specified owned counter
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@param type string Counter to target
  ---@param newValue number Value to set the counter to
  ---@param modifier number If newValue is not provided, the existing value will be adjusted by this modifier
  PlayermatApi.updateCounter = function(matColor, type, newValue, modifier)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("updateCounter", { type = type, newValue = newValue, modifier = modifier })
    end
  end

  -- Triggers the draw function for the specified playermat
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@param number number Amount of cards to draw
  PlayermatApi.drawCardsWithReshuffle = function(matColor, number)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("drawCardsWithReshuffle", number)
    end
  end

  -- Returns the resource counter amount
  ---@param matColor string Color of the playermat - White, Orange, Green or Red (does not support "All")
  ---@param type string Counter to target
  PlayermatApi.getCounterValue = function(matColor, type)
    for _, mat in pairs(getMatForColor(matColor)) do
      return mat.call("getCounterValue", type)
    end
  end

  -- Returns a list of mat colors that have an investigator placed
  PlayermatApi.getUsedMatColors = function()
    local usedColors = {}
    for matColor, mat in pairs(getMatForColor("All")) do
      local searchPos = mat.positionToWorld(localInvestigatorPosition)
      local searchResult = searchLib.atPosition(searchPos, "isCardOrDeck")
      if #searchResult > 0 then
        table.insert(usedColors, matColor)
      end
    end
    return usedColors
  end

  -- Returns investigator name
  ---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
  PlayermatApi.getInvestigatorName = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      local searchPos = mat.positionToWorld(localInvestigatorPosition)
      local searchResult = searchLib.atPosition(searchPos, "isCardOrDeck")
      if #searchResult == 1 then
        return searchResult[1].getName()
      end
    end
    return ""
  end

  -- Resets the specified skill tracker to "1, 1, 1, 1"
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.resetSkillTracker = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("resetSkillTracker")
    end
  end

  -- Redraws the XML for the slot symbols based on the slotData table
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.redrawSlotSymbols = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("redrawSlotSymbols")
    end
  end

  -- Finds all objects on the playermat and associated set aside zone and returns a table
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  ---@param filter string Name of the filte function (see util/SearchLib)
  PlayermatApi.searchAroundPlayermat = function(matColor, filter)
    local objList = {}
    for _, mat in pairs(getMatForColor(matColor)) do
      for _, obj in ipairs(mat.call("searchAroundSelf", filter)) do
        table.insert(objList, obj)
      end
    end
    return objList
  end

  -- Discard a non-hidden card from the corresponding player's hand
  ---@param matColor string Color of the playermat - White, Orange, Green, Red or All
  PlayermatApi.doDiscardOne = function(matColor)
    for _, mat in pairs(getMatForColor(matColor)) do
      mat.call("doDiscardOne")
    end
  end

  -- Triggers the metadata sync for all playermats
  PlayermatApi.syncAllCustomizableCards = function()
    for _, mat in pairs(getMatForColor("All")) do
      mat.call("syncAllCustomizableCards")
    end
  end

  return PlayermatApi
end
end)
__bundle_register("core/OptionPanelApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local OptionPanelApi = {}

  -- loads saved options
  ---@param options table Set a new state for the option table
  OptionPanelApi.loadSettings = function(options)
    return Global.call("loadSettings", options)
  end

  ---@return any: Table of option panel state
  OptionPanelApi.getOptions = function()
    return Global.getTable("optionPanel")
  end

  return OptionPanelApi
end
end)
__bundle_register("util/SearchLib", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local SearchLib = {}
  local filterFunctions = {
    isCard = function(x) return x.type == "Card" end,
    isDeck = function(x) return x.type == "Deck" end,
    isCardOrDeck = function(x) return x.type == "Card" or x.type == "Deck" end,
    isClue = function(x) return x.memo == "clueDoom" and x.is_face_down == false end,
    isTileOrToken = function(x) return x.type == "Tile" end,
    isUniversalToken = function(x) return x.getMemo() == "universalActionAbility" end,
  }

  -- performs the actual search and returns a filtered list of object references
  ---@param pos tts__Vector Global position
  ---@param rot? tts__Vector Global rotation
  ---@param size table Size
  ---@param filter? string Name of the filter function
  ---@param direction? table Direction (positive is up)
  ---@param maxDistance? number Distance for the cast
  local function returnSearchResult(pos, rot, size, filter, direction, maxDistance)
    local filterFunc
    if filter then
      filterFunc = filterFunctions[filter]
    end
    local searchResult = Physics.cast({
      origin       = pos,
      direction    = direction or { 0, 1, 0 },
      orientation  = rot or { 0, 0, 0 },
      type         = 3,
      size         = size,
      max_distance = maxDistance or 0
    })

    -- filter the result for matching objects
    local objList = {}
    for _, v in ipairs(searchResult) do
      if not filter or filterFunc(v.hit_object) then
        table.insert(objList, v.hit_object)
      end
    end
    return objList
  end

  -- searches the specified area
  SearchLib.inArea = function(pos, rot, size, filter)
    return returnSearchResult(pos, rot, size, filter)
  end

  -- searches the area on an object
  SearchLib.onObject = function(obj, filter)
    local pos = obj.getPosition()
    local size = obj.getBounds().size:setAt("y", 1)
    return returnSearchResult(pos, _, size, filter)
  end

  -- searches the specified position (a single point)
  SearchLib.atPosition = function(pos, filter)
    local size = { 0.1, 2, 0.1 }
    return returnSearchResult(pos, _, size, filter)
  end

  -- searches below the specified position (downwards until y = 0)
  SearchLib.belowPosition = function(pos, filter)
    local size = { 0.1, 2, 0.1 }
    local direction = { 0, -1, 0 }
    local maxDistance = pos.y
    return returnSearchResult(pos, _, size, filter, direction, maxDistance)
  end

  return SearchLib
end
end)
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("playercards/cards/BookofLivingMyths")
end)
__bundle_register("playercards/cards/BookofLivingMyths", function(require, _LOADED, __bundle_register, __bundle_modules)
require("playercards/CardsWithHelper")
local blessCurseManagerApi = require("chaosbag/BlessCurseManagerApi")
local chaosBagApi          = require("chaosbag/ChaosBagApi")
local guidReferenceApi     = require("core/GUIDReferenceApi")
local playermatApi         = require("playermat/PlayermatApi")

-- intentionally global
hasXML                     = true
isHelperEnabled            = false
local updated, loopId

function updateSave()
  self.script_state = JSON.encode({
    isHelperEnabled = isHelperEnabled,
    loopId = loopId
  })
end

function onLoad(savedData)
  if savedData and savedData ~= "" then
    local loadedData = JSON.decode(savedData)
    isHelperEnabled = loadedData.isHelperEnabled
    loopId = loadedData.loopId
  end
  syncDisplayWithOptionPanel()
end

function shutOff()
  if loopId then
    Wait.stop(loopId)
    loopId = nil
  end
end

function initialize()
  maybeUpdateButtonState()
  loopId = Wait.time(maybeUpdateButtonState, 1, -1)
end

function resolveToken(player, _, tokenType)
  if not updated then return end
  local matColor
  if player.color == "Black" then
    matColor = playermatApi.getMatColorByPosition(self.getPosition())
  else
    matColor = playermatApi.getMatColor(player.color)
  end

  local mat = guidReferenceApi.getObjectByOwnerAndType(matColor, "Playermat")
  chaosBagApi.drawChaosToken(mat, true, tokenType)
  updated = false
  Wait.frames(maybeUpdateButtonState, 2)
end

-- count tokens in the bag and show appropriate buttons
function maybeUpdateButtonState()
  local numInBag = blessCurseManagerApi.getBlessCurseInBag()
  local state = { Bless = false, Curse = false }

  if numInBag.Bless >= numInBag.Curse and numInBag.Bless > 0 then
    state.Bless = true
  end

  if numInBag.Curse >= numInBag.Bless and numInBag.Curse > 0 then
    state.Curse = true
  end

  setUiState(state)
  updated = true
end

function setUiState(params)
  for _, tokenName in ipairs({ "Bless", "Curse" }) do
    if params[tokenName] then
      self.UI.show(tokenName)
      self.UI.hide("inactive" .. tokenName)
    else
      self.UI.show("inactive" .. tokenName)
      self.UI.hide(tokenName)
    end
  end
end

function errorMessage()
  local numInBag = blessCurseManagerApi.getBlessCurseInBag()

  if numInBag.Bless == 0 and numInBag.Curse == 0 then
    broadcastToAll("There are no Bless or Curse tokens in the chaos bag.", "Red")
  elseif numInBag.Bless > numInBag.Curse then
    broadcastToAll("There are more Bless tokens than Curse tokens in the chaos bag.", "Red")
  else
    broadcastToAll("There are more Curse tokens than Bless tokens in the chaos bag.", "Red")
  end
end
end)
__bundle_register("chaosbag/BlessCurseManagerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local BlessCurseManagerApi = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")

  local function getManager()
    return guidReferenceApi.getObjectByOwnerAndType("Mythos", "BlessCurseManager")
  end

  -- removes all taken tokens and resets the counts
  BlessCurseManagerApi.removeTakenTokensAndReset = function()
    local BlessCurseManager = getManager()
    Wait.time(function() BlessCurseManager.call("removeTakenTokens", "Bless") end, 0.05)
    Wait.time(function() BlessCurseManager.call("removeTakenTokens", "Curse") end, 0.10)
    Wait.time(function() BlessCurseManager.call("doReset", "White") end, 0.15)
  end

  -- updates the internal count (called by cards that seal bless/curse tokens)
  ---@param type string Type of chaos token ("Bless" or "Curse")
  ---@param guid string GUID of the token
  BlessCurseManagerApi.sealedToken = function(type, guid)
    getManager().call("sealedToken", { type = type, guid = guid })
  end

  -- updates the internal count (called by cards that seal bless/curse tokens)
  ---@param type string Type of chaos token ("Bless" or "Curse")
  ---@param guid string GUID of the token
  ---@param fromBag? boolean Whether or not token was just drawn from the chaos bag
  BlessCurseManagerApi.releasedToken = function(type, guid, fromBag)
    getManager().call("releasedToken", { type = type, guid = guid, fromBag = fromBag })
  end

  -- updates the internal count (called by cards that seal bless/curse tokens)
  ---@param type string Type of chaos token ("Bless" or "Curse")
  ---@param guid string GUID of the token
  BlessCurseManagerApi.returnedToken = function(type, guid)
    getManager().call("returnedToken", { type = type, guid = guid })
  end

  -- broadcasts the current status for bless/curse tokens
  ---@param playerColor string Color of the player to show the broadcast to
  BlessCurseManagerApi.broadcastStatus = function(playerColor)
    getManager().call("broadcastStatus", playerColor)
  end

  -- removes all bless / curse tokens from the chaos bag and play
  ---@param playerColor string Color of the player to show the broadcast to
  BlessCurseManagerApi.removeAll = function(playerColor)
    getManager().call("doRemove", playerColor)
  end

  -- adds bless / curse sealing to the hovered card
  ---@param playerColor string Color of the player to show the broadcast to
  ---@param hoveredObject tts__Object Hovered object
  BlessCurseManagerApi.addBlurseSealingMenu = function(playerColor, hoveredObject)
    getManager().call("addMenuOptions", { playerColor = playerColor, hoveredObject = hoveredObject })
  end
  
  -- adds bless / curse to the chaos bag
  ---@param type string Type of chaos token ("Bless" or "Curse")
  BlessCurseManagerApi.addToken = function(type)
    getManager().call("addToken", type)
  end

  -- removes bless / curse from the chaos bag
  ---@param type string Type of chaos token ("Bless" or "Curse")
  BlessCurseManagerApi.removeToken = function(type)
    getManager().call("removeToken", type)
  end
  
  BlessCurseManagerApi.getBlessCurseInBag = function()
    return getManager().call("getBlessCurseInBag", {})
  end

  return BlessCurseManagerApi
end
end)
__bundle_register("core/GUIDReferenceApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local GUIDReferenceApi = {}

  local function getGuidHandler()
    return getObjectFromGUID("123456")
  end

  -- Returns the matching object
  ---@param owner string Parent object for this search
  ---@param type string Type of object to search for
  ---@return any: Object reference to the matching object
  GUIDReferenceApi.getObjectByOwnerAndType = function(owner, type)
    return getGuidHandler().call("getObjectByOwnerAndType", { owner = owner, type = type })
  end

  -- Returns all matching objects as a table with references
  ---@param type string Type of object to search for
  ---@return table: List of object references to matching objects
  GUIDReferenceApi.getObjectsByType = function(type)
    return getGuidHandler().call("getObjectsByType", type)
  end

  -- Returns all matching objects as a table with references
  ---@param owner string Parent object for this search
  ---@return table: List of object references to matching objects
  GUIDReferenceApi.getObjectsByOwner = function(owner)
    return getGuidHandler().call("getObjectsByOwner", owner)
  end

  -- Sends new information to the reference handler to edit the main index
  ---@param owner string Parent of the object
  ---@param type string Type of the object
  ---@param guid string GUID of the object
  GUIDReferenceApi.editIndex = function(owner, type, guid)
    return getGuidHandler().call("editIndex", {
      owner = owner,
      type = type,
      guid = guid
    })
  end

  -- Returns the owner of an object or the object it's located on
  ---@param object tts__GameObject Object for this search
  ---@return string: Parent of the object or object it's located on
  GUIDReferenceApi.getOwnerOfObject = function(object)
    return getGuidHandler().call("getOwnerOfObject", object)
  end

  return GUIDReferenceApi
end
end)
__bundle_register("playercards/CardsWithHelper", function(require, _LOADED, __bundle_register, __bundle_modules)
--[[ Library for cards that have helpers
This file is used to share code between cards with helpers.
It syncs the visibility of the helper with the option panel and
makes sure the card has the respective tag.
Additionally, it will call 'initiliaze()' and 'shutOff()'
in the parent file if they are present.

Instructions:
1) Define the global variables before requiring this file:
hasXML          = true  (whether the card has an XML display)
isHelperEnabled = false (default state of the helper, should be 'false')

2) In 'onLoad()'', call 'syncDisplayWithOptionPanel()'
----------------------------------------------------------]]

local optionPanelApi = require("core/OptionPanelApi")

-- if the respective option is enabled in onLoad(), enable the helper
function syncDisplayWithOptionPanel()
  self.addTag("CardWithHelper")
  local options = optionPanelApi.getOptions()
  if options.enableCardHelpers then
    setHelperState(true)
  else
    updateDisplay()
  end
end

-- forces a new state
function setHelperState(newState)
  isHelperEnabled = newState
  updateSave()
  updateDisplay()
end

-- toggles the current state
function toggleHelper()
  isHelperEnabled = not isHelperEnabled
  updateSave()
  updateDisplay()
end

-- updates the visibility and calls events (after a small delay to allow XML being set)
function updateDisplay()
  Wait.frames(actualDisplayUpdate, 5)
end

function actualDisplayUpdate()
  if isHelperEnabled then
    self.clearContextMenu()
    self.addContextMenuItem("Disable Helper", toggleHelper)
    if hasXML then self.UI.show("Helper") end
    if initialize then initialize() end
  else
    self.clearContextMenu()
    self.addContextMenuItem("Enable Helper", toggleHelper)
    if hasXML then self.UI.hide("Helper") end
    if shutOff then shutOff() end
  end
end
end)
return __bundle_require("__root")