ah_sce_unpacked/unpacked/Bag All Player Cards 15bb07/Card Family Inheritance 394603.ttslua

1206 lines
44 KiB
Plaintext
Raw Normal View History

2022-12-13 14:02:30 -05:00
-- 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)
2024-02-04 10:51:51 -05:00
__bundle_register("core/token/TokenManager", function(require, _LOADED, __bundle_register, __bundle_modules)
2024-01-06 21:32:29 -05:00
do
2024-02-04 10:51:51 -05:00
local guidReferenceApi = require("core/GUIDReferenceApi")
local optionPanelApi = require("core/OptionPanelApi")
local playAreaApi = require("core/PlayAreaApi")
local searchLib = require("util/SearchLib")
local tokenSpawnTrackerApi = require("core/token/TokenSpawnTrackerApi")
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
local PLAYER_CARD_TOKEN_OFFSETS = {
[1] = {
Vector(0, 3, -0.2)
},
[2] = {
Vector(0.4, 3, -0.2),
Vector(-0.4, 3, -0.2)
},
[3] = {
Vector(0, 3, -0.9),
Vector(0.4, 3, -0.2),
Vector(-0.4, 3, -0.2)
},
[4] = {
Vector(0.4, 3, -0.9),
Vector(-0.4, 3, -0.9),
Vector(0.4, 3, -0.2),
Vector(-0.4, 3, -0.2)
},
[5] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.4, 3, -0.2),
Vector(-0.4, 3, -0.2)
},
[6] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2)
},
[7] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(0, 3, 0.5)
},
[8] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(-0.35, 3, 0.5),
Vector(0.35, 3, 0.5)
},
[9] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(0.7, 3, 0.5),
Vector(0, 3, 0.5),
Vector(-0.7, 3, 0.5)
},
[10] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(0.7, 3, 0.5),
Vector(0, 3, 0.5),
Vector(-0.7, 3, 0.5),
Vector(0, 3, 1.2)
},
[11] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(0.7, 3, 0.5),
Vector(0, 3, 0.5),
Vector(-0.7, 3, 0.5),
Vector(-0.35, 3, 1.2),
Vector(0.35, 3, 1.2)
},
[12] = {
Vector(0.7, 3, -0.9),
Vector(0, 3, -0.9),
Vector(-0.7, 3, -0.9),
Vector(0.7, 3, -0.2),
Vector(0, 3, -0.2),
Vector(-0.7, 3, -0.2),
Vector(0.7, 3, 0.5),
Vector(0, 3, 0.5),
Vector(-0.7, 3, 0.5),
Vector(0.7, 3, 1.2),
Vector(0, 3, 1.2),
Vector(-0.7, 3, 1.2)
}
}
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- stateIDs for the multi-stated resource tokens
local stateTable = {
["resource"] = 1,
["ammo"] = 2,
["bounty"] = 3,
["charge"] = 4,
["evidence"] = 5,
["secret"] = 6,
["supply"] = 7
}
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- Table of data extracted from the token source bag, keyed by the Memo on each token which
-- should match the token type keys ("resource", "clue", etc)
local tokenTemplates
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
local playerCardData
local locationData
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
local TokenManager = { }
local internal = { }
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- Spawns tokens for the card. This function is built to just throw a card at it and let it do
-- the work once a card has hit an area where it might spawn tokens. It will check to see if
-- the card has already spawned, find appropriate data from either the uses metadata or the Data
-- Helper, and spawn the tokens.
---@param card Object Card to maybe spawn tokens for
---@param extraUses Table A table of <use type>=<count> which will modify the number of tokens
--- spawned for that type. e.g. Akachi's playmat should pass "Charge"=1
TokenManager.spawnForCard = function(card, extraUses)
if tokenSpawnTrackerApi.hasSpawnedTokens(card.getGUID()) then
return
end
local metadata = JSON.decode(card.getGMNotes())
if metadata ~= nil then
internal.spawnTokensFromUses(card, extraUses)
else
internal.spawnTokensFromDataHelper(card)
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawns a set of tokens on the given card.
---@param card Object Card to spawn tokens on
---@param tokenType String Type of token to spawn, valid values are "damage", "horror",
-- "resource", "doom", or "clue"
---@param tokenCount Number How many tokens to spawn. For damage or horror this value will be set to the
-- spawned state object rather than spawning multiple tokens
---@param shiftDown Number An offset for the z-value of this group of tokens
---@param subType String Subtype of token to spawn. This will only differ from the tokenName for resource tokens
TokenManager.spawnTokenGroup = function(card, tokenType, tokenCount, shiftDown, subType)
local optionPanel = optionPanelApi.getOptions()
if tokenType == "damage" or tokenType == "horror" then
TokenManager.spawnCounterToken(card, tokenType, tokenCount, shiftDown)
elseif tokenType == "resource" and optionPanel["useResourceCounters"] == "enabled" then
TokenManager.spawnResourceCounterToken(card, tokenCount)
elseif tokenType == "resource" and optionPanel["useResourceCounters"] == "custom" and tokenCount == 0 then
TokenManager.spawnResourceCounterToken(card, tokenCount)
else
TokenManager.spawnMultipleTokens(card, tokenType, tokenCount, shiftDown, subType)
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawns a single counter token and sets the value to tokenValue. Used for damage and horror
-- tokens.
---@param card Object Card to spawn tokens on
---@param tokenType String type of token to spawn, valid values are "damage" and "horror". Other
-- types should use spawnMultipleTokens()
---@param tokenValue Number Value to set the damage/horror to
TokenManager.spawnCounterToken = function(card, tokenType, tokenValue, shiftDown)
if tokenValue < 1 or tokenValue > 50 then return end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
local pos = card.positionToWorld(PLAYER_CARD_TOKEN_OFFSETS[1][1] + Vector(0, 0, shiftDown))
local rot = card.getRotation()
TokenManager.spawnToken(pos, tokenType, rot, function(spawned) spawned.setState(tokenValue) end)
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
TokenManager.spawnResourceCounterToken = function(card, tokenCount)
local pos = card.positionToWorld(card.positionToLocal(card.getPosition()) + Vector(0, 0.2, -0.5))
local rot = card.getRotation()
TokenManager.spawnToken(pos, "resourceCounter", rot, function(spawned)
spawned.call("updateVal", tokenCount)
end)
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawns a number of tokens.
---@param tokenType String type of token to spawn, valid values are resource", "doom", or "clue".
-- Other types should use spawnCounterToken()
---@param tokenCount Number How many tokens to spawn
---@param shiftDown Number An offset for the z-value of this group of tokens
---@param subType String Subtype of token to spawn. This will only differ from the tokenName for resource tokens
TokenManager.spawnMultipleTokens = function(card, tokenType, tokenCount, shiftDown, subType)
-- not checking the max at this point since clue offsets are calculated dynamically
if tokenCount < 1 then return end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
local offsets = {}
if tokenType == "clue" then
offsets = internal.buildClueOffsets(card, tokenCount)
else
-- only up to 12 offset tables defined
if tokenCount > 12 then return end
for i = 1, tokenCount do
offsets[i] = card.positionToWorld(PLAYER_CARD_TOKEN_OFFSETS[tokenCount][i])
-- Fix the y-position for the spawn, since positionToWorld considers rotation which can
-- have bad results for face up/down differences
offsets[i].y = card.getPosition().y + 0.15
end
end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
if shiftDown ~= nil then
-- Copy the offsets to make sure we don't change the static values
local baseOffsets = offsets
offsets = { }
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- get a vector for the shifting (downwards local to the card)
local shiftDownVector = Vector(0, 0, shiftDown):rotateOver("y", card.getRotation().y)
for i, baseOffset in ipairs(baseOffsets) do
offsets[i] = baseOffset + shiftDownVector
end
end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
if offsets == nil then
error("couldn't find offsets for " .. tokenCount .. ' tokens')
return
end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- handling for not provided subtype (for example when spawning from custom data helpers)
if subType == nil then
subType = ""
end
-- this is used to load the correct state for additional resource tokens (e.g. "Ammo")
local callback = nil
local stateID = stateTable[string.lower(subType)]
if tokenType == "resource" and stateID ~= nil and stateID ~= 1 then
callback = function(spawned) spawned.setState(stateID) end
end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
for i = 1, tokenCount do
TokenManager.spawnToken(offsets[i], tokenType, card.getRotation(), callback)
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawns a single token at the given global position by copying it from the template bag.
---@param position Global position to spawn the token
---@param tokenType String type of token to spawn, valid values are "damage", "horror",
-- "resource", "doom", or "clue"
---@param rotation Vector Rotation to be used for the new token. Only the y-value will be used,
-- x and z will use the default rotation from the source bag
---@param callback function A callback function triggered after the new token is spawned
TokenManager.spawnToken = function(position, tokenType, rotation, callback)
internal.initTokenTemplates()
local loadTokenType = tokenType
if tokenType == "clue" or tokenType == "doom" then
loadTokenType = "clueDoom"
end
if tokenTemplates[loadTokenType] == nil then
error("Unknown token type '" .. tokenType .. "'")
return
end
local tokenTemplate = tokenTemplates[loadTokenType]
-- Take ONLY the Y-value for rotation, so we don't flip the token coming out of the bag
local rot = Vector(tokenTemplate.Transform.rotX,
270,
tokenTemplate.Transform.rotZ)
if rotation ~= nil then
rot.y = rotation.y
end
if tokenType == "doom" then
rot.z = 180
end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
tokenTemplate.Nickname = ""
return spawnObjectData({
data = tokenTemplate,
position = position,
rotation = rot,
callback_function = callback
})
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Checks a card for metadata to maybe replenish it
---@param card Object Card object to be replenished
---@param uses Table The already decoded metadata.uses (to avoid decoding again)
---@param mat Object The playmat the card is placed on (for rotation and casting)
TokenManager.maybeReplenishCard = function(card, uses, mat)
-- TODO: support for cards with multiple uses AND replenish (as of yet, no official card needs that)
if uses[1].count and uses[1].replenish then
internal.replenishTokens(card, uses, mat)
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Delegate function to the token spawn tracker. Exists to avoid circular dependencies in some
-- callers.
---@param card Object Card object to reset the tokens for
TokenManager.resetTokensSpawned = function(card)
tokenSpawnTrackerApi.resetTokensSpawned(card.getGUID())
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Pushes new player card data into the local copy of the Data Helper player data.
---@param dataTable Table Key/Value pairs following the DataHelper style
TokenManager.addPlayerCardData = function(dataTable)
internal.initDataHelperData()
for k, v in pairs(dataTable) do
playerCardData[k] = v
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Pushes new location data into the local copy of the Data Helper location data.
---@param dataTable Table Key/Value pairs following the DataHelper style
TokenManager.addLocationData = function(dataTable)
internal.initDataHelperData()
for k, v in pairs(dataTable) do
locationData[k] = v
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Checks to see if the given card has location data in the DataHelper
---@param card Object Card to check for data
---@return Boolean True if this card has data in the helper, false otherwise
TokenManager.hasLocationData = function(card)
internal.initDataHelperData()
return internal.getLocationData(card) ~= nil
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
internal.initTokenTemplates = function()
if tokenTemplates ~= nil then
return
end
tokenTemplates = {}
local tokenSource = guidReferenceApi.getObjectByOwnerAndType("Mythos", "TokenSource")
for _, tokenTemplate in ipairs(tokenSource.getData().ContainedObjects) do
local tokenName = tokenTemplate.Memo
tokenTemplates[tokenName] = tokenTemplate
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Copies the data from the DataHelper. Will only happen once.
internal.initDataHelperData = function()
if playerCardData ~= nil then
return
end
local dataHelper = guidReferenceApi.getObjectByOwnerAndType("Mythos", "DataHelper")
playerCardData = dataHelper.getTable('PLAYER_CARD_DATA')
locationData = dataHelper.getTable('LOCATIONS_DATA')
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawn tokens for a card based on the uses metadata. This will consider the face up/down state
-- of the card for both locations and standard cards.
---@param card Object Card to maybe spawn tokens for
---@param extraUses Table A table of <use type>=<count> which will modify the number of tokens
--- spawned for that type. e.g. Akachi's playmat should pass "Charge"=1
internal.spawnTokensFromUses = function(card, extraUses)
local uses = internal.getUses(card)
if uses == nil then return end
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- go through tokens to spawn
local tokenCount
for i, useInfo in ipairs(uses) do
tokenCount = (useInfo.count or 0) + (useInfo.countPerInvestigator or 0) * playAreaApi.getInvestigatorCount()
if extraUses ~= nil and extraUses[useInfo.type] ~= nil then
tokenCount = tokenCount + extraUses[useInfo.type]
end
-- Shift each spawned group after the first down so they don't pile on each other
TokenManager.spawnTokenGroup(card, useInfo.token, tokenCount, (i - 1) * 0.8, useInfo.type)
end
tokenSpawnTrackerApi.markTokensSpawned(card.getGUID())
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawn tokens for a card based on the data helper data. This will consider the face up/down state
-- of the card for both locations and standard cards.
---@param card Object Card to maybe spawn tokens for
internal.spawnTokensFromDataHelper = function(card)
internal.initDataHelperData()
local playerData = internal.getPlayerCardData(card)
if playerData ~= nil then
internal.spawnPlayerCardTokensFromDataHelper(card, playerData)
end
local locationData = internal.getLocationData(card)
if locationData ~= nil then
internal.spawnLocationTokensFromDataHelper(card, locationData)
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawn tokens for a player card using data retrieved from the Data Helper.
---@param card Object Card to maybe spawn tokens for
---@param playerData Table Player card data structure retrieved from the DataHelper. Should be
-- the right data for this card.
internal.spawnPlayerCardTokensFromDataHelper = function(card, playerData)
local token = playerData.tokenType
local tokenCount = playerData.tokenCount
TokenManager.spawnTokenGroup(card, token, tokenCount)
tokenSpawnTrackerApi.markTokensSpawned(card.getGUID())
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
-- Spawn tokens for a location using data retrieved from the Data Helper.
---@param card Object Card to maybe spawn tokens for
---@param locationData Table Location data structure retrieved from the DataHelper. Should be
-- the right data for this card.
internal.spawnLocationTokensFromDataHelper = function(card, locationData)
local clueCount = internal.getClueCountFromData(card, locationData)
if clueCount > 0 then
TokenManager.spawnTokenGroup(card, "clue", clueCount)
tokenSpawnTrackerApi.markTokensSpawned(card.getGUID())
end
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
internal.getPlayerCardData = function(card)
return playerCardData[card.getName() .. ':' .. card.getDescription()]
or playerCardData[card.getName()]
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
internal.getLocationData = function(card)
return locationData[card.getName() .. '_' .. card.getGUID()] or locationData[card.getName()]
2024-01-06 21:32:29 -05:00
end
2024-02-04 10:51:51 -05:00
internal.getClueCountFromData = function(card, locationData)
-- Return the number of clues to spawn on this location
if locationData == nil then
error('attempted to get clue for unexpected object: ' .. card.getName())
return 0
2023-04-22 16:56:01 -04:00
end
2024-02-04 10:51:51 -05:00
if ((card.is_face_down and locationData.clueSide == 'back')
or (not card.is_face_down and locationData.clueSide == 'front')) then
if locationData.type == 'fixed' then
return locationData.value
elseif locationData.type == 'perPlayer' then
return locationData.value * playAreaApi.getInvestigatorCount()
end
error('unexpected location type: ' .. locationData.type)
2023-04-22 16:56:01 -04:00
end
2024-02-04 10:51:51 -05:00
return 0
2023-04-22 16:56:01 -04:00
end
2024-02-04 10:51:51 -05:00
-- Gets the right uses structure for this card, based on metadata and face up/down state
---@param card Object Card to pull the uses from
internal.getUses = function(card)
local metadata = JSON.decode(card.getGMNotes()) or { }
if metadata.type == "Location" then
if card.is_face_down and metadata.locationBack ~= nil then
return metadata.locationBack.uses
elseif not card.is_face_down and metadata.locationFront ~= nil then
return metadata.locationFront.uses
end
elseif not card.is_face_down then
return metadata.uses
end
2023-04-22 16:56:01 -04:00
2024-02-04 10:51:51 -05:00
return nil
2023-04-22 16:56:01 -04:00
end
2024-02-04 10:51:51 -05:00
-- Dynamically create positions for clues on a card.
---@param card Object Card the clues will be placed on
---@param count Integer How many clues?
---@return Table Array of global positions to spawn the clues at
internal.buildClueOffsets = function(card, count)
local pos = card.getPosition()
local cluePositions = { }
for i = 1, count do
local row = math.floor(1 + (i - 1) / 4)
local column = (i - 1) % 4
table.insert(cluePositions, Vector(pos.x + 1.5 - 0.55 * row, pos.y + 0.15, pos.z - 0.825 + 0.55 * column))
end
return cluePositions
2023-04-22 16:56:01 -04:00
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
---@param card Object Card object to be replenished
---@param uses Table The already decoded metadata.uses (to avoid decoding again)
---@param mat Object The playmat the card is placed on (for rotation and casting)
internal.replenishTokens = function(card, uses, mat)
local cardPos = card.getPosition()
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- don't continue for cards on the deck (Norman) or in the discard pile
if mat.positionToLocal(cardPos).x < -1 then return end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- get current amount of resource tokens on the card
local clickableResourceCounter = nil
local foundTokens = 0
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
for _, obj in ipairs(searchLib.onObject(card, "isTileOrToken")) do
local memo = obj.getMemo()
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
if (stateTable[memo] or 0) > 0 then
foundTokens = foundTokens + math.abs(obj.getQuantity())
obj.destruct()
elseif memo == "resourceCounter" then
foundTokens = obj.getVar("val")
clickableResourceCounter = obj
break
end
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- this is the theoretical new amount of uses (to be checked below)
local newCount = foundTokens + uses[1].replenish
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- if there are already more uses than the replenish amount, keep them
if foundTokens > uses[1].count then
newCount = foundTokens
-- only replenish up until the replenish amount
elseif newCount > uses[1].count then
newCount = uses[1].count
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- update the clickable counter or spawn a group of tokens
if clickableResourceCounter then
clickableResourceCounter.call("updateVal", newCount)
2023-01-29 19:31:52 -05:00
else
2024-02-04 10:51:51 -05:00
TokenManager.spawnTokenGroup(card, uses[1].token, newCount, _, uses[1].type)
2023-01-29 19:31:52 -05:00
end
end
2024-02-04 10:51:51 -05:00
return TokenManager
end
end)
__bundle_register("core/token/TokenSpawnTrackerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local TokenSpawnTracker = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
local function getSpawnTracker()
return guidReferenceApi.getObjectByOwnerAndType("Mythos", "TokenSpawnTracker")
end
TokenSpawnTracker.hasSpawnedTokens = function(cardGuid)
return getSpawnTracker().call("hasSpawnedTokens", cardGuid)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
TokenSpawnTracker.markTokensSpawned = function(cardGuid)
return getSpawnTracker().call("markTokensSpawned", cardGuid)
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
TokenSpawnTracker.resetTokensSpawned = function(cardGuid)
return getSpawnTracker().call("resetTokensSpawned", cardGuid)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
TokenSpawnTracker.resetAllAssetAndEvents = function()
return getSpawnTracker().call("resetAllAssetAndEvents")
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
TokenSpawnTracker.resetAllLocations = function()
return getSpawnTracker().call("resetAllLocations")
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
TokenSpawnTracker.resetAll = function()
return getSpawnTracker().call("resetAll")
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
return TokenSpawnTracker
end
end)
__bundle_register("util/SearchLib", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local SearchLib = {}
local filterFunctions = {
isActionToken = function(x) return x.getDescription() == "Action Token" end,
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
}
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- performs the actual search and returns a filtered list of object references
---@param pos Table Global position
---@param rot Table 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)
if filter then filter = 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
})
-- filtering the result
local objList = {}
for _, v in ipairs(searchResult) do
if not filter or filter(v.hit_object) then
table.insert(objList, v.hit_object)
2023-01-29 19:31:52 -05:00
end
end
2024-02-04 10:51:51 -05:00
return objList
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- searches the specified area
SearchLib.inArea = function(pos, rot, size, filter)
return returnSearchResult(pos, rot, size, filter)
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- searches the area on an object
SearchLib.onObject = function(obj, filter)
pos = obj.getPosition()
size = obj.getBounds().size:setAt("y", 1)
return returnSearchResult(pos, _, size, filter)
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
-- searches the specified position (a single point)
SearchLib.atPosition = function(pos, filter)
size = { 0.1, 2, 0.1 }
return returnSearchResult(pos, _, size, filter)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- searches below the specified position (downwards until y = 0)
SearchLib.belowPosition = function(pos, filter)
direction = { 0, -1, 0 }
maxDistance = pos.y
return returnSearchResult(pos, _, size, filter, direction, maxDistance)
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
return SearchLib
end
end)
__bundle_register("core/GUIDReferenceApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local GUIDReferenceApi = {}
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
local function getGuidHandler()
return getObjectFromGUID("123456")
end
-- returns all matching objects as a table with references
---@param owner String Parent object for this search
---@param type String Type of object to search for
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
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
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
2023-01-29 19:31:52 -05:00
})
end
2024-02-04 10:51:51 -05:00
return GUIDReferenceApi
end
end)
__bundle_register("core/OptionPanelApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local OptionPanelApi = {}
-- loads saved options
---@param options Table New options table
OptionPanelApi.loadSettings = function(options)
return Global.call("loadSettings", options)
2023-08-27 21:09:46 -04:00
end
2024-02-04 10:51:51 -05:00
-- returns option panel table
OptionPanelApi.getOptions = function()
return Global.getTable("optionPanel")
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
return OptionPanelApi
end
end)
__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")
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
local function getInvestigatorCounter()
return guidReferenceApi.getObjectByOwnerAndType("Mythos", "InvestigatorCounter")
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- 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 getInvestigatorCounter().getVar("val")
2023-01-29 19:31:52 -05:00
end
2021-02-13 12:12:29 -05:00
2024-02-04 10:51:51 -05:00
-- 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)
getInvestigatorCounter().call("updateVal", count)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- 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 Color of the player requesting the shift for messages
PlayAreaApi.shiftContentsUp = function(playerColor)
return getPlayArea().call("shiftContentsUp", playerColor)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
PlayAreaApi.shiftContentsDown = function(playerColor)
return getPlayArea().call("shiftContentsDown", playerColor)
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
PlayAreaApi.shiftContentsLeft = function(playerColor)
return getPlayArea().call("shiftContentsLeft", playerColor)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
PlayAreaApi.shiftContentsRight = function(playerColor)
return getPlayArea().call("shiftContentsRight", playerColor)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- Reset the play area's tracking of which cards have had tokens spawned.
PlayAreaApi.resetSpawnedCards = function()
return getPlayArea().call("resetSpawnedCards")
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- Sets whether location connections should be drawn
PlayAreaApi.setConnectionDrawState = function(state)
getPlayArea().call("setConnectionDrawState", state)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- Sets the connection color
PlayAreaApi.setConnectionColor = function(color)
getPlayArea().call("setConnectionColor", color)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- Event to be called when the current scenario has changed.
---@param scenarioName Name of the new scenario
PlayAreaApi.onScenarioChanged = function(scenarioName)
getPlayArea().call("onScenarioChanged", scenarioName)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- 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 matchCardTypes Boolean Whether snap points should only snap for the matching card types.
PlayAreaApi.setLimitSnapsByType = function(matchCardTypes)
getPlayArea().call("setLimitSnapsByType", matchCardTypes)
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- 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 })
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- counts the VP on locations in the play area
PlayAreaApi.countVP = function()
return getPlayArea().call("countVP")
end
2023-01-29 19:31:52 -05:00
2024-02-04 10:51:51 -05:00
-- 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)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
-- Checks if an object is in the play area (returns true or false)
PlayAreaApi.isInPlayArea = function(object)
return getPlayArea().call("isInPlayArea", object)
2023-01-29 19:31:52 -05:00
end
2024-02-04 10:51:51 -05:00
PlayAreaApi.getSurface = function()
return getPlayArea().getCustomObject().image
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
PlayAreaApi.updateSurface = function(url)
return getPlayArea().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)
getPlayArea().call("updateLocations", args)
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
PlayAreaApi.getCustomDataHelper = function()
return getPlayArea().getVar("customDataHelper")
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
return PlayAreaApi
end
end)
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("playercards/cards/FamilyInheritance")
end)
__bundle_register("playercards/cards/FamilyInheritance", function(require, _LOADED, __bundle_register, __bundle_modules)
local playmatApi = require("playermat/PlaymatApi")
local searchLib = require("util/SearchLib")
local tokenManager = require("core/token/TokenManager")
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
local clickableResourceCounter = nil
local foundTokens = 0
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
function onLoad()
self.addContextMenuItem("Add 4 resources", function(playerColor) add4(playerColor) end)
self.addContextMenuItem("Take all resources", function(playerColor) takeAll(playerColor) end)
self.addContextMenuItem("Discard all resources", function(playerColor) loseAll(playerColor) end)
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
function searchSelf()
clickableResourceCounter = nil
foundTokens = 0
for _, obj in ipairs(searchLib.onObject(self, "isTileOrToken")) do
local image = obj.getCustomObject().image
if image == "http://cloud-3.steamusercontent.com/ugc/1758068501357192910/11DDDC7EF621320962FDCF3AE3211D5EDC3D1573/" then
foundTokens = foundTokens + math.abs(obj.getQuantity())
obj.destruct()
elseif obj.getMemo() == "resourceCounter" then
foundTokens = obj.getVar("val")
clickableResourceCounter = obj
return
2023-08-27 21:09:46 -04:00
end
2024-02-04 10:51:51 -05:00
end
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
function add4(playerColor)
searchSelf()
local newCount = foundTokens + 4
if clickableResourceCounter then
clickableResourceCounter.call("updateVal", newCount)
else
if newCount > 12 then
printToColor("Count increased to " .. newCount .. " resources. Spawning clickable counter instead.", playerColor)
tokenManager.spawnResourceCounterToken(self, newCount)
2023-08-27 21:09:46 -04:00
else
2024-02-04 10:51:51 -05:00
tokenManager.spawnTokenGroup(self, "resource", newCount)
2023-08-27 21:09:46 -04:00
end
end
2024-02-04 10:51:51 -05:00
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
function takeAll(playerColor)
searchSelf()
local matColor = playmatApi.getMatColorByPosition(self.getPosition())
playmatApi.updateCounter(matColor, "ResourceCounter", _, foundTokens)
if clickableResourceCounter then
clickableResourceCounter.call("updateVal", 0)
2023-08-27 21:09:46 -04:00
end
2024-02-04 10:51:51 -05:00
printToColor("Moved " .. foundTokens .. " resource(s) to " .. matColor .. "'s resource pool.", playerColor)
end
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
function loseAll(playerColor)
searchSelf()
if clickableResourceCounter then
clickableResourceCounter.call("updateVal", 0)
end
printToColor("Discarded " .. foundTokens .. " resource(s).", playerColor)
2023-08-27 21:09:46 -04:00
end
end)
__bundle_register("playermat/PlaymatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
2024-01-06 21:32:29 -05:00
local PlaymatApi = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
2024-02-04 10:51:51 -05:00
local searchLib = require("util/SearchLib")
2023-08-27 21:09:46 -04:00
2024-01-06 21:32:29 -05:00
-- Convenience function to look up a mat's object by color, or get all mats.
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
---@return array Table Single-element if only single playmat is requested
local function getMatForColor(matColor)
if matColor == "All" then
return guidReferenceApi.getObjectsByType("Playermat")
else
return { matColor = guidReferenceApi.getObjectByOwnerAndType(matColor, "Playermat") }
end
end
2023-08-27 21:09:46 -04:00
2024-01-06 21:32:29 -05:00
-- Returns the color of the closest playmat
---@param startPos Table Starting position to get the closest mat from
2023-08-27 21:09:46 -04:00
PlaymatApi.getMatColorByPosition = function(startPos)
2024-01-06 21:32:29 -05:00
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
2023-08-27 21:09:46 -04:00
end
end
2024-01-06 21:32:29 -05:00
return result
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Returns the color of the player's hand that is seated next to the playmat
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
2023-08-27 21:09:46 -04:00
PlaymatApi.getPlayerColor = function(matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("playerColor")
end
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Returns the color of the playmat that owns the playercolor's hand
---@param handColor String Color of the playmat
2023-08-27 21:09:46 -04:00
PlaymatApi.getMatColor = function(handColor)
2024-01-06 21:32:29 -05:00
for matColor, mat in pairs(getMatForColor("All")) do
local playerColor = mat.getVar("playerColor")
if playerColor == handColor then
return matColor
end
2023-08-27 21:09:46 -04:00
end
end
2024-01-06 21:32:29 -05:00
-- Returns if there is the card "Dream-Enhancing Serum" on the requested playmat
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.isDES = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("isDES")
end
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Performs a search of the deck area of the requested playmat and returns the result as table
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.getDeckAreaObjects = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("getDeckAreaObjects")
end
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Flips the top card of the deck (useful after deck manipulation for Norman Withers)
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.flipTopCardFromDeck = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("flipTopCardFromDeck")
end
2023-08-27 21:09:46 -04:00
end
-- Returns the position of the discard pile of the requested playmat
2024-01-06 21:32:29 -05:00
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
2023-08-27 21:09:46 -04:00
PlaymatApi.getDiscardPosition = function(matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("returnGlobalDiscardPosition")
end
2023-08-27 21:09:46 -04:00
end
-- Transforms a local position into a global position
---@param localPos Table Local position to be transformed
2024-01-06 21:32:29 -05:00
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
2023-08-27 21:09:46 -04:00
PlaymatApi.transformLocalPosition = function(localPos, matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
return mat.positionToWorld(localPos)
end
2023-08-27 21:09:46 -04:00
end
-- Returns the rotation of the requested playmat
2024-01-06 21:32:29 -05:00
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
2023-08-27 21:09:46 -04:00
PlaymatApi.returnRotation = function(matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getRotation()
end
2023-08-27 21:09:46 -04:00
end
2024-02-04 10:51:51 -05:00
-- Returns a table with spawn data (position and rotation) for a helper object
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
---@param helperName String Name of the helper object
PlaymatApi.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
2023-08-27 21:09:46 -04:00
-- Triggers the Upkeep for the requested playmat
2024-01-06 21:32:29 -05:00
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
---@param playerColor String Color of the calling player (for messages)
PlaymatApi.doUpkeepFromHotkey = function(matColor, playerColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("doUpkeepFromHotkey", playerColor)
end
end
-- Handles discarding for the requested playmat for the provided list of objects
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
---@param objList Table List of objects to discard
PlaymatApi.discardListOfObjects = function(matColor, objList)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("discardListOfObjects", objList)
end
2023-08-27 21:09:46 -04:00
end
-- Returns the active investigator id
2024-01-06 21:32:29 -05:00
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
2023-08-27 21:09:46 -04:00
PlaymatApi.returnInvestigatorId = function(matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("activeInvestigatorId")
end
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Sets the requested playmat's snap points to limit snapping to matching card types or not. If
2023-08-27 21:09:46 -04:00
-- 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.
2024-01-06 21:32:29 -05:00
---@param matchCardTypes Boolean Whether snap points should only snap for the matching card types
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
PlaymatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
2023-08-27 21:09:46 -04:00
mat.call("setLimitSnapsByType", matchCardTypes)
end
end
2024-01-06 21:32:29 -05:00
-- Sets the requested playmat'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 playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
PlaymatApi.showDrawButton = function(isDrawButtonVisible, matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
2023-08-27 21:09:46 -04:00
mat.call("showDrawButton", isDrawButtonVisible)
end
end
2024-01-06 21:32:29 -05:00
-- Shows or hides the clickable clue counter for the requested playmat
---@param showCounter Boolean Whether the clickable counter should be present or not
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
PlaymatApi.clickableClues = function(showCounter, matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
2023-08-27 21:09:46 -04:00
mat.call("clickableClues", showCounter)
end
end
2024-01-06 21:32:29 -05:00
-- Removes all clues (to the trash for tokens and counters set to 0) for the requested playmat
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
PlaymatApi.removeClues = function(matColor)
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
2023-08-27 21:09:46 -04:00
mat.call("removeClues")
end
end
2024-01-06 21:32:29 -05:00
-- Reports the clue count for the requested playmat
2023-08-27 21:09:46 -04:00
---@param useClickableCounters Boolean Controls which type of counter is getting checked
PlaymatApi.getClueCount = function(useClickableCounters, matColor)
local count = 0
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor(matColor)) do
count = count + mat.call("getClueCount", useClickableCounters)
2023-08-27 21:09:46 -04:00
end
return count
end
2024-01-06 21:32:29 -05:00
-- updates the specified owned counter
---@param matColor String Color of the playmat - 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
PlaymatApi.updateCounter = function(matColor, type, newValue, modifier)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("updateCounter", { type = type, newValue = newValue, modifier = modifier })
2023-08-27 21:09:46 -04:00
end
end
2024-02-04 10:51:51 -05:00
-- triggers the draw function for the specified playmat
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
---@param number Number Amount of cards to draw
PlaymatApi.drawCardsWithReshuffle = function(matColor, number)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("drawCardsWithReshuffle", number)
end
end
2024-01-06 21:32:29 -05:00
-- returns the resource counter amount
---@param matColor String Color of the playmat - White, Orange, Green or Red (does not support "All")
---@param type String Counter to target
PlaymatApi.getCounterValue = function(matColor, type)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("getCounterValue", type)
end
2024-01-06 21:32:07 -05:00
end
2024-02-04 10:51:51 -05:00
-- returns a list of mat colors that have an investigator placed
PlaymatApi.getUsedMatColors = function()
local localInvestigatorPosition = { x = -1.17, y = 1, z = -0.01 }
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
2024-01-06 21:32:29 -05:00
-- resets the specified skill tracker to "1, 1, 1, 1"
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
PlaymatApi.resetSkillTracker = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("resetSkillTracker")
2023-08-27 21:09:46 -04:00
end
end
2024-01-06 21:32:29 -05:00
-- finds all objects on the playmat and associated set aside zone and returns a table
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
2024-02-04 10:51:51 -05:00
---@param filter String Name of the filte function (see util/SearchLib)
2024-01-06 21:32:29 -05:00
PlaymatApi.searchAroundPlaymat = 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
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
return objList
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Discard a non-hidden card from the corresponding player's hand
---@param matColor String Color of the playmat - White, Orange, Green, Red or All
PlaymatApi.doDiscardOne = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("doDiscardOne")
end
2024-01-06 21:32:07 -05:00
end
2024-01-06 21:32:29 -05:00
-- Triggers the metadata sync for all playmats
PlaymatApi.syncAllCustomizableCards = function()
for _, mat in pairs(getMatForColor("All")) do
mat.call("syncAllCustomizableCards")
2023-08-27 21:09:46 -04:00
end
end
2023-01-29 19:31:52 -05:00
2023-08-27 21:09:46 -04:00
return PlaymatApi
2021-02-13 12:12:29 -05:00
end
2023-01-29 19:31:52 -05:00
end)
2022-12-13 14:02:30 -05:00
return __bundle_require("__root")