-- 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("core/PlayAreaApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local PlayAreaApi = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")

  local function getPlayArea()
    return guidReferenceApi.getObjectByOwnerAndType("Mythos", "PlayArea")
  end

  local function getInvestigatorCounter()
    return guidReferenceApi.getObjectByOwnerAndType("Mythos", "InvestigatorCounter")
  end

  -- Returns the current value of the investigator counter from the playermat
  ---@return number: Number of investigators currently set on the counter
  PlayAreaApi.getInvestigatorCount = function()
    return getInvestigatorCounter().getVar("val")
  end

  -- Updates the current value of the investigator counter from the playermat
  ---@param count number Number of investigators to set on the counter
  PlayAreaApi.setInvestigatorCount = function(count)
    getInvestigatorCounter().call("updateVal", count)
  end

  -- Move all contents on the play area (cards, tokens, etc) one slot in the given direction. Certain
  -- fixed objects will be ignored, as will anything the player has tagged with 'displacement_excluded'
  ---@param playerColor string Color of the player requesting the shift for messages
  PlayAreaApi.shiftContentsUp = function(playerColor)
    getPlayArea().call("shiftContentsUp", playerColor)
  end

  PlayAreaApi.shiftContentsDown = function(playerColor)
    getPlayArea().call("shiftContentsDown", playerColor)
  end

  PlayAreaApi.shiftContentsLeft = function(playerColor)
    getPlayArea().call("shiftContentsLeft", playerColor)
  end

  PlayAreaApi.shiftContentsRight = function(playerColor)
    getPlayArea().call("shiftContentsRight", playerColor)
  end

  ---@param state boolean This controls whether location connections should be drawn
  PlayAreaApi.setConnectionDrawState = function(state)
    getPlayArea().call("setConnectionDrawState", state)
  end

  ---@param color string Connection color to be used for location connections
  PlayAreaApi.setConnectionColor = function(color)
    getPlayArea().call("setConnectionColor", color)
  end

  -- Event to be called when the current scenario has changed
  ---@param scenarioName string Name of the new scenario
  PlayAreaApi.onScenarioChanged = function(scenarioName)
    getPlayArea().call("onScenarioChanged", scenarioName)
  end

  -- Sets this playermat's snap points to limit snapping to locations or not.
  -- 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
  PlayAreaApi.setLimitSnapsByType = function(matchCardTypes)
    getPlayArea().call("setLimitSnapsByType", matchCardTypes)
  end

  -- Receiver for the Global tryObjectEnterContainer event.  Used to clear vector lines from dragged
  -- cards before they're destroyed by entering the container
  PlayAreaApi.tryObjectEnterContainer = function(container, object)
    getPlayArea().call("tryObjectEnterContainer", { container = container, object = object })
  end

  -- Counts the VP on locations in the play area
  PlayAreaApi.countVP = function()
    return getPlayArea().call("countVP")
  end

  -- Highlights all locations in the play area without metadata
  ---@param state boolean True if highlighting should be enabled
  PlayAreaApi.highlightMissingData = function(state)
    return getPlayArea().call("highlightMissingData", state)
  end

  -- Highlights all locations in the play area with VP
  ---@param state boolean True if highlighting should be enabled
  PlayAreaApi.highlightCountedVP = function(state)
    return getPlayArea().call("countVP", state)
  end

  -- Checks if an object is in the play area (returns true or false)
  PlayAreaApi.isInPlayArea = function(object)
    return getPlayArea().call("isInPlayArea", object)
  end

  -- Returns the current surface of the play area
  PlayAreaApi.getSurface = function()
    return getPlayArea().getCustomObject().image
  end

  -- Updates the surface of the play area
  PlayAreaApi.updateSurface = function(url)
    return getPlayArea().call("updateSurface", url)
  end

  -- Returns a deep copy of the currently tracked locations
  PlayAreaApi.getTrackedLocations = function()
    local t = {}
    for k, v in pairs(getPlayArea().call("getTrackedLocations", {})) do
      t[k] = v
    end
    return t
  end

  -- Called by Custom Data Helpers to push their location data into the Data Helper. This adds the
  -- data to the local token manager instance.
  ---@param args table Single-value array holding the GUID of the Custom Data Helper making the call
  PlayAreaApi.updateLocations = function(args)
    getPlayArea().call("updateLocations", args)
  end

  PlayAreaApi.getCustomDataHelper = function()
    return getPlayArea().getVar("customDataHelper")
  end

  return PlayAreaApi
end
end)
__bundle_register("core/token/TokenChecker", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local CHAOS_TOKEN_NAMES = {
    ["Elder Sign"] = true,
    ["+1"] = true,
    ["0"] = true,
    ["-1"] = true,
    ["-2"] = true,
    ["-3"] = true,
    ["-4"] = true,
    ["-5"] = true,
    ["-6"] = true,
    ["-7"] = true,
    ["-8"] = true,
    ["Skull"] = true,
    ["Cultist"] = true,
    ["Tablet"] = true,
    ["Elder Thing"] = true,
    ["Auto-fail"] = true,
    ["Bless"] = true,
    ["Curse"] = true,
    ["Frost"] = true
  }

  local TokenChecker = {}

  -- returns true if the passed object is a chaos token (by name)
  TokenChecker.isChaosToken = function(obj)
    if obj.type == "Tile" and CHAOS_TOKEN_NAMES[obj.getName()] then
      return true
    else
      return false
    end
  end

  return TokenChecker
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("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("core/token/TokenSpawnTrackerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local TokenSpawnTracker = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")

  local function getSpawnTracker()
    return guidReferenceApi.getObjectByOwnerAndType("Mythos", "TokenSpawnTracker")
  end

  TokenSpawnTracker.hasSpawnedTokens = function(cardGuid)
    return getSpawnTracker().call("hasSpawnedTokens", cardGuid)
  end

  TokenSpawnTracker.markTokensSpawned = function(cardGuid)
    return getSpawnTracker().call("markTokensSpawned", cardGuid)
  end

  TokenSpawnTracker.resetTokensSpawned = function(card)
    return getSpawnTracker().call("resetTokensSpawned", card)
  end

  TokenSpawnTracker.resetAllAssetAndEvents = function()
    return getSpawnTracker().call("resetAllAssetAndEvents")
  end

  TokenSpawnTracker.resetAllLocations = function()
    return getSpawnTracker().call("resetAllLocations")
  end

  TokenSpawnTracker.resetAll = function()
    return getSpawnTracker().call("resetAll")
  end

  return TokenSpawnTracker
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("util/DeckLib", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local DeckLib = {}
  local searchLib = require("util/SearchLib")

  -- places a card/deck at a position or merges into an existing deck below
  ---@param objOrTable tts__Object|table Object or table of objects to move
  ---@param pos table New position for the object
  ---@param rot? table New rotation for the object
  ---@param below? boolean Should the object be placed below an existing deck?
  DeckLib.placeOrMergeIntoDeck = function(objOrTable, pos, rot, below)
    if objOrTable == nil or pos == nil then return end

    -- handle 'objOrTable' parameter
    local objects = {}
    if type(objOrTable) == "table" then
      objects = objOrTable
    else
      table.insert(objects, objOrTable)
    end

    -- search the new position for existing card/deck
    local searchResult = searchLib.atPosition(pos, "isCardOrDeck")
    local targetObj

    -- get new position
    local offset = 0.5
    local newPos = Vector(pos) + Vector(0, offset, 0)

    if #searchResult == 1 then
      targetObj = searchResult[1]
      local bounds = targetObj.getBounds()
      if below then
        newPos = Vector(pos):setAt("y", bounds.center.y - bounds.size.y / 2)
      else
        newPos = Vector(pos):setAt("y", bounds.center.y + bounds.size.y / 2 + offset)
      end
    end

    -- process objects in reverse order
    for i = #objects, 1, -1 do
      local obj = objects[i]
      -- add a 0.1 delay for each object (for animation purposes)
      Wait.time(function()
        -- allow moving smoothly out of hand and temporarily lock it
        obj.setLock(true)
        obj.use_hands = false

        if rot then
          obj.setRotationSmooth(rot, false, true)
        end
        obj.setPositionSmooth(newPos, false, true)

        -- wait for object to finish movement (or 2 seconds)
        Wait.condition(
          function()
            -- revert toggles
            obj.setLock(false)
            obj.use_hands = true

            -- use putObject to avoid a TTS bug that merges unrelated cards that are not resting
            if #searchResult == 1 and targetObj ~= obj and not targetObj.isDestroyed() and not obj.isDestroyed() then
              targetObj = targetObj.putObject(obj)
            else
              targetObj = obj
            end
          end,
          -- check state of the object (make sure it's not moving)
          function() return obj.isDestroyed() or not obj.isSmoothMoving() end,
          2)
      end, (#objects- i) * 0.1)
    end
  end

  return DeckLib
end
end)
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("core/MythosArea")
end)
__bundle_register("core/MythosArea", function(require, _LOADED, __bundle_register, __bundle_modules)
local deckLib = require("util/DeckLib")
local guidReferenceApi = require("core/GUIDReferenceApi")
local playAreaApi = require("core/PlayAreaApi")
local playermatApi = require("playermat/PlayermatApi")
local searchLib = require("util/SearchLib")
local tokenArrangerApi = require("accessories/TokenArrangerApi")
local tokenChecker = require("core/token/TokenChecker")
local tokenSpawnTrackerApi = require("core/token/TokenSpawnTrackerApi")

local ENCOUNTER_DECK_AREA = {
  upperLeft = { x = 1.05, z = 0.15 },
  lowerRight = { x = 0.70, z = 0.59 }
}
local ENCOUNTER_DISCARD_AREA = {
  upperLeft = { x = 1.77, z = 0.15 },
  lowerRight = { x = 1.42, z = 0.59 }
}

-- global position of encounter deck and discard pile
local ENCOUNTER_DECK_POS = { x = -3.93, y = 1, z = 5.76 }
local ENCOUNTER_DISCARD_POSITION = { x = -3.85, y = 1, z = 10.38 }
local isReshuffling = false
local collisionEnabled = false
local currentScenario, useFrontData, tokenData

function onSave()
  return JSON.encode({
    currentScenario = currentScenario,
    useFrontData    = useFrontData,
    tokenData       = tokenData
  })
end

function onLoad(savedData)
  if savedData and savedData ~= "" then
    local loadedState = JSON.decode(savedData) or {}
    currentScenario   = loadedState.currentScenario or ""
    useFrontData      = loadedState.useFrontData or true
    tokenData         = loadedState.tokenData or {}
  end
  Wait.time(function() collisionEnabled = true end, 0.1)
end

---------------------------------------------------------
-- collison and container event handling
---------------------------------------------------------

-- TTS event handler. Handles scenario name event triggering and encounter card token resets.
function onCollisionEnter(collisionInfo)
  if not collisionEnabled then return end

  local object = collisionInfo.collision_object

  -- early exit for better performance
  if object.type ~= "Card" then return end

  -- get scenario name and maybe fire followup event
  if object.getName() == "Scenario" then
    local description = object.getDescription()

    -- detect if a new scenario card is placed down
    if currentScenario ~= description then
      currentScenario = description
      fireScenarioChangedEvent()
    end

    local metadata = JSON.decode(object.getGMNotes()) or {}
    if not metadata["tokens"] then
      tokenData = {}
      return
    end

    -- detect orientation of scenario card (for difficulty)
    useFrontData = not object.is_face_down
    tokenData = metadata["tokens"][(useFrontData and "front" or "back")]
    fireTokenDataChangedEvent()
  end

  local localPos = self.positionToLocal(object.getPosition())
  if inArea(localPos, ENCOUNTER_DECK_AREA) or inArea(localPos, ENCOUNTER_DISCARD_AREA) then
    Wait.frames(function() tokenSpawnTrackerApi.resetTokensSpawned(object) end, 1)
    removeTokensFromObject(object)
  end
end

-- TTS event handler. Handles scenario name event triggering
function onCollisionExit(collisionInfo)
  local object = collisionInfo.collision_object

  -- reset token metadata if scenario reference card is removed
  if object.getName() == "Scenario" then
    tokenData = {}
    useFrontData = nil
    fireTokenDataChangedEvent()
  end
end

-- Listens for cards entering the encounter deck or encounter discard, discards tokens on them,
-- and resets the spawn state for the cards when they do.
function onObjectEnterContainer(container, object)
  local localPos = self.positionToLocal(container.getPosition())
  if inArea(localPos, ENCOUNTER_DECK_AREA) or inArea(localPos, ENCOUNTER_DISCARD_AREA) then
    tokenSpawnTrackerApi.resetTokensSpawned(object)
    removeTokensFromObject(object)
  end
end

-- fires if the scenario title changes
function fireScenarioChangedEvent()
  -- maybe show the title splash screen
  Wait.frames(function() Global.call('titleSplash', currentScenario) end, 20)

  -- set the scenario for the playarea (connections might be disabled)
  playAreaApi.onScenarioChanged(currentScenario)

  -- maybe update the playarea image
  local playAreaImageSelector = guidReferenceApi.getObjectByOwnerAndType("Mythos", "PlayAreaImageSelector")
  playAreaImageSelector.call("maybeUpdatePlayAreaImage", currentScenario)
end

-- fires if the scenario title or the difficulty changes
function fireTokenDataChangedEvent()
  local fullData = returnTokenData()
  tokenArrangerApi.onTokenDataChanged(fullData)
end

-- returns the chaos token metadata (if provided)
function returnTokenData()
  return {
    tokenData       = tokenData,
    currentScenario = currentScenario,
    useFrontData    = useFrontData
  }
end

---------------------------------------------------------
-- encounter card drawing
---------------------------------------------------------

-- gets the encounter deck (for internal functions and Api calls)
function getEncounterDeck()
  local searchResult = searchLib.atPosition(ENCOUNTER_DECK_POS, "isCardOrDeck")

  if #searchResult > 0 then
    return searchResult[1]
  end
end

-- 'params' contains the position, rotation and a boolean to force a faceup draw
function drawEncounterCard(params)
  local encounterDeck = getEncounterDeck()
  local reshuffledAlready

  if encounterDeck then
    reshuffledAlready = false
    if encounterDeck.type == "Deck" then
      actualEncounterCardDraw(encounterDeck.takeObject(), params)
    else
      actualEncounterCardDraw(encounterDeck, params)
    end
  else
    -- nothing here, time to reshuffle
    if reshuffledAlready == true then
      reshuffledAlready = false
      return
    end

    -- if there is no discard pile either, reshuffleEncounterDeck will give an error message already
    local success = reshuffleEncounterDeck()

    -- only continue if there was a discard pile
    if not success then return end
    reshuffledAlready = true
    drawEncounterCard(params)
  end
end

-- draw the provided card to the requesting playermat
function actualEncounterCardDraw(card, params)
    card.deal(1, params.matColor);
end

-- gets the discard pile and shuffles it into the encounter deck
---@return boolean: Whether the operation was successfully performed
function reshuffleEncounterDeck()
  -- flag to avoid multiple calls
  if isReshuffling then
    return false
  end
  isReshuffling = true

  -- disable flag after 1s delay
  Wait.time(function() isReshuffling = false end, 1)

  local encounterDeck = getEncounterDeck()
  local discardPile = searchLib.atPosition(ENCOUNTER_DISCARD_POSITION, "isCardOrDeck")

  if #discardPile > 0 then
    local discardDeck = discardPile[1]

    -- flips discard pile
    if not discardDeck.is_face_down then
      discardDeck.setRotation({ 0, -90, 180 })
    end

    -- make a new encounter deck
    if encounterDeck == nil then
      discardDeck.setPosition(Vector(ENCOUNTER_DECK_POS) + Vector({ 0, 1, 0 }))
      encounterDeck = discardDeck
    else
      encounterDeck.putObject(discardDeck)
    end
    encounterDeck.shuffle()
    broadcastToAll("Shuffled encounter discard into deck.", "White")
    return true
  else
    broadcastToAll("Encounter discard pile is already empty.", "Red")
    return false
  end
end

---------------------------------------------------------
-- helper functions
---------------------------------------------------------

-- Simple method to check if the given point is in a specified area
---@param point tts__Vector Point to check, only x and z values are relevant
---@param bounds table Defined area to see if the point is within
---@return boolean: True if the point is in the area defined by bounds
function inArea(point, bounds)
  return (point.x < bounds.upperLeft.x
    and point.x > bounds.lowerRight.x
    and point.z > bounds.upperLeft.z
    and point.z < bounds.lowerRight.z)
end

-- removes tokens from the provided card/deck
function removeTokensFromObject(object)
  local TRASH = guidReferenceApi.getObjectByOwnerAndType("Mythos", "Trash")
  for _, obj in ipairs(searchLib.onObject(object, "isTileOrToken")) do
    if obj.getGUID() ~= "4ee1f2" and -- table
        obj ~= self and
        obj.memo ~= nil and
        obj.getLock() == false and
        not tokenChecker.isChaosToken(obj) then
      TRASH.putObject(obj)
    end
  end
end
end)
__bundle_register("accessories/TokenArrangerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local TokenArrangerApi = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")

  -- local function to call the token arranger, if it is on the table
  ---@param functionName string Name of the function to cal
  ---@param argument? table Parameter to pass
  local function callIfExistent(functionName, argument)
    local tokenArranger = guidReferenceApi.getObjectByOwnerAndType("Mythos", "TokenArranger")
    if tokenArranger ~= nil then
      tokenArranger.call(functionName, argument)
    end
  end

  -- updates the token modifiers with the provided data
  ---@param fullData table Contains the chaos token metadata
  TokenArrangerApi.onTokenDataChanged = function(fullData)
    callIfExistent("onTokenDataChanged", fullData)
  end

  -- deletes already laid out tokens
  TokenArrangerApi.deleteCopiedTokens = function()
    callIfExistent("deleteCopiedTokens")
  end

  -- updates the laid out tokens
  TokenArrangerApi.layout = function()
    Wait.time(function() callIfExistent("layout") end, 0.1)
  end

  return TokenArrangerApi
end
end)
return __bundle_require("__root")