ah_sce_unpacked/unpacked/go_game_piece_white Game Key Handler fce69c.ttslua

1068 lines
38 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)
2023-08-27 21:09:46 -04:00
__bundle_register("core/GameKeyHandler", function(require, _LOADED, __bundle_register, __bundle_modules)
local blessCurseManagerApi = require("chaosbag/BlessCurseManagerApi")
2024-01-06 21:32:29 -05:00
local guidReferenceApi = require("core/GUIDReferenceApi")
2024-02-04 10:51:51 -05:00
local navigationOverlayApi = require("core/NavigationOverlayApi")
2024-01-06 21:32:07 -05:00
local optionPanelApi = require("core/OptionPanelApi")
2023-08-27 21:09:46 -04:00
local playmatApi = require("playermat/PlaymatApi")
2024-02-04 10:51:51 -05:00
local searchLib = require("util/SearchLib")
2023-08-27 21:09:46 -04:00
local victoryDisplayApi = require("core/VictoryDisplayApi")
function onLoad()
2024-02-04 10:51:51 -05:00
addHotkey("Add doom to agenda", addDoomToAgenda)
addHotkey("Add Bless/Curse context menu", addBlurseSealingMenu)
addHotkey("Discard object", discardObject)
addHotkey("Discard top card", discardTopDeck)
addHotkey("Display Bless/Curse status", showBlessCurseStatus)
2023-08-27 21:09:46 -04:00
addHotkey("Move card to Victory Display", moveCardToVictoryDisplay)
2024-06-09 10:10:21 -04:00
addHotkey("Place card into threat area", takeCardIntoThreatArea)
2024-01-06 21:32:29 -05:00
addHotkey("Remove a use", removeOneUse)
2024-02-04 10:51:51 -05:00
addHotkey("Switch seat clockwise", switchSeatClockwise)
addHotkey("Switch seat counter-clockwise", switchSeatCounterClockwise)
2023-08-27 21:09:46 -04:00
addHotkey("Take clue from location", takeClueFromLocation)
2024-03-10 09:56:22 -04:00
addHotkey("Take clue from location (White)", takeClueFromLocationWhite)
addHotkey("Take clue from location (Orange)", takeClueFromLocationOrange)
addHotkey("Take clue from location (Green)", takeClueFromLocationGreen)
addHotkey("Take clue from location (Red)", takeClueFromLocationRed)
2023-08-27 21:09:46 -04:00
addHotkey("Upkeep", triggerUpkeep)
addHotkey("Upkeep (Multi-handed)", triggerUpkeepMultihanded)
end
-- triggers the "Upkeep" function of the calling player's playmat
function triggerUpkeep(playerColor)
if playerColor == "Black" then
broadcastToColor("Triggering 'Upkeep (Multihanded)' instead", playerColor, "Yellow")
triggerUpkeepMultihanded(playerColor)
return
end
local matColor = playmatApi.getMatColor(playerColor)
playmatApi.doUpkeepFromHotkey(matColor, playerColor)
end
-- triggers the "Upkeep" function of the calling player's playmat AND
2024-06-09 10:10:21 -04:00
-- for all playmats that don't have a seated player, but an investigator card
2023-08-27 21:09:46 -04:00
function triggerUpkeepMultihanded(playerColor)
if playerColor ~= "Black" then
triggerUpkeep(playerColor)
end
local colors = Player.getAvailableColors()
for _, handColor in ipairs(colors) do
local matColor = playmatApi.getMatColor(handColor)
if playmatApi.returnInvestigatorId(matColor) ~= "00000" and Player[handColor].seated == false then
playmatApi.doUpkeepFromHotkey(matColor, playerColor)
end
end
end
-- adds 1 doom to the agenda
function addDoomToAgenda()
2024-01-06 21:32:29 -05:00
local doomCounter = guidReferenceApi.getObjectByOwnerAndType("Mythos", "DoomCounter")
doomCounter.call("addVal", 1)
end
2024-06-09 10:10:21 -04:00
-- move the hovered object to the nearest empty slot on the playermat
function takeCardIntoThreatArea(playerColor, hoveredObject)
-- only continue if an unlocked card
if hoveredObject == nil
or hoveredObject.type ~= "Card" and hoveredObject.type ~= "Deck"
or hoveredObject.hasTag("Location")
or hoveredObject.locked then
broadcastToColor("Hover a non-location card and try again.", playerColor, "Yellow")
return
end
local matColor = playmatApi.getMatColor(playerColor)
local mat = guidReferenceApi.getObjectByOwnerAndType(matColor, "Playermat")
-- do not continue if the threat area is already full
if playmatApi.getEncounterCardDrawPosition(matColor, false) == playmatApi.getEncounterCardDrawPosition(matColor, true) then
broadcastToColor("Threat area is full.", playerColor,"Yellow")
return
end
-- initialize list of objects to move
local moveTheseObjects = {}
for _, obj in ipairs(searchLib.onObject(hoveredObject, "isTileOrToken")) do
table.insert(moveTheseObjects, obj)
end
-- find out if the original card is on the green or red playmats
local originalMatColor = guidReferenceApi.getOwnerOfObject(hoveredObject)
-- determine modifiers for the playmats
local modifierY
if originalMatColor == "Red" then
modifierY = 90
elseif originalMatColor == "Green" then
modifierY = -90
else
modifierY = 0
end
local localPositions = {}
for i, obj in ipairs(moveTheseObjects) do
local localPos = hoveredObject.positionToLocal(obj.getPosition())
localPositions[i] = localPos
end
-- move the main card
local pos = playmatApi.getEncounterCardDrawPosition(matColor, false)
hoveredObject.setPosition(pos)
hoveredObject.setRotation(hoveredObject.getRotation() - Vector(0, 270-mat.getRotation().y-modifierY, 0))
local cardName = hoveredObject.getName()
if cardName == nil or cardName == "" then
cardName = "card(s)"
end
broadcastToAll("Placed " .. cardName .. " into threat area.", "White")
for i, obj in ipairs(moveTheseObjects) do
if not obj.locked then
local globalPos = hoveredObject.positionToWorld(localPositions[i])
obj.setPosition(globalPos)
obj.setRotation(obj.getRotation() - Vector(0, 270-mat.getRotation().y-modifierY, 0))
end
end
end
2024-01-06 21:32:29 -05:00
-- discard the hovered object to the respective trashcan and discard tokens on it if it was a card
function discardObject(playerColor, hoveredObject)
-- only continue if an unlocked card, deck or tile was hovered
if hoveredObject == nil
or (hoveredObject.type ~= "Card" and hoveredObject.type ~= "Deck" and hoveredObject.type ~= "Tile")
or hoveredObject.locked then
broadcastToColor("Hover a token/tile or a card/deck and try again.", playerColor, "Yellow")
return
end
-- warning for locations since these are usually not meant to be discarded
if hoveredObject.hasTag("Location") then
broadcastToAll("Watch out: A location was discarded.", "Yellow")
end
-- initialize list of objects to discard
local discardTheseObjects = { hoveredObject }
-- discard tokens / tiles on cards / decks
if hoveredObject.type ~= "Tile" then
2024-02-04 10:51:51 -05:00
for _, obj in ipairs(searchLib.onObject(hoveredObject, "isTileOrToken")) do
table.insert(discardTheseObjects, obj)
2024-01-06 21:32:29 -05:00
end
end
local discardForMatColor = getColorToDiscardFor(hoveredObject, playerColor)
playmatApi.discardListOfObjects(discardForMatColor, discardTheseObjects)
end
2024-02-04 10:51:51 -05:00
-- discard the top card of hovered deck, calling discardObject function
function discardTopDeck(playerColor, hoveredObject)
-- only continue if an unlocked card or deck was hovered
if hoveredObject == nil
or (hoveredObject.type ~= "Card" and hoveredObject.type ~= "Deck")
or hoveredObject.locked then
broadcastToColor("Hover a deck/card and try again.", playerColor, "Yellow")
return
end
if hoveredObject.type == "Deck" then
takenCard = hoveredObject.takeObject({index = 0})
else
takenCard = hoveredObject
end
Wait.frames(function() discardObject(playerColor, takenCard) end, 1)
end
2024-01-06 21:32:29 -05:00
-- helper function to get the player to trigger the discard function for
function getColorToDiscardFor(hoveredObject, playerColor)
local pos = hoveredObject.getPosition()
local closestMatColor = playmatApi.getMatColorByPosition(pos)
-- check if actually on the closest playmat
local closestMat = guidReferenceApi.getObjectByOwnerAndType(closestMatColor, "Playermat")
local bounds = closestMat.getBounds()
-- define the area "near" the playmat
local bufferAroundPlaymat = 2
local areaNearPlaymat = {}
areaNearPlaymat.minX = bounds.center.x - bounds.size.x / 2 - bufferAroundPlaymat
areaNearPlaymat.maxX = bounds.center.x + bounds.size.x / 2 + bufferAroundPlaymat
areaNearPlaymat.minZ = bounds.center.z - bounds.size.z / 2 - bufferAroundPlaymat
areaNearPlaymat.maxZ = bounds.center.z + bounds.size.z / 2 + bufferAroundPlaymat
-- discard to closest mat if near it, use triggering playmat if not
local discardForMatColor
if inArea(pos, areaNearPlaymat) then
return closestMatColor
2024-02-17 19:48:30 -05:00
elseif pos.y > (Player[playerColor].getHandTransform().position.y - (Player[playerColor].getHandTransform().scale.y / 2)) then -- discard to closest mat if card is in a hand
return closestMatColor
2024-01-06 21:32:29 -05:00
else
return playmatApi.getMatColor(playerColor)
end
2023-08-27 21:09:46 -04:00
end
-- moves the hovered card to the victory display
function moveCardToVictoryDisplay(_, hoveredObject)
victoryDisplayApi.placeCard(hoveredObject)
end
2024-01-06 21:32:29 -05:00
-- removes a use from a card (or a token if hovered)
function removeOneUse(playerColor, hoveredObject)
-- only continue if an unlocked card or tile was hovered
if hoveredObject == nil
or (hoveredObject.type ~= "Card" and hoveredObject.type ~= "Tile")
or hoveredObject.locked then
broadcastToColor("Hover a token/tile or a card and try again.", playerColor, "Yellow")
return
end
local targetObject = nil
-- discard hovered token / tile
if hoveredObject.type == "Tile" then
targetObject = hoveredObject
elseif hoveredObject.type == "Card" then
-- grab the first use type from the metadata (or nil)
local notes = JSON.decode(hoveredObject.getGMNotes()) or {}
local usesData = notes.uses or {}
local useInfo = usesData[1] or {}
local searchForType = useInfo.type
if searchForType then searchForType = searchForType:lower() end
2024-02-04 10:51:51 -05:00
for _, obj in ipairs(searchLib.onObject(hoveredObject, "isTileOrToken")) do
if not obj.locked and obj.memo ~= "resourceCounter" then
2024-01-06 21:32:29 -05:00
-- check for matching object, otherwise use the first hit
if obj.memo == searchForType then
targetObject = obj
break
elseif not targetObject then
targetObject = obj
end
end
end
end
-- error handling
if not targetObject then
broadcastToColor("No tokens found!", playerColor, "Yellow")
return
end
-- handling for stacked tokens
if targetObject.getQuantity() > 1 then
targetObject = targetObject.takeObject()
end
-- feedback message
local tokenName = targetObject.getName()
if tokenName == "" then
if targetObject.memo ~= "" then
-- name handling for clue / doom
if targetObject.memo == "clueDoom" then
if targetObject.is_face_down then
tokenName = "Doom"
else
tokenName = "Clue"
end
else
tokenName = titleCase(targetObject.memo)
end
else
tokenName = "Unknown"
end
end
local playerName = Player[playerColor].steam_name
broadcastToAll(playerName .. " removed a token: " .. tokenName, playerColor)
local discardForMatColor = getColorToDiscardFor(hoveredObject, playerColor)
playmatApi.discardListOfObjects(discardForMatColor, { targetObject })
end
2024-02-04 10:51:51 -05:00
-- switches the triggering player to the next seat (clockwise)
function switchSeatClockwise(playerColor)
switchSeat(playerColor, "clockwise")
end
-- switches the triggering player to the next seat (counter-clockwise)
function switchSeatCounterClockwise(playerColor)
switchSeat(playerColor, "counter-clockwise")
end
-- handles seat switching in the given direction
function switchSeat(playerColor, direction)
if playerColor == "Black" or playerColor == "Grey" then
broadcastToColor("This hotkey is only available to seated players.", playerColor, "Orange")
return
end
-- sort function for matcolors based on hand position (Green, White, Orange, Red)
local function sortByHandPosition(color1, color2)
local pos1 = Player[color1].getHandTransform().position
local pos2 = Player[color2].getHandTransform().position
return pos1.z > pos2.z
end
-- get used playermats
local usedColors = playmatApi.getUsedMatColors()
table.sort(usedColors, sortByHandPosition)
-- get current seat index
local index
for i, color in ipairs(usedColors) do
if color == playerColor then
index = i
break
end
end
if not index then
broadcastToColor("Couldn't detect investigator.", playerColor, "Orange")
return
end
-- get next color
index = index + ((direction == "clockwise") and -1 or 1)
if index == 0 then
index = #usedColors
elseif index > #usedColors then
index = 1
end
-- swap color
navigationOverlayApi.loadCamera(Player[playerColor], usedColors[index])
end
2024-03-10 09:56:22 -04:00
function takeClueFromLocationWhite(_, hoveredObject)
takeClueFromLocation("White", hoveredObject)
end
function takeClueFromLocationOrange(_, hoveredObject)
takeClueFromLocation("Orange", hoveredObject)
end
function takeClueFromLocationGreen(_, hoveredObject)
takeClueFromLocation("Green", hoveredObject)
end
function takeClueFromLocationRed(_, hoveredObject)
takeClueFromLocation("Red", hoveredObject)
end
2023-08-27 21:09:46 -04:00
-- takes a clue from a location, player needs to hover the clue directly or the location
function takeClueFromLocation(playerColor, hoveredObject)
2024-06-09 10:10:21 -04:00
-- use different color for messages if player is not seated (because this hotkey is called for a different mat)
local messageColor = playerColor
if not Player[playerColor] or not Player[playerColor].seated then
messageColor = getFirstSeatedPlayer()
end
2023-08-27 21:09:46 -04:00
local cardName, clue
if hoveredObject == nil then
2024-06-09 10:10:21 -04:00
broadcastToColor("Hover a clue or card with clues and try again.", messageColor, "Yellow")
2023-08-27 21:09:46 -04:00
return
2024-01-06 21:32:29 -05:00
elseif hoveredObject.type == "Card" then
2023-08-27 21:09:46 -04:00
cardName = hoveredObject.getName()
2024-02-04 10:51:51 -05:00
local searchResult = searchLib.onObject(hoveredObject, "isClue")
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
if #searchResult == 0 then
2024-06-09 10:10:21 -04:00
broadcastToColor("This card does not have any clues on it.", messageColor, "Yellow")
2023-08-27 21:09:46 -04:00
return
2024-02-04 10:51:51 -05:00
else
clue = searchResult[1]
2023-08-27 21:09:46 -04:00
end
elseif hoveredObject.memo == "clueDoom" then
if hoveredObject.is_face_down then
2024-06-09 10:10:21 -04:00
broadcastToColor("This is a doom token and not a clue.", messageColor, "Yellow")
2023-08-27 21:09:46 -04:00
return
end
clue = hoveredObject
2024-02-04 10:51:51 -05:00
local searchResult = searchLib.belowPosition(clue.getPosition(), "isCard")
2023-08-27 21:09:46 -04:00
2024-02-04 10:51:51 -05:00
if #searchResult ~= 0 then
cardName = searchResult[1].getName()
2023-08-27 21:09:46 -04:00
end
2024-03-10 09:56:22 -04:00
elseif hoveredObject.type == "Infinite" and hoveredObject.getName() == "Clue tokens" then
clue = hoveredObject.takeObject()
cardName = "token pool"
2023-08-27 21:09:46 -04:00
else
2024-06-09 10:10:21 -04:00
broadcastToColor("Hover a clue or card with clues and try again.", messageColor, "Yellow")
2023-08-27 21:09:46 -04:00
return
end
2024-01-06 21:32:07 -05:00
local clickableClues = optionPanelApi.getOptions()["useClueClickers"]
2024-06-09 10:10:21 -04:00
-- handling for calling this for a specific mat via hotkey
local playerName, matColor, pos
if Player[playerColor] and Player[playerColor].seated then
playerName = Player[playerColor].steam_name
matColor = playmatApi.getMatColor(playerColor)
else
playerName = playerColor
matColor = playerColor
end
2024-01-06 21:32:07 -05:00
if clickableClues then
pos = {x = 0.49, y = 2.66, z = 0.00}
2024-01-06 21:32:29 -05:00
playmatApi.updateCounter(matColor, "ClickableClueCounter", _, 1)
2024-01-06 21:32:07 -05:00
else
pos = playmatApi.transformLocalPosition({x = -1.12, y = 0.05, z = 0.7}, matColor)
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:07 -05:00
local rot = playmatApi.returnRotation(matColor)
2023-08-27 21:09:46 -04:00
-- check if found clue is a stack or single token
if clue.getQuantity() > 1 then
clue.takeObject({position = pos, rotation = rot})
else
clue.setPositionSmooth(pos)
clue.setRotation(rot)
end
if cardName then
2024-02-04 10:51:51 -05:00
broadcastToAll(playerName .. " took one clue from " .. cardName .. ".", "White")
2023-08-27 21:09:46 -04:00
else
2024-02-04 10:51:51 -05:00
broadcastToAll(playerName .. " took one clue.", "White")
2023-08-27 21:09:46 -04:00
end
victoryDisplayApi.update()
end
-- broadcasts the bless/curse status to the calling player
function showBlessCurseStatus(playerColor)
blessCurseManagerApi.broadcastStatus(playerColor)
end
-- adds Wendy's menu to the hovered card
2024-02-04 10:51:51 -05:00
function addBlurseSealingMenu(playerColor, hoveredObject)
blessCurseManagerApi.addBlurseSealingMenu(playerColor, hoveredObject)
2023-08-27 21:09:46 -04:00
end
2024-01-06 21:32:29 -05:00
-- Simple method to check if the given point is in a specified area
2024-02-17 19:48:30 -05:00
---@param point tts__Vector Point to check, only x and z values are relevant
---@param bounds table Defined area to see if the point is within
2024-01-06 21:32:29 -05:00
function inArea(point, bounds)
return (point.x > bounds.minX
and point.x < bounds.maxX
and point.z > bounds.minZ
and point.z < bounds.maxZ)
end
2023-08-27 21:09:46 -04:00
2024-01-06 21:32:29 -05:00
-- capitalizes the first letter
function titleCase(str)
local first = str:sub(1, 1)
local rest = str:sub(2)
return first:upper() .. rest:lower()
2023-08-27 21:09:46 -04:00
end
2024-06-09 10:10:21 -04:00
-- returns the color of the first seated player
function getFirstSeatedPlayer()
for _, color in ipairs(getSeatedPlayers()) do
return color
end
end
2023-08-27 21:09:46 -04:00
end)
2024-06-09 10:10:21 -04:00
__bundle_register("chaosbag/BlessCurseManagerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
2024-02-17 19:48:30 -05:00
do
2024-06-09 10:10:21 -04:00
local BlessCurseManagerApi = {}
2024-02-17 19:48:30 -05:00
local guidReferenceApi = require("core/GUIDReferenceApi")
2024-06-09 10:10:21 -04:00
local function getManager()
return guidReferenceApi.getObjectByOwnerAndType("Mythos", "BlessCurseManager")
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- removes all taken tokens and resets the counts
BlessCurseManagerApi.removeTakenTokensAndReset = function()
local BlessCurseManager = getManager()
Wait.time(function() BlessCurseManager.call("removeTakenTokens", "Bless") end, 0.05)
Wait.time(function() BlessCurseManager.call("removeTakenTokens", "Curse") end, 0.10)
Wait.time(function() BlessCurseManager.call("doReset", "White") end, 0.15)
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- updates the internal count (called by cards that seal bless/curse tokens)
---@param type string Type of chaos token ("Bless" or "Curse")
---@param guid string GUID of the token
BlessCurseManagerApi.sealedToken = function(type, guid)
getManager().call("sealedToken", { type = type, guid = guid })
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- updates the internal count (called by cards that seal bless/curse tokens)
---@param type string Type of chaos token ("Bless" or "Curse")
---@param guid string GUID of the token
BlessCurseManagerApi.releasedToken = function(type, guid)
getManager().call("releasedToken", { type = type, guid = guid })
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- updates the internal count (called by cards that seal bless/curse tokens)
---@param type string Type of chaos token ("Bless" or "Curse")
---@param guid string GUID of the token
BlessCurseManagerApi.returnedToken = function(type, guid)
getManager().call("returnedToken", { type = type, guid = guid })
end
2024-03-10 09:56:22 -04:00
2024-06-09 10:10:21 -04:00
-- broadcasts the current status for bless/curse tokens
---@param playerColor string Color of the player to show the broadcast to
BlessCurseManagerApi.broadcastStatus = function(playerColor)
getManager().call("broadcastStatus", playerColor)
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- removes all bless / curse tokens from the chaos bag and play
---@param playerColor string Color of the player to show the broadcast to
BlessCurseManagerApi.removeAll = function(playerColor)
getManager().call("doRemove", playerColor)
2024-03-10 09:56:22 -04:00
end
2024-06-09 10:10:21 -04:00
-- adds bless / curse sealing to the hovered card
---@param playerColor string Color of the player to show the broadcast to
---@param hoveredObject tts__Object Hovered object
BlessCurseManagerApi.addBlurseSealingMenu = function(playerColor, hoveredObject)
getManager().call("addMenuOptions", { playerColor = playerColor, hoveredObject = hoveredObject })
end
return BlessCurseManagerApi
2024-03-10 09:56:22 -04:00
end
end)
__bundle_register("core/VictoryDisplayApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local VictoryDisplayApi = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
local function getVictoryDisplay()
return guidReferenceApi.getObjectByOwnerAndType("Mythos", "VictoryDisplay")
end
-- triggers an update of the victory count
---@param delay? number Delay in seconds after which the update call is executed
VictoryDisplayApi.update = function(delay)
getVictoryDisplay().call("startUpdate", delay)
end
-- moves a card to the victory display (in the first empty spot)
---@param object tts__Object Object that should be checked and potentially moved
VictoryDisplayApi.placeCard = function(object)
if object ~= nil and object.tag == "Card" then
getVictoryDisplay().call("placeCard", object)
end
end
return VictoryDisplayApi
end
end)
__bundle_register("playermat/PlaymatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local PlaymatApi = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
local searchLib = require("util/SearchLib")
-- 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 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
-- Returns the color of the closest playmat
---@param startPos table Starting position to get the closest mat from
PlaymatApi.getMatColorByPosition = function(startPos)
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
end
end
return result
end
-- 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")
PlaymatApi.getPlayerColor = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("playerColor")
end
end
-- Returns the color of the playmat that owns the playercolor's hand
---@param handColor string Color of the playmat
PlaymatApi.getMatColor = function(handColor)
for matColor, mat in pairs(getMatForColor("All")) do
local playerColor = mat.getVar("playerColor")
if playerColor == handColor then
return matColor
end
end
end
-- 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
end
-- 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
end
-- 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
end
-- Returns the position of the discard pile of the requested playmat
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.getDiscardPosition = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("returnGlobalDiscardPosition")
end
end
2024-06-09 10:10:21 -04:00
-- Returns the position of the draw pile of the requested playmat
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.getDrawPosition = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("returnGlobalDrawPosition")
end
end
2024-03-10 09:56:22 -04:00
-- Transforms a local position into a global position
---@param localPos table Local position to be transformed
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.transformLocalPosition = function(localPos, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.positionToWorld(localPos)
end
end
-- Returns the rotation of the requested playmat
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.returnRotation = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getRotation()
end
end
-- 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
-- Triggers the Upkeep for the requested playmat
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
---@param playerColor string Color of the calling player (for messages)
PlaymatApi.doUpkeepFromHotkey = function(matColor, playerColor)
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
end
-- Returns the active investigator id
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
PlaymatApi.returnInvestigatorId = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("activeInvestigatorId")
end
end
2024-06-09 10:10:21 -04:00
-- Returns the position for encounter card drawing
---@param matColor string Color of the playmat - White, Orange, Green or Red (does not support "All")
---@param stack boolean If true, returns the leftmost position instead of the first empty from the right
PlaymatApi.getEncounterCardDrawPosition = function(matColor, stack)
for _, mat in pairs(getMatForColor(matColor)) do
return Vector(mat.call("getEncounterCardDrawPosition", stack))
end
end
2024-03-10 09:56:22 -04:00
-- Sets the requested playmat's snap points to limit snapping to matching card types or not. If
-- matchTypes is true, the main card slot snap points will only snap assets, while the
-- investigator area point will only snap Investigators. If matchTypes is false, snap points will
-- be reset to snap all cards.
---@param matchCardTypes boolean Whether snap points should only snap for the matching card types
---@param matColor string Color of the playmat - White, Orange, Green, Red or All
PlaymatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("setLimitSnapsByType", matchCardTypes)
end
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04: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
PlaymatApi.showDrawButton = function(isDrawButtonVisible, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("showDrawButton", isDrawButtonVisible)
end
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04: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
PlaymatApi.clickableClues = function(showCounter, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("clickableClues", showCounter)
end
2024-02-17 19:48:30 -05:00
end
2024-02-04 10:51:51 -05:00
2024-03-10 09:56:22 -04: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
PlaymatApi.removeClues = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("removeClues")
end
2024-02-04 10:51:51 -05:00
end
2024-03-10 09:56:22 -04:00
-- Reports the clue count for the requested playmat
---@param useClickableCounters boolean Controls which type of counter is getting checked
PlaymatApi.getClueCount = function(useClickableCounters, matColor)
local count = 0
for _, mat in pairs(getMatForColor(matColor)) do
count = count + mat.call("getClueCount", useClickableCounters)
end
return count
2024-02-04 10:51:51 -05:00
end
2024-06-09 10:10:21 -04:00
-- Updates the specified owned counter
2024-03-10 09:56:22 -04: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
PlaymatApi.updateCounter = function(matColor, type, newValue, modifier)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("updateCounter", { type = type, newValue = newValue, modifier = modifier })
end
2024-02-04 10:51:51 -05:00
end
2024-06-09 10:10:21 -04:00
-- Triggers the draw function for the specified playmat
2024-03-10 09:56:22 -04:00
---@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
2024-02-04 10:51:51 -05:00
end
2024-06-09 10:10:21 -04:00
-- Returns the resource counter amount
2024-03-10 09:56:22 -04:00
---@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-02-04 10:51:51 -05:00
end
2024-06-09 10:10:21 -04:00
-- Returns a list of mat colors that have an investigator placed
2024-03-10 09:56:22 -04:00
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
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- Resets the specified skill tracker to "1, 1, 1, 1"
2024-03-10 09:56:22 -04:00
---@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")
end
2024-02-17 19:48:30 -05:00
end
2024-06-09 10:10:21 -04:00
-- Finds all objects on the playmat and associated set aside zone and returns a table
2024-03-10 09:56:22 -04: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)
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-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04: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-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04:00
-- Triggers the metadata sync for all playmats
PlaymatApi.syncAllCustomizableCards = function()
for _, mat in pairs(getMatForColor("All")) do
mat.call("syncAllCustomizableCards")
2024-02-17 19:48:30 -05:00
end
end
2024-03-10 09:56:22 -04:00
return PlaymatApi
2024-02-17 19:48:30 -05:00
end
end)
2024-03-10 09:56:22 -04:00
__bundle_register("util/SearchLib", function(require, _LOADED, __bundle_register, __bundle_modules)
2024-02-17 19:48:30 -05:00
do
2024-03-10 09:56:22 -04:00
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-02-17 19:48:30 -05:00
2024-03-10 09:56:22 -04:00
-- performs the actual search and returns a filtered list of object references
---@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
local function returnSearchResult(pos, rot, size, filter, direction, maxDistance)
local filterFunc
if filter then
filterFunc = 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 filterFunc(v.hit_object) then
table.insert(objList, v.hit_object)
end
end
return objList
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04:00
-- searches the specified area
SearchLib.inArea = function(pos, rot, size, filter)
return returnSearchResult(pos, rot, size, filter)
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04: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)
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04:00
-- searches the specified position (a single point)
SearchLib.atPosition = function(pos, filter)
size = { 0.1, 2, 0.1 }
return returnSearchResult(pos, _, size, filter)
2024-02-17 19:48:30 -05:00
end
2024-03-10 09:56:22 -04: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
return SearchLib
2024-02-17 19:48:30 -05:00
end
end)
2024-06-09 10:10:21 -04:00
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("core/GameKeyHandler")
end)
__bundle_register("core/GUIDReferenceApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local GUIDReferenceApi = {}
local function getGuidHandler()
return getObjectFromGUID("123456")
end
-- Returns the matching object
---@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
-- Returns the owner of an object or the object it's located on
---@param object tts__GameObject Object for this search
---@return string: Parent of the object or object it's located on
GUIDReferenceApi.getOwnerOfObject = function(object)
return getGuidHandler().call("getOwnerOfObject", object)
end
return GUIDReferenceApi
end
end)
__bundle_register("core/NavigationOverlayApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local NavigationOverlayApi = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
local function getNOHandler()
return guidReferenceApi.getObjectByOwnerAndType("Mythos", "NavigationOverlayHandler")
end
-- copies the visibility for the Navigation overlay
---@param startColor string Color of the player to copy from
---@param targetColor string Color of the targeted player
NavigationOverlayApi.copyVisibility = function(startColor, targetColor)
getNOHandler().call("copyVisibility", {
startColor = startColor,
targetColor = targetColor
})
end
-- changes the Navigation Overlay view ("Full View" --> "Play Areas" --> "Closed" etc.)
---@param playerColor string Color of the player to update the visibility for
NavigationOverlayApi.cycleVisibility = function(playerColor)
getNOHandler().call("cycleVisibility", playerColor)
end
-- loads the specified camera for a player
---@param player tts__Player Player whose camera should be moved
---@param camera number|string If number: Index of the camera view to load | If string: Color of the playermat to swap to
NavigationOverlayApi.loadCamera = function(player, camera)
getNOHandler().call("loadCameraFromApi", {
player = player,
camera = camera
})
end
return NavigationOverlayApi
end
end)
__bundle_register("core/OptionPanelApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local OptionPanelApi = {}
-- loads saved options
---@param options table Set a new state for the option table
OptionPanelApi.loadSettings = function(options)
return Global.call("loadSettings", options)
end
---@return any: Table of option panel state
OptionPanelApi.getOptions = function()
return Global.getTable("optionPanel")
end
return OptionPanelApi
end
end)
2023-04-22 16:56:01 -04:00
return __bundle_require("__root")