ah_sce_unpacked/unpacked/Bag Additional Player Cards 2cba6b.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("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("arkhamdb/HotfixBag")
end)
__bundle_register("arkhamdb/HotfixBag", function(require, _LOADED, __bundle_register, __bundle_modules)
-- A Hotfix bag contains replacement cards for the All Cards Bag, and should
-- have the 'AllCardsHotfix' tag on the object.  Code for the All Cards Bag will
-- find these bags during indexing, and use them to replace cards from the
-- actual bag.

-- Tells the All Cards Bag to recreate its indexes.  The All Cards Bag may
-- ignore this request; see the rebuildIndexForHotfix() method in the All Cards
-- Bag for details.

local allCardsBagApi = require("playercards/AllCardsBagApi")

function onLoad()
  allCardsBagApi.rebuildIndexForHotfix()
  self.addContextMenuItem("Update card index", function() allCardsBagApi.rebuildIndexForHotfix() end)
end
end)
__bundle_register("playercards/AllCardsBagApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
  local AllCardsBagApi = {}
  local guidReferenceApi = require("core/GUIDReferenceApi")

  local function getAllCardsBag()
    return guidReferenceApi.getObjectByOwnerAndType("Mythos", "AllCardsBag")
  end

  -- Returns a specific card from the bag, based on ArkhamDB ID
  ---@param id table String ID of the card to retrieve
  ---@return table table
  --  If the indexes are still being constructed, an empty table is
  --  returned.  Otherwise, a single table with the following fields
  --    cardData: TTS object data, suitable for spawning the card
  --    cardMetadata: Table of parsed metadata
  AllCardsBagApi.getCardById = function(id)
    return getAllCardsBag().call("getCardById", {id = id})
  end

  -- Gets a random basic weakness from the bag.  Once a given ID has been returned
  -- it will be removed from the list and cannot be selected again until a reload
  -- occurs or the indexes are rebuilt, which will refresh the list to include all
  -- weaknesses.
  ---@return string: ID of the selected weakness.
  AllCardsBagApi.getRandomWeaknessId = function()
    return getAllCardsBag().call("getRandomWeaknessId")
  end

  AllCardsBagApi.isIndexReady = function()
    return getAllCardsBag().call("isIndexReady")
  end

  -- Called by Hotfix bags when they load.  If we are still loading indexes, then
  -- the all cards and hotfix bags are being loaded together, and we can ignore
  -- this call as the hotfix will be included in the initial indexing.  If it is
  -- called once indexing is complete it means the hotfix bag has been added
  -- later, and we should rebuild the index to integrate the hotfix bag.
  AllCardsBagApi.rebuildIndexForHotfix = function()
    return getAllCardsBag().call("rebuildIndexForHotfix")
  end

  -- Searches the bag for cards which match the given name and returns a list.  Note that this is
  -- an O(n) search without index support.  It may be slow.
  ---@param name string or string fragment to search for names
  ---@param exact boolean Whether the name match should be exact
  AllCardsBagApi.getCardsByName = function(name, exact)
    return getAllCardsBag().call("getCardsByName", {name = name, exact = exact})
  end

  AllCardsBagApi.isBagPresent = function()
    return getAllCardsBag() and true
  end

  -- Returns a list of cards from the bag matching a class and level (0 or upgraded)
  ---@param class string class to retrieve ("Guardian", "Seeker", etc)
  ---@param upgraded boolean true for upgraded cards (Level 1-5), false for Level 0
  ---@return table: If the indexes are still being constructed, returns an empty table.
  --     Otherwise, a list of tables, each with the following fields
  --       cardData: TTS object data, suitable for spawning the card
  --       cardMetadata: Table of parsed metadata
  AllCardsBagApi.getCardsByClassAndLevel = function(class, upgraded)
    return getAllCardsBag().call("getCardsByClassAndLevel", {class = class, upgraded = upgraded})
  end

  AllCardsBagApi.getCardsByCycle = function(cycle)
    return getAllCardsBag().call("getCardsByCycle", cycle)
  end

  AllCardsBagApi.getUniqueWeaknesses = function()
    return getAllCardsBag().call("getUniqueWeaknesses")
  end

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

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

  ---@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

  return GUIDReferenceApi
end
end)
return __bundle_require("__root")