-- 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("accessories/TokenArrangerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local TokenArrangerApi = {}

  -- local function to call the token arranger, if it is on the table
  ---@param functionName String Name of the function to cal
  ---@param argument Variant Parameter to pass
  local function callIfExistent(functionName, argument)
    local tokenArranger = getObjectsWithTag("TokenArranger")[1]
    if tokenArranger ~= nil then
      tokenArranger.call(functionName, argument)
    end
  end

  -- updates the token modifiers with the provided data
  ---@param tokenData 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)
__bundle_register("core/PlayAreaApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local PlayAreaApi = { }

  local PLAY_AREA_GUID = "721ba2"

  -- 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(PLAY_AREA_GUID).call("getInvestigatorCount")
  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

  return PlayAreaApi
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("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("core/MythosArea")
end)
__bundle_register("core/MythosArea", function(require, _LOADED, __bundle_register, __bundle_modules)
local playAreaApi = require("core/PlayAreaApi")
local tokenArrangerApi = require("accessories/TokenArrangerApi")
local tokenSpawnTrackerApi = require("core/token/TokenSpawnTrackerApi")

local ENCOUNTER_DECK_AREA = {
  upperLeft = { x = 0.9, z = 0.42 },
  lowerRight = { x = 0.86, z = 0.38 },
}
local ENCOUNTER_DISCARD_AREA = {
  upperLeft = { x = 1.62, z = 0.42 },
  lowerRight = { x = 1.58, z = 0.38 },
}

local currentScenario
local useFrontData
local tokenData

-- we use this to turn off collision handling until onLoad() is complete
local collisionEnabled = false

function onLoad(saveState)
  if saveState ~= nil then
    local loadedState = JSON.decode(saveState) or {}
    currentScenario   = loadedState.currentScenario or ""
    useFrontData      = loadedState.useFrontData or true
    tokenData         = loadedState.tokenData or {}
  end
  collisionEnabled = true
end

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

-- 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
  if object.getName() == "Scenario" then
    local updateNeeded = false
    local description = object.getDescription()

    -- detect if orientation of scenario card changed (flipped to other side)
    if object.is_face_down == useFrontData then
      useFrontData = not useFrontData
      updateNeeded = true
    end

    -- detect if another scenario card is placed down
    if currentScenario ~= description then
      currentScenario = description
      updateNeeded = true
      fireScenarioChangedEvent()
    end

    -- trigger update if a change was detected and push new data
    if updateNeeded then
      local metadata = JSON.decode(object.getGMNotes()) or {}
      if not metadata["tokens"] then
        tokenData = {}
        return
      end
      tokenData = metadata["tokens"][(useFrontData and "front" or "back")]
      fireTokenDataChangedEvent()
    end
  end

  local localPos = self.positionToLocal(object.getPosition())
  if inArea(localPos, ENCOUNTER_DECK_AREA) or inArea(localPos, ENCOUNTER_DISCARD_AREA) then
    tokenSpawnTrackerApi.resetTokensSpawned(object.getGUID())
  end
end

-- TTS event handler. Handles scenario name event triggering
function onCollisionExit(collisionInfo)
  if not collisionEnabled then return end
  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, 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.getGUID())
  end
end

-- fires if the scenario title changes
function fireScenarioChangedEvent()
  Wait.frames(function() Global.call('titleSplash', currentScenario) end, 20)
  playAreaApi.onScenarioChanged(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

-- Simple method to check if the given point is in a specified area.  Local use only,
---@param point Vector.  Point to check, only x and z values are relevant
---@param bounds Table.  Defined area to see if the point is within.  See MAIN_PLAY_AREA for sample
--     bounds definition.
---@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
end)
return __bundle_require("__root")