ah_sce_unpacked/unpacked/Bag All Player Cards 15bb07/CardCustom Grizzled Upgrade Sheet ef8f08.ttslua

946 lines
30 KiB
Plaintext
Raw Normal View History

2023-04-22 16:56:01 -04: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("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("playercards/customizable/GrizzledUpgradeSheet")
end)
__bundle_register("playercards/customizable/GrizzledUpgradeSheet", function(require, _LOADED, __bundle_register, __bundle_modules)
-- Customizable Cards: Grizzled
-- Color information for buttons and input boxes
boxSize = 40
inputFontsize = 50
-- static values
xInitial = -0.933
xOffset = 0.075
customizations = {
[1] = {
textField = {
position = { 0.3, 0.25, -0.91 },
width = 600
}
},
[2] = {
checkboxes = {
posZ = -0.71,
count = 1,
},
textField = {
position = { 0.005, 0.25, -0.58 },
width = 875
}
},
[3] = {
checkboxes = {
posZ = -0.458,
count = 2,
},
textField = {
position = { 0.005, 0.25, -0.32 },
width = 875
}
},
[4] = {
checkboxes = {
posZ = -0.205,
count = 3,
}
},
[5] = {
checkboxes = {
posZ = 0.362,
count = 4,
},
},
[6] = {
checkboxes = {
posZ = 0.82,
count = 5,
},
},
}
require("playercards/customizable/UpgradeSheetLibrary")
end)
2023-08-27 21:09:46 -04:00
__bundle_register("playercards/customizable/UpgradeSheetLibrary", function(require, _LOADED, __bundle_register, __bundle_modules)
-- Common code for handling customizable card upgrade sheets
-- Define UI elements in the base card file, then include this
-- UI element definition is an array of tables, each with this structure. A row may include
-- checkboxes (number defined by count), a text field, both, or neither (if the row has custom
-- handling, as Living Ink does)
-- {
-- checkboxes = {
-- posZ = -0.71,
-- count = 1,
-- },
-- textField = {
-- position = { 0.005, 0.25, -0.58 },
-- width = 875
-- }
-- }
-- Fields should also be defined for xInitial (left edge of the checkboxes) and xOffset (amount to
-- shift X from one box to the next) as well as boxSize (checkboxes) and inputFontSize.
--
-- selectedUpgrades holds the state of checkboxes and text input, each element being:
-- selectedUpgrades[row] = { xp = #, text = "" }
local playmatApi = require("playermat/PlaymatApi")
-- Y position for UI elements. Visibility of checkboxes moves the checkbox inside the card object
-- when not selected.
local Y_VISIBLE = 0.25
local Y_INVISIBLE = -0.5
-- Used for Summoned Servitor and Living Ink
local VECTOR_COLOR = {
unselected = { 0.5, 0.5, 0.5, 0.75 },
mystic = { 0.597, 0.195, 0.796 }
}
-- These match with ArkhamDB's way of storing the data in the dropdown menu
local SUMMONED_SERVITOR_SLOT_INDICES = { arcane = "1", ally = "0", none = "" }
2022-10-19 19:07:47 -04:00
2023-08-27 21:09:46 -04:00
local rowCheckboxFirstIndex = { }
local rowInputIndex = { }
local selectedUpgrades = { }
2022-10-19 19:07:47 -04:00
-- save state when going into bags / decks
function onDestroy() self.script_state = onSave() end
2023-08-27 21:09:46 -04:00
function onSave()
return JSON.encode({
selections = selectedUpgrades
})
end
2022-10-19 19:07:47 -04:00
-- Startup procedure
2023-08-27 21:09:46 -04:00
function onLoad(savedData)
if savedData ~= "" then
local loadedData = JSON.decode(savedData)
if loadedData.selections ~= nil then
selectedUpgrades = loadedData.selections
end
end
selfId = getSelfId()
2022-10-19 19:07:47 -04:00
2023-08-27 21:09:46 -04:00
maybeLoadLivingInkSkills()
createUi()
maybeUpdateLivingInkSkillDisplay()
maybeUpdateServitorSlotDisplay()
self.addContextMenuItem("Clear Selections", function() resetSelections() end)
self.addContextMenuItem("Scale: 1x", function() self.setScale({ 1, 1, 1 }) end)
self.addContextMenuItem("Scale: 2x", function() self.setScale({ 2, 1, 2 }) end)
self.addContextMenuItem("Scale: 3x", function() self.setScale({ 3, 1, 3 }) end)
end
-- Grabs the ID from the metadata for special functions (Living Ink, Summoned Servitor)
function getSelfId()
local metadata = JSON.decode(self.getGMNotes())
return metadata.id
end
function isUpgradeActive(row)
return customizations[row] ~= nil
and customizations[row].checkboxes ~= nil
and customizations[row].checkboxes.count ~= nil
and customizations[row].checkboxes.count > 0
and selectedUpgrades[row] ~= nil
and selectedUpgrades[row].xp ~= nil
and selectedUpgrades[row].xp >= customizations[row].checkboxes.count
end
function resetSelections()
selectedUpgrades = { }
updateDisplay()
end
function createUi()
if customizations == nil then
return
end
for i = 1, #customizations do
if customizations[i].checkboxes ~= nil then
createRowCheckboxes(i)
end
if customizations[i].textField ~= nil then
createRowTextField(i)
2022-10-19 19:07:47 -04:00
end
2023-08-27 21:09:46 -04:00
end
maybeMakeLivingInkSkillSelectionButtons()
maybeMakeServitorSlotSelectionButtons()
updateDisplay()
end
function createRowCheckboxes(rowIndex)
local checkboxes = customizations[rowIndex].checkboxes
rowCheckboxFirstIndex[rowIndex] = 0
local previousButtons = self.getButtons()
if previousButtons ~= nil then
rowCheckboxFirstIndex[rowIndex] = #previousButtons
end
for col = 1, checkboxes.count do
local funcName = "checkboxRow" .. rowIndex .. "Col" .. col
local func = function() clickCheckbox(rowIndex, col) end
self.setVar(funcName, func)
local checkboxPos = getCheckboxPosition(rowIndex, col)
self.createButton({
click_function = funcName,
function_owner = self,
position = checkboxPos,
height = boxSize * 10,
width = boxSize * 10,
font_size = 1000,
scale = { 0.1, 0.1, 0.1 },
color = { 0, 0, 0 },
font_color = { 0, 0, 0 }
})
end
end
function getCheckboxPosition(row, col)
return {
x = xInitial + col * xOffset,
y = Y_VISIBLE,
z = customizations[row].checkboxes.posZ
}
end
function createRowTextField(rowIndex)
local textField = customizations[rowIndex].textField
rowInputIndex[rowIndex] = 0
local previousInputs = self.getInputs()
if previousInputs ~= nil then
rowInputIndex[rowIndex] = #previousInputs
end
local funcName = "textbox" .. rowIndex
local func = function(_, _, val, sel) clickTextbox(rowIndex, val, sel) end
self.setVar(funcName, func)
self.createInput({
input_function = funcName,
function_owner = self,
label = "Click to type",
alignment = 2,
position = textField.position,
scale = { 0.1, 0.1, 0.1 },
width = textField.width * 10,
height = inputFontsize * 10 + 75,
font_size = inputFontsize * 10.5,
color = "White",
value = ""
})
end
function updateDisplay()
for i = 1, #customizations do
updateRowDisplay(i)
end
maybeUpdateLivingInkSkillDisplay()
maybeUpdateServitorSlotDisplay()
end
2022-10-19 19:07:47 -04:00
2023-08-27 21:09:46 -04:00
function updateRowDisplay(rowIndex)
if customizations[rowIndex].checkboxes ~= nil then
updateCheckboxes(rowIndex)
end
if customizations[rowIndex].textField ~= nil then
updateTextField(rowIndex)
end
end
function updateCheckboxes(rowIndex)
local checkboxCount = customizations[rowIndex].checkboxes.count
local selected = 0
if selectedUpgrades[rowIndex] ~= nil and selectedUpgrades[rowIndex].xp ~= nil then
selected = selectedUpgrades[rowIndex].xp
end
local checkboxIndex = rowCheckboxFirstIndex[rowIndex]
for col = 1, checkboxCount do
local pos = getCheckboxPosition(rowIndex, col)
if col <= selected then
pos.y = Y_VISIBLE
else
pos.y = Y_INVISIBLE
end
2022-10-19 19:07:47 -04:00
self.editButton({
2023-08-27 21:09:46 -04:00
index = checkboxIndex,
position = pos
})
checkboxIndex = checkboxIndex + 1
end
end
function updateTextField(rowIndex)
local inputIndex = rowInputIndex[rowIndex]
if selectedUpgrades[rowIndex] ~= nil and selectedUpgrades[rowIndex].text ~= nil then
self.editInput({
index = inputIndex,
value = " " .. selectedUpgrades[rowIndex].text
2022-10-19 19:07:47 -04:00
})
2023-08-27 21:09:46 -04:00
end
2022-10-19 19:07:47 -04:00
end
2024-02-17 19:48:30 -05:00
function clickCheckbox(row, col)
2023-08-27 21:09:46 -04:00
if selectedUpgrades[row] == nil then
selectedUpgrades[row] = { }
selectedUpgrades[row].xp = 0
end
if selectedUpgrades[row].xp == col then
selectedUpgrades[row].xp = col - 1
else
selectedUpgrades[row].xp = col
end
updateCheckboxes(row)
playmatApi.syncAllCustomizableCards()
end
-- Updates saved value for given text box when it loses focus
function clickTextbox(rowIndex, value, selected)
if selected == false then
if selectedUpgrades[rowIndex] == nil then
selectedUpgrades[rowIndex] = { }
2022-10-19 19:07:47 -04:00
end
2023-08-27 21:09:46 -04:00
selectedUpgrades[rowIndex].text = value:gsub("^%s*(.-)%s*$", "%1")
-- Editing isn't actually done yet, and will block the update. Wait a frame so it's finished
Wait.frames(function() updateRowDisplay(rowIndex) end, 1)
end
end
---------------------------------------------------------
-- Living Ink related functions
---------------------------------------------------------
-- Builds the list of boolean skill selections from the Row 1 text field
function maybeLoadLivingInkSkills()
if selfId ~= "09079-c" then return end
selectedSkills = {
willpower = false,
intellect = false,
combat = false,
agility = false
}
if selectedUpgrades[1] ~= nil and selectedUpgrades[1].text ~= nil then
for skill in string.gmatch(selectedUpgrades[1].text, "([^,]+)") do
selectedSkills[skill] = true
end
end
end
function clickSkill(skillname)
selectedSkills[skillname] = not selectedSkills[skillname]
maybeUpdateLivingInkSkillDisplay()
updateSelectedLivingInkSkillText()
end
-- Creates the invisible buttons overlaying the skill icons
function maybeMakeLivingInkSkillSelectionButtons()
if selfId ~= "09079-c" then return end
local buttonData = {
function_owner = self,
position = { y = 0.2 },
height = 130,
width = 130,
color = { 0, 0, 0, 0 },
}
for skillname, _ in pairs(selectedSkills) do
local funcName = "clickSkill" .. skillname
self.setVar(funcName, function() clickSkill(skillname) end)
buttonData.click_function = funcName
buttonData.position.x = -1 * SKILL_ICON_POSITIONS[skillname].x
buttonData.position.z = SKILL_ICON_POSITIONS[skillname].z
self.createButton(buttonData)
end
end
-- Builds a comma-delimited string of skills and places it in the Row 1 text field
function updateSelectedLivingInkSkillText()
local skillString = ""
if selectedSkills.willpower then
skillString = skillString .. "willpower" .. ","
end
if selectedSkills.intellect then
skillString = skillString .. "intellect" .. ","
end
if selectedSkills.combat then
skillString = skillString .. "combat" .. ","
end
if selectedSkills.agility then
skillString = skillString .. "agility" .. ","
end
if selectedUpgrades[1] == nil then
selectedUpgrades[1] = { }
end
selectedUpgrades[1].text = skillString
end
-- Refresh the vector circles indicating a skill is selected. Since we can only have one table of
-- vectors set, have to refresh all 4 at once
function maybeUpdateLivingInkSkillDisplay()
if selfId ~= "09079-c" then return end
local circles = {}
for skill, isSelected in pairs(selectedSkills) do
if isSelected then
local circle = getCircleVector(SKILL_ICON_POSITIONS[skill])
if circle ~= nil then
table.insert(circles, circle)
end
end
end
self.setVectorLines(circles)
end
function getCircleVector(center)
local diameter = Vector(0, 0, 0.1)
local pointOfOrigin = Vector(center.x, Y_VISIBLE, center.z)
local vec
local vecList = {}
local arcStep = 5
for i = 0, 360, arcStep do
diameter:rotateOver('y', arcStep)
vec = pointOfOrigin + diameter
vec.y = pointOfOrigin.y
table.insert(vecList, vec)
end
return {
points = vecList,
color = VECTOR_COLOR.mystic,
thickness = 0.02,
}
end
---------------------------------------------------------
-- Summoned Servitor related functions
---------------------------------------------------------
-- Creates the invisible buttons overlaying the slot words
function maybeMakeServitorSlotSelectionButtons()
if selfId ~= "09080-c" then return end
local buttonData = {
click_function = "clickArcane",
function_owner = self,
position = { x = -1 * SLOT_ICON_POSITIONS.arcane.x, y = 0.2, z = SLOT_ICON_POSITIONS.arcane.z },
height = 130,
width = 130,
color = { 0, 0, 0, 0 },
}
self.createButton(buttonData)
buttonData.click_function = "clickAlly"
buttonData.position.x = -1 * SLOT_ICON_POSITIONS.ally.x
self.createButton(buttonData)
end
-- toggles the clicked slot
function clickArcane()
if selectedUpgrades[6] == nil then
selectedUpgrades[6] = { }
end
if selectedUpgrades[6].text == SUMMONED_SERVITOR_SLOT_INDICES.arcane then
selectedUpgrades[6].text = SUMMONED_SERVITOR_SLOT_INDICES.none
else
selectedUpgrades[6].text = SUMMONED_SERVITOR_SLOT_INDICES.arcane
end
maybeUpdateServitorSlotDisplay()
end
-- toggles the clicked slot
function clickAlly()
if selectedUpgrades[6] == nil then
selectedUpgrades[6] = { }
end
if selectedUpgrades[6].text == SUMMONED_SERVITOR_SLOT_INDICES.ally then
selectedUpgrades[6].text = SUMMONED_SERVITOR_SLOT_INDICES.none
else
selectedUpgrades[6].text = SUMMONED_SERVITOR_SLOT_INDICES.ally
end
maybeUpdateServitorSlotDisplay()
end
-- Refresh the vector circles indicating a slot is selected.
function maybeUpdateServitorSlotDisplay()
if selfId ~= "09080-c" then return end
local center = SLOT_ICON_POSITIONS["arcane"]
local arcaneVecList = {
Vector(center.x + 0.12, Y_VISIBLE, center.z + 0.05),
Vector(center.x - 0.12, Y_VISIBLE, center.z + 0.05),
Vector(center.x - 0.12, Y_VISIBLE, center.z - 0.05),
Vector(center.x + 0.12, Y_VISIBLE, center.z - 0.05),
Vector(center.x + 0.12, Y_VISIBLE, center.z + 0.05),
}
center = SLOT_ICON_POSITIONS["ally"]
local allyVecList = {
Vector(center.x + 0.07, Y_VISIBLE, center.z + 0.05),
Vector(center.x - 0.07, Y_VISIBLE, center.z + 0.05),
Vector(center.x - 0.07, Y_VISIBLE, center.z - 0.05),
Vector(center.x + 0.07, Y_VISIBLE, center.z - 0.05),
Vector(center.x + 0.07, Y_VISIBLE, center.z + 0.05),
}
local arcaneVecColor = VECTOR_COLOR.unselected
local allyVecColor = VECTOR_COLOR.unselected
if selectedUpgrades[6] ~= nil and selectedUpgrades[6].text == SUMMONED_SERVITOR_SLOT_INDICES.arcane then
arcaneVecColor = VECTOR_COLOR.mystic
elseif selectedUpgrades[6] ~= nil and selectedUpgrades[6].text == SUMMONED_SERVITOR_SLOT_INDICES.ally then
allyVecColor = VECTOR_COLOR.mystic
end
self.setVectorLines({
{
points = arcaneVecList,
color = arcaneVecColor,
thickness = 0.02,
},
{
points = allyVecList,
color = allyVecColor,
thickness = 0.02,
}
})
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.
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@return table: Single-element if only single playmat is requested
2024-01-06 21:32:29 -05:00
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
2024-02-17 19:48:30 -05:00
---@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
2024-02-17 19:48:30 -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.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
2024-02-17 19:48:30 -05:00
---@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
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
2024-01-06 21:32:29 -05:00
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
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
2024-01-06 21:32:29 -05:00
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)
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
2024-01-06 21:32:29 -05:00
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-02-17 19:48:30 -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
2024-02-17 19:48:30 -05:00
---@param localPos table Local position to be transformed
---@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-02-17 19:48:30 -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
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@param helperName string Name of the helper object
2024-02-04 10:51:51 -05:00
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-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@param playerColor string Color of the calling player (for messages)
2023-08-27 21:09:46 -04:00
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
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
---@param objList table List of objects to discard
2024-01-06 21:32:29 -05:00
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-02-17 19:48:30 -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-02-17 19:48:30 -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
2024-02-17 19:48:30 -05:00
---@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
2024-02-17 19:48:30 -05:00
---@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
2024-02-17 19:48:30 -05:00
---@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
2024-02-17 19:48:30 -05:00
---@param useClickableCounters boolean Controls which type of counter is getting checked
2023-08-27 21:09:46 -04:00
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
2024-02-17 19:48:30 -05:00
---@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
2024-01-06 21:32:29 -05:00
PlaymatApi.updateCounter = function(matColor, type, newValue, modifier)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("updateCounter", { type = type, newValue = newValue, modifier = modifier })
end
end
2024-02-04 10:51:51 -05:00
-- triggers the draw function for the specified playmat
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@param number number Amount of cards to draw
2024-02-04 10:51:51 -05:00
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
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
---@param type string Counter to target
2024-01-06 21:32:29 -05:00
PlaymatApi.getCounterValue = function(matColor, type)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("getCounterValue", type)
2023-08-27 21:09:46 -04:00
end
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"
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
2024-01-06 21:32:29 -05:00
PlaymatApi.resetSkillTracker = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("resetSkillTracker")
end
end
-- finds all objects on the playmat and associated set aside zone and returns a table
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@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
end
return objList
2024-01-06 21:32:07 -05:00
end
2023-08-27 21:09:46 -04:00
-- Discard a non-hidden card from the corresponding player's hand
2024-02-17 19:48:30 -05:00
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
2023-08-27 21:09:46 -04:00
PlaymatApi.doDiscardOne = 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("doDiscardOne")
end
end
2024-01-06 21:32:29 -05:00
-- Triggers the metadata sync for all playmats
2023-08-27 21:09:46 -04:00
PlaymatApi.syncAllCustomizableCards = function()
2024-01-06 21:32:29 -05:00
for _, mat in pairs(getMatForColor("All")) do
2023-08-27 21:09:46 -04:00
mat.call("syncAllCustomizableCards")
end
end
2024-01-06 21:32:29 -05:00
return PlaymatApi
end
end)
__bundle_register("core/GUIDReferenceApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local GUIDReferenceApi = {}
local function getGuidHandler()
return getObjectFromGUID("123456")
end
2024-02-17 19:48:30 -05:00
---@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
2024-01-06 21:32:29 -05:00
GUIDReferenceApi.getObjectByOwnerAndType = function(owner, type)
return getGuidHandler().call("getObjectByOwnerAndType", { owner = owner, type = type })
2024-01-06 21:32:07 -05:00
end
2024-01-06 21:32:29 -05:00
-- returns all matching objects as a table with references
2024-02-17 19:48:30 -05:00
---@param type string Type of object to search for
---@return table: List of object references to matching objects
2024-01-06 21:32:29 -05:00
GUIDReferenceApi.getObjectsByType = function(type)
return getGuidHandler().call("getObjectsByType", type)
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- returns all matching objects as a table with references
2024-02-17 19:48:30 -05:00
---@param owner string Parent object for this search
---@return table: List of object references to matching objects
2024-01-06 21:32:29 -05:00
GUIDReferenceApi.getObjectsByOwner = function(owner)
return getGuidHandler().call("getObjectsByOwner", owner)
end
2024-02-04 10:51:51 -05:00
-- sends new information to the reference handler to edit the main index
2024-02-17 19:48:30 -05:00
---@param owner string Parent of the object
---@param type string Type of the object
---@param guid string GUID of the object
2024-02-04 10:51:51 -05:00
GUIDReferenceApi.editIndex = function(owner, type, guid)
return getGuidHandler().call("editIndex", {
owner = owner,
type = type,
guid = guid
})
end
2024-01-06 21:32:29 -05:00
return GUIDReferenceApi
2023-04-22 16:56:01 -04:00
end
end)
2024-02-04 10:51:51 -05:00
__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
2024-02-17 19:48:30 -05:00
---@param pos tts__Vector Global position
---@param rot? tts__Vector Global rotation
---@param size table Size
---@param filter? string Name of the filter function
---@param direction? table Direction (positive is up)
---@param maxDistance? number Distance for the cast
2024-02-04 10:51:51 -05:00
local function returnSearchResult(pos, rot, size, filter, direction, maxDistance)
2024-02-17 19:48:30 -05:00
local filterFunc
if filter then
filterFunc = filterFunctions[filter]
end
2024-02-04 10:51:51 -05:00
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
})
2024-01-06 21:32:29 -05:00
2024-02-04 10:51:51 -05:00
-- filtering the result
local objList = {}
for _, v in ipairs(searchResult) do
2024-02-17 19:48:30 -05:00
if not filter or filterFunc(v.hit_object) then
2024-02-04 10:51:51 -05:00
table.insert(objList, v.hit_object)
end
end
return objList
end
2024-01-06 21:32:29 -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
-- 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
-- searches the specified position (a single point)
SearchLib.atPosition = function(pos, filter)
size = { 0.1, 2, 0.1 }
return returnSearchResult(pos, _, size, filter)
end
-- searches below the specified position (downwards until y = 0)
SearchLib.belowPosition = function(pos, filter)
direction = { 0, -1, 0 }
maxDistance = pos.y
return returnSearchResult(pos, _, size, filter, direction, maxDistance)
end
return SearchLib
end
2024-01-06 21:32:29 -05:00
end)
2023-04-22 16:56:01 -04:00
return __bundle_require("__root")