ah_sce_unpacked/unpacked/Bag OptionPanel Source 830bd0/Custom_Token Clean Up Helper 26cf4b.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("core/PlayAreaApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local PlayAreaApi = { }
  local PLAY_AREA_GUID = "721ba2"
  local INVESTIGATOR_COUNTER_GUID = "f182ee"

  -- Returns the current value of the investigator counter from the playmat
  ---@return Integer.  Number of investigators currently set on the counter
  PlayAreaApi.getInvestigatorCount = function()
    return getObjectFromGUID(INVESTIGATOR_COUNTER_GUID).getVar("val")
  end

  -- Updates the current value of the investigator counter from the playmat
  ---@param count Number of investigators to set on the counter
  PlayAreaApi.setInvestigatorCount = function(count)
    return getObjectFromGUID(INVESTIGATOR_COUNTER_GUID).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 Color of the player requesting the shift.  Used solely to send an error
  ---    message in the unlikely case that the scripting zone has been deleted
  PlayAreaApi.shiftContentsUp = function(playerColor)
    return getObjectFromGUID(PLAY_AREA_GUID).call("shiftContentsUp", playerColor)
  end

  PlayAreaApi.shiftContentsDown = function(playerColor)
    return getObjectFromGUID(PLAY_AREA_GUID).call("shiftContentsDown", playerColor)
  end

  PlayAreaApi.shiftContentsLeft = function(playerColor)
    return getObjectFromGUID(PLAY_AREA_GUID).call("shiftContentsLeft", playerColor)
  end

  PlayAreaApi.shiftContentsRight = function(playerColor)
    return getObjectFromGUID(PLAY_AREA_GUID).call("shiftContentsRight", playerColor)
  end

  -- Reset the play area's tracking of which cards have had tokens spawned.
  PlayAreaApi.resetSpawnedCards = function()
    return getObjectFromGUID(PLAY_AREA_GUID).call("resetSpawnedCards")
  end

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

  -- Sets this playmat's snap points to limit snapping to locations or not.
  -- If matchTypes is false, snap points will be reset to snap all cards.
  ---@param matchTypes Boolean  Whether snap points should only snap for the matching card types.
  PlayAreaApi.setLimitSnapsByType = function(matchCardTypes)
    getObjectFromGUID(PLAY_AREA_GUID).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)
    getObjectFromGUID(PLAY_AREA_GUID).call("tryObjectEnterContainer",
        { container = container, object = object })
  end

  -- counts the VP on locations in the play area
  PlayAreaApi.countVP = function()
    return getObjectFromGUID(PLAY_AREA_GUID).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 getObjectFromGUID(PLAY_AREA_GUID).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 getObjectFromGUID(PLAY_AREA_GUID).call("highlightCountedVP", state)
  end

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

  PlayAreaApi.getSurface = function()
    return getObjectFromGUID(PLAY_AREA_GUID).getCustomObject().image
  end

  PlayAreaApi.updateSurface = function(url)
    return getObjectFromGUID(PLAY_AREA_GUID).call("updateSurface", url)
  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)
    getObjectFromGUID(PLAY_AREA_GUID).call("updateLocations", args)
  end

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

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

  -- this table links the name of a trigger effect to its index
  local soundIndices = {
    ["Vacuum"] = 0,
    ["Deep Bell"] = 1,
    ["Dark Souls"] = 2
  }

  local function playTriggerEffect(index)
    getObjectsWithTag("SoundCube")[1].AssetBundle.playTriggerEffect(index)
  end

  -- plays the by name requested sound
  ---@param soundName String Name of the sound to play
  SoundCubeApi.playSoundByName = function(soundName)
    playTriggerEffect(soundIndices[soundName])
  end

  return SoundCubeApi
end
end)
__bundle_register("core/token/TokenSpawnTrackerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local TokenSpawnTracker = { }
  local SPAWN_TRACKER_GUID = "e3ffc9"

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

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

  TokenSpawnTracker.resetTokensSpawned = function(cardGuid)
    return getObjectFromGUID(SPAWN_TRACKER_GUID).call("resetTokensSpawned", cardGuid)
  end

  TokenSpawnTracker.resetAllAssetAndEvents = function()
    return getObjectFromGUID(SPAWN_TRACKER_GUID).call("resetAllAssetAndEvents")
  end

  TokenSpawnTracker.resetAllLocations = function()
    return getObjectFromGUID(SPAWN_TRACKER_GUID).call("resetAllLocations")
  end

  TokenSpawnTracker.resetAll = function()
    return getObjectFromGUID(SPAWN_TRACKER_GUID).call("resetAll")
  end

  return TokenSpawnTracker
end
end)
__bundle_register("playermat/PlaymatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local PlaymatApi = { }
  local internal = { }

  local MAT_IDS = {
    White  = "8b081b",
    Orange = "bd0ff4",
    Green  = "383d8b",
    Red    = "0840d5"
  }

  local CLUE_COUNTER_GUIDS = {
    White  = "37be78",
    Orange = "1769ed",
    Green  = "032300",
    Red    = "d86b7c"
  }

  local CLUE_CLICKER_GUIDS = {
    White  = "db85d6",
    Orange = "3f22e5",
    Green  = "891403",
    Red    = "4111de"
  }

  -- Returns the color of the by position requested playermat as string
  ---@param startPos Table Position of the search, table get's roughly cut into 4 quarters to assign a playermat
  PlaymatApi.getMatColorByPosition = function(startPos)
    if startPos.x < -42 then
      if startPos.z > 0 then
        return "White"
      else
        return "Orange"
      end
    else
      if startPos.z > 0 then
        return "Green"
      else
        return "Red"
      end
    end
  end

  -- Returns the color of the player's hand that is seated next to the playermat
  ---@param matColor String Color of the playermat
  PlaymatApi.getPlayerColor = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.getVar("playerColor")
  end

  -- Returns the color of the playermat that owns the playercolor's hand
  ---@param handColor String Color of the playermat
  PlaymatApi.getMatColor = function(handColor)
    local matColors = {"White", "Orange", "Green", "Red"}
    for i, mat in ipairs(internal.getMatForColor("All")) do
      local color = mat.getVar("playerColor")
      if color == handColor then return matColors[i] end
    end
    return "NOT_FOUND"
  end

  -- Returns the result of a cast in the specificed playermat's area
  ---@param matColor String Color of the playermat
  PlaymatApi.searchPlaymat = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.call("searchAroundSelf")
  end

  -- Returns if there is the card "Dream-Enhancing Serum" on the requested playermat
  ---@param matColor String Color of the playermat
  PlaymatApi.isDES = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.getVar("isDES")
  end

  -- Returns the draw deck of the requested playmat
  ---@param matColor String Color of the playermat
  PlaymatApi.getDrawDeck = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    mat.call("getDrawDiscardDecks")
    return mat.getVar("drawDeck")
  end

  -- Returns the position of the discard pile of the requested playmat
  ---@param matColor String Color of the playermat
  PlaymatApi.getDiscardPosition = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.call("returnGlobalDiscardPosition")
  end

  -- Transforms a local position into a global position
  ---@param localPos Table Local position to be transformed
  ---@param matColor String Color of the playermat
  PlaymatApi.transformLocalPosition = function(localPos, matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.positionToWorld(localPos)
  end

  -- Returns the rotation of the requested playmat
  ---@param matColor String Color of the playermat
  PlaymatApi.returnRotation = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.getRotation()
  end

  -- Triggers the Upkeep for the requested playmat
  ---@param matColor String Color of the playermat
  ---@param playerColor String Color of the calling player (for messages)
  PlaymatApi.doUpkeepFromHotkey = function(matColor, playerColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.call("doUpkeepFromHotkey", playerColor)
  end

  -- Returns the active investigator id
  ---@param matColor String Color of the playermat
  PlaymatApi.returnInvestigatorId = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.getVar("activeInvestigatorId")
  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 for one of the active player colors - White, Orange, Green, Red.  Also
  --     accepts "All" as a special value which will apply the setting to all four mats.
  PlaymatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
    for _, mat in ipairs(internal.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 for one of the active player colors - White, Orange, Green, Red.  Also
  --     accepts "All" as a special value which will apply the setting to all four mats.
  PlaymatApi.showDrawButton = function(isDrawButtonVisible, matColor)
    for _, mat in ipairs(internal.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 for one of the active player colors - White, Orange, Green, Red.  Also
  --     accepts "All" as a special value which will apply the setting to all four mats.
  PlaymatApi.clickableClues = function(showCounter, matColor)
    for _, mat in ipairs(internal.getMatForColor(matColor)) do
      mat.call("clickableClues", showCounter)
    end
  end

  -- Removes all clues (to the trash for tokens and counters set to 0) for the requested playermat
  ---@param matColor String for one of the active player colors - White, Orange, Green, Red.  Also
  --     accepts "All" as a special value which will apply the setting to all four mats.
  PlaymatApi.removeClues = function(matColor)
    for _, mat in ipairs(internal.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
  PlaymatApi.getClueCount = function(useClickableCounters, matColor)
    local count = 0
    for _, mat in ipairs(internal.getMatForColor(matColor)) do
      count = count + tonumber(mat.call("getClueCount", useClickableCounters))
    end
    return count
  end

  -- Adds the specified amount of resources to the requested playermat's resource counter
  PlaymatApi.gainResources = function(amount, matColor)
    for _, mat in ipairs(internal.getMatForColor(matColor)) do
      mat.call("gainResources", amount)
    end
  end

  -- Returns the resource counter amount for the requested playermat
  PlaymatApi.getResourceCount = function(matColor)
    local mat = getObjectFromGUID(MAT_IDS[matColor])
    return mat.call("getResourceCount")
  end

  -- Discard a non-hidden card from the corresponding player's hand
  PlaymatApi.doDiscardOne = function(matColor)
    for _, mat in ipairs(internal.getMatForColor(matColor)) do
      mat.call("doDiscardOne")
    end
  end

  PlaymatApi.syncAllCustomizableCards = function()
    for _, mat in ipairs(internal.getMatForColor("All")) do
      mat.call("syncAllCustomizableCards")
    end
  end

  PlaymatApi.updateClueClicker = function(playerColor, val)
    return getObjectFromGUID(CLUE_CLICKER_GUIDS[playerColor]).call("updateVal", val)
  end

  -- Convenience function to look up a mat's object by color, or get all mats.
  ---@param matColor String for one of the active player colors - White, Orange, Green, Red.  Also
  --     accepts "All" as a special value which will return all four mats.
  ---@return: Array of playermat objects.  If a single mat is requested, will return a single-element
  --     array to simplify processing by consumers.
  internal.getMatForColor = function(matColor)
    local targetMatGuid = MAT_IDS[matColor]
    if targetMatGuid != nil then
      return { getObjectFromGUID(targetMatGuid) }
    end
    if matColor == "All" then
      return {
        getObjectFromGUID(MAT_IDS.White),
        getObjectFromGUID(MAT_IDS.Orange),
        getObjectFromGUID(MAT_IDS.Green),
        getObjectFromGUID(MAT_IDS.Red),
      }
    end
  end

  return PlaymatApi
end
end)
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("accessories/CleanUpHelper")
end)
__bundle_register("accessories/CleanUpHelper", function(require, _LOADED, __bundle_register, __bundle_modules)
--[[ Cleans up the table for the next scenario in a campaign:
- sets counters to default values (resources and doom) or trauma values (health and sanity, if not disabled) from campaign log
- puts everything on playmats and hands into respective trashcans
- use the IGNORE_TAG to exclude objects from tidying (default: "CleanUpHelper_Ignore")]]

local blessCurseManagerApi      = require("chaosbag/BlessCurseManagerApi")
local chaosBagApi               = require("chaosbag/ChaosBagApi")
local playAreaApi               = require("core/PlayAreaApi")
local playmatApi                = require("playermat/PlaymatApi")
local soundCubeApi              = require("core/SoundCubeApi")
local tokenSpawnTrackerApi      = require("core/token/TokenSpawnTrackerApi")

-- these objects will be ignored
local IGNORE_GUIDS              = {
  -- big playmat, change image panel and investigator counter
  "b7b45b", "f182ee", "721ba2",
  -- bless/curse manager
  "afa06b", "bd0253", "5933fb",
  -- stuff on agenda/act playmat
  "85c4c6", "4a3aa4", "fea079", "b015d8", "11e0cf", "9f334f", "70b9f6", "0a5a29",
  -- doom/location token bag
  "47ffc3", "170f10",
  -- table
  "4ee1f2"
}

-- objects with this tag will be ignored
local IGNORE_TAG                = "CleanUpHelper_ignore"

-- colors and order for following tables
local COLORS                    = { "White", "Orange", "Green", "Red", "Agenda" }

-- counter GUIDS (4x damage and 4x horror)
local DAMAGE_HORROR_GUIDS       = {
  "eb08d6", "e64eec", "1f5a0a", "591a45",
  "468e88", "0257d9", "7b5729", "beb964",
}

local campaignLog
local RESET_VALUES              = {}

-- GUIDS of objects (in order of ownership relating to 'COLORS')
local PLAYERMAT_GUIDS           = { "8b081b", "bd0ff4", "383d8b", "0840d5" }
local RESOURCE_GUIDS            = { "4406f0", "816d84", "cd15ac", "a4b60d" }
local TRACKER_GUIDS             = { "e598c2", "b4a5f7", "af7ed7", "e74881" }
local CLUE_GUIDS                = { "d86b7c", "1769ed", "032300", "37be78" }
local CLUE_CLICKER_GUIDS        = { "db85d6", "3f22e5", "891403", "4111de" }
local TRASHCAN_GUIDS            = { "147e80", "f7b6c8", "5f896a", "4b8594", "70b9f6" }

-- values for physics.cast (4 entries for player zones, 5th entry for agenda/act deck, 6th for campaign log)
local PHYSICS_POSITION          = {
  { -54.5, 2, 21 },
  { -54.5, 2, -21 },
  { -27.0, 2, 26 },
  { -27.0, 2, -26 },
  { -02.0, 2, 10 },
  { -00.0, 2, -27 }
}

local PHYSICS_ROTATION          = {
  270,
  270,
  0,
  180,
  270,
  0
}

local PHYSICS_SCALE             = {
  { 36.6, 1, 14.5 },
  { 36.6, 1, 14.5 },
  { 34.0, 1, 14.5 },
  { 34.0, 1, 14.5 },
  { 55.0, 1, 13.5 },
  { 05.0, 1, 05.0 }
}

local optionsVisible            = false
local options                   = {}
options["importTrauma"]         = true
options["tidyPlayermats"]       = true
options["removeDrawnLines"]     = false

local buttonParameters          = {}
buttonParameters.function_owner = self

local loadingFailedBefore       = false

---------------------------------------------------------
-- option loading and GUI setup
---------------------------------------------------------

function onSave()
  return JSON.encode({ options = options })
end

function onLoad(savedData)
  if savedData ~= nil then
    local loadedData = JSON.decode(savedData)
    options = loadedData.options
    -- update UI to match saved state
    for id, state in pairs(options) do
      self.UI.setAttribute(id, "image", state and "option_on" or "option_off")
    end
  end

  -- index 0: button as label
  buttonParameters.label          = "Clean Up Helper"
  buttonParameters.click_function = "none"
  buttonParameters.position       = { x = 0, y = 0.1, z = -1.3 }
  buttonParameters.height         = 0
  buttonParameters.width          = 0
  buttonParameters.font_size      = 230
  buttonParameters.font_color     = Color(0, 0, 0)
  self.createButton(buttonParameters)

  -- index 1: option button
  buttonParameters.label          = "Settings"
  buttonParameters.click_function = "showOrHideOptions"
  buttonParameters.color          = { 0, 0, 0, 0.96 }
  buttonParameters.position.z     = -0.1
  buttonParameters.height         = 350
  buttonParameters.width          = 1000
  buttonParameters.font_size      = 190
  buttonParameters.font_color     = "White"
  self.createButton(buttonParameters)

  -- index 2: start button
  buttonParameters.label          = "Reset play areas"
  buttonParameters.click_function = "cleanUp"
  buttonParameters.position.z     = 1.1
  buttonParameters.width          = 1550
  self.createButton(buttonParameters)

  -- create single table for ignoring
  for _, v in ipairs(CLUE_GUIDS) do table.insert(IGNORE_GUIDS, v) end
  for _, v in ipairs(CLUE_CLICKER_GUIDS) do table.insert(IGNORE_GUIDS, v) end
  for _, v in ipairs(RESOURCE_GUIDS) do table.insert(IGNORE_GUIDS, v) end
  for _, v in ipairs(TRASHCAN_GUIDS) do table.insert(IGNORE_GUIDS, v) end
  for _, v in ipairs(PLAYERMAT_GUIDS) do table.insert(IGNORE_GUIDS, v) end
  for _, v in ipairs(DAMAGE_HORROR_GUIDS) do table.insert(IGNORE_GUIDS, v) end
end

---------------------------------------------------------
-- click functions for option buttons
---------------------------------------------------------

-- changes the UI state and the internal variable for the togglebuttons
function optionButtonClick(_, id)
  local currentState = options[id]
  local newState = (currentState and "option_off" or "option_on")
  options[id] = not currentState
  self.UI.setAttribute(id, "image", newState)
end

-- shows or hides the option panel
function showOrHideOptions()
  optionsVisible = not optionsVisible

  if optionsVisible then
    self.UI.show("options")
  else
    self.UI.hide("options")
  end
end

---------------------------------------------------------
-- main function
---------------------------------------------------------

function cleanUp(_, color)
  printToAll("------------------------------", "White")
  printToAll("Clean up started!", "Orange")
  printToAll("Resetting counters...", "White")

  soundCubeApi.playSoundByName("Vacuum")
  ignoreCustomDataHelper()
  getTrauma()

  -- delay to account for potential state change
  Wait.time(function()
    updateCounters(RESOURCE_GUIDS, 5, "Resource")
    updateCounters(CLUE_CLICKER_GUIDS, 0, "Clue clicker")
    updateCounters(DAMAGE_HORROR_GUIDS, RESET_VALUES, "Damage / Horror")
  end, 0.2)

  resetSkillTrackers()
  resetDoomCounter()
  blessCurseManagerApi.removeAll(color)
  removeLines()
  discardHands()
  tokenSpawnTrackerApi.resetAll()
  chaosBagApi.returnChaosTokens()
  chaosBagApi.releaseAllSealedTokens(color)

  printToAll("Tidying main play area...", "White")
  startLuaCoroutine(self, "tidyPlayareaCoroutine")
end

---------------------------------------------------------
-- modular functions, called by other functions
---------------------------------------------------------

function updateCounters(tableOfGUIDs, newValues, info)
  -- instead of a table, this will be used if just a single value is provided
  local singleValue = tonumber(newValues)

  for i, guid in ipairs(tableOfGUIDs) do
    local TOKEN = getObjectFromGUID(guid)
    local newValue = singleValue or newValues[i]

    if TOKEN ~= nil then
      TOKEN.call("updateVal", newValue)
    else
      printToAll(info .. ": No. " .. i .. " could not be found.", "Yellow")
    end
  end
end

-- set investigator skill trackers to "1, 1, 1, 1"
function resetSkillTrackers()
  for i, guid in ipairs(TRACKER_GUIDS) do
    local obj = getObjectFromGUID(guid)

    if obj ~= nil then
      obj.call("updateStats", { 1, 1, 1, 1 })
    else
      printToAll("Skill tracker for " .. COLORS[i] .. " playmat could not be found.", "Yellow")
    end
  end
end

-- reset doom on agenda
function resetDoomCounter()
  local doomCounter = getObjectFromGUID("85c4c6")

  if doomCounter ~= nil then
    doomCounter.call("updateVal")
  else
    printToAll("Doom counter could not be found.", "Yellow")
  end
end

-- gets the GUID of a custom data helper (if present) and adds it to the ignore list
function ignoreCustomDataHelper()
  local customDataHelper = playAreaApi.getCustomDataHelper()
  if customDataHelper then
    table.insert(IGNORE_GUIDS, customDataHelper.getGUID())
  end
end

-- read values for trauma from campaign log if enabled
function getTrauma()
  RESET_VALUES = {
    0, 0, 0, 0,
    0, 0, 0, 0
  }

  -- stop here if trauma import is disabled
  if not options["importTrauma"] then
    printToAll("Default values for health and sanity loaded.", "Yellow")
    return
  end

  -- get campaign log
  campaignLog = findObjects(6)[1]
  if campaignLog == nil then
    printToAll("Campaign log not found in standard position!", "Yellow")
    printToAll("Default values for health and sanity loaded.", "Yellow")
    return
  end
  campaignLog = campaignLog.hit_object
  loadTrauma()
end

-- gets data from campaign log if possible
function loadTrauma()
  -- check if "returnTrauma" function exists to avoid calling nil
  local trauma = campaignLog.getVar("returnTrauma")

  if trauma ~= nil then
    printToAll("Trauma values found in campaign log!", "Green")
    RESET_VALUES = campaignLog.call("returnTrauma")
    loadingFailedBefore = false
  elseif loadingFailedBefore then
    printToAll("Trauma values could not be found in campaign log!", "Yellow")
    printToAll("Default values for health and sanity loaded.", "Yellow")
    loadingFailedBefore = false
  else
    -- set campaign log to first state
    local stateId = campaignLog.getStateId()

    if stateId ~= 1 then
      campaignLog = campaignLog.setState(1)
    end
    loadingFailedBefore = true

    -- small delay to account for potential state change
    Wait.time(loadTrauma, 0.1)
  end
end

-- remove drawn lines
function removeLines()
  if options["removeDrawnLines"] then
    printToAll("Removing vector lines...", "White")
    Global.setVectorLines({})
  end
end

-- discard all hand objects
function discardHands()
  if not options["tidyPlayermats"] then return end
  for i = 1, 4 do
    local trashcan = getObjectFromGUID(TRASHCAN_GUIDS[i])
    if trashcan == nil then return end
    local hand = Player[playmatApi.getPlayerColor(COLORS[i])].getHandObjects()
    for j = #hand, 1, -1 do
      trashcan.putObject(hand[j])
    end
  end
end

-- clean up for play area
function tidyPlayareaCoroutine()
  local trashcan = getObjectFromGUID(TRASHCAN_GUIDS[5])
  local PLAYMATZONE = getObjectFromGUID("a2f932")

  if PLAYMATZONE == nil then
    printToAll("Scripting zone for main play area could not be found!", "Red")
  elseif trashcan == nil then
    printToAll("Trashcan for main play area could not be found!", "Red")
  else
    for _, obj in ipairs(PLAYMATZONE.getObjects()) do
      -- ignore these elements
      if not tableContains(IGNORE_GUIDS, obj.getGUID()) and obj.hasTag(IGNORE_TAG) == false then
        coroutine.yield(0)
        trashcan.putObject(obj)
      end
    end
  end

  printToAll("Tidying playermats and agenda mat...", "White")
  startLuaCoroutine(self, "tidyPlayerMatCoroutine")
  return 1
end

-- clean up for the four playermats and the agenda/act playmat
function tidyPlayerMatCoroutine()
  for i = 1, 5 do
    -- only continue for playermat (1-4) if option enabled
    if options["tidyPlayermats"] or i == 5 then
      -- delay for animation purpose
      for k = 1, 30 do coroutine.yield(0) end

      -- get respective trashcan
      local trashcan = getObjectFromGUID(TRASHCAN_GUIDS[i])
      if trashcan == nil then
        printToAll("Trashcan for " .. COLORS[i] .. " playmat could not be found!", "Red")
        return 1
      end

      for _, entry in ipairs(findObjects(i)) do
        local obj = entry.hit_object
        local desc_low = string.lower(obj.getDescription())

        -- ignore these elements
        if not tableContains(IGNORE_GUIDS, obj.getGUID()) and obj.hasTag(IGNORE_TAG) == false and
            desc_low ~= "chaos bag" and desc_low ~= "action token" then
          coroutine.yield(0)
          trashcan.putObject(obj)

          -- flip action tokens back to ready
        elseif desc_low == "action token" and obj.is_face_down then
          obj.flip()
        end
      end

      -- reset "activeInvestigatorId"
      if i < 5 then
        local playermat = getObjectFromGUID(PLAYERMAT_GUIDS[i])
        if playermat then
          playermat.setVar("activeInvestigatorId", "00000")
        end
      end
    end
  end

  local datahelper = getObjectFromGUID("708279")
  if datahelper then
    datahelper.setTable("SPAWNED_PLAYER_CARD_GUIDS", {})
  end

  printToAll("Clean up completed!", "Green")
  return 1
end

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

-- find objects depending on index (1 to 4 for playermats, 5 for agenda/act playmat, 6 for campaign log)
function findObjects(num)
  return Physics.cast({
    direction    = { 0, 1, 0 },
    max_distance = 1,
    type         = 3,
    size         = PHYSICS_SCALE[num],
    origin       = PHYSICS_POSITION[num],
    orientation  = { 0, PHYSICS_ROTATION[num], 0 },
    debug        = false
  })
end

-- search a table for a value, return true if found (else returns false)
function tableContains(table, value)
  for _, v in ipairs(table) do
    if v == value then
      return true
    end
  end
  return false
end
end)
__bundle_register("chaosbag/BlessCurseManagerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local BlessCurseManagerApi = {}
  local MANAGER_GUID = "5933fb"

  -- removes all taken tokens and resets the counts
  BlessCurseManagerApi.removeTakenTokensAndReset = function()
    local BlessCurseManager = getObjectFromGUID(MANAGER_GUID)
    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)
  BlessCurseManagerApi.sealedToken = function(type, guid)
    getObjectFromGUID(MANAGER_GUID).call("sealedToken", { type = type, guid = guid })
  end

  -- updates the internal count (called by cards that seal bless/curse tokens)
  BlessCurseManagerApi.releasedToken = function(type, guid)
    getObjectFromGUID(MANAGER_GUID).call("releasedToken", { 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)
    getObjectFromGUID(MANAGER_GUID).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)
    getObjectFromGUID(MANAGER_GUID).call("doRemove", playerColor)
  end

  -- adds Wendy's menu to the hovered card (allows sealing of tokens)
  ---@param color String Color of the player to show the broadcast to
  BlessCurseManagerApi.addWendysMenu = function(playerColor, hoveredObject)
    getObjectFromGUID(MANAGER_GUID).call("addMenuOptions", { playerColor = playerColor, hoveredObject = hoveredObject })
  end
  
  return BlessCurseManagerApi
end
end)
__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)
    return 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.getTable("chaosTokens")
  end

  -- returns all sealed tokens on cards to the chaos bag
  ChaosBagApi.releaseAllSealedTokens = function(playerColor)
    return Global.call("releaseAllSealedTokens", playerColor)
  end

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

  -- removes the specified chaos token from the chaos bag
  ---@param id String ID of the chaos token
  ChaosBagApi.removeChaosToken = function(id)
    return Global.call("removeChaosToken", id)
  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)
    return 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 Boolean.  True if the bag is manipulated, false if it should be blocked.
  ChaosBagApi.canTouchChaosTokens = function()
    return Global.call("canTouchChaosTokens")
  end

  -- called by playermats (by the "Draw chaos token" button)
  ChaosBagApi.drawChaosToken = function(mat, tokenOffset, isRightClick)
    return Global.call("drawChaosToken", {mat, tokenOffset, isRightClick})
  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)
return __bundle_require("__root")