348 lines
11 KiB
Plaintext
348 lines
11 KiB
Plaintext
-- Bundled by luabundle {"version":"1.6.0"}
|
|
local __bundle_require, __bundle_loaded, __bundle_register, __bundle_modules = (function(superRequire)
|
|
local loadingPlaceholder = {[{}] = true}
|
|
|
|
local register
|
|
local modules = {}
|
|
|
|
local require
|
|
local loaded = {}
|
|
|
|
register = function(name, body)
|
|
if not modules[name] then
|
|
modules[name] = body
|
|
end
|
|
end
|
|
|
|
require = function(name)
|
|
local loadedModule = loaded[name]
|
|
|
|
if loadedModule then
|
|
if loadedModule == loadingPlaceholder then
|
|
return nil
|
|
end
|
|
else
|
|
if not modules[name] then
|
|
if not superRequire then
|
|
local identifier = type(name) == 'string' and '\"' .. name .. '\"' or tostring(name)
|
|
error('Tried to require ' .. identifier .. ', but no such module has been registered')
|
|
else
|
|
return superRequire(name)
|
|
end
|
|
end
|
|
|
|
loaded[name] = loadingPlaceholder
|
|
loadedModule = modules[name](require, loaded, register, modules)
|
|
loaded[name] = loadedModule
|
|
end
|
|
|
|
return loadedModule
|
|
end
|
|
|
|
return require, loaded, register, modules
|
|
end)(nil)
|
|
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
require("playercards/cards/WellConnected")
|
|
end)
|
|
__bundle_register("playercards/cards/WellConnected", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
-- this script is shared between both the level 0 and the upgraded level 3 version of the card
|
|
local playmatApi = require("playermat/PlaymatApi")
|
|
|
|
local display = false
|
|
local count = 0
|
|
local modValue = 5 -- level 0 Well Connected
|
|
local loopId = nil
|
|
|
|
local b_display = {
|
|
click_function = "toggleCounter",
|
|
function_owner = self,
|
|
position = {0.88,0.5,-1.33},
|
|
font_size = 150,
|
|
width = 175,
|
|
height = 175
|
|
}
|
|
|
|
function onLoad(saved_data)
|
|
local notes = JSON.decode(self.getGMNotes())
|
|
|
|
if notes.id == "54006" then -- hardcoded card id for upgraded Well Connected (3)
|
|
modValue = 4 -- Well Connected (3)
|
|
end
|
|
|
|
if saved_data != '' then
|
|
local loaded_data = JSON.decode(saved_data)
|
|
display = not loaded_data.saved_display
|
|
|
|
self.clearButtons()
|
|
toggleCounter()
|
|
end
|
|
|
|
self.addContextMenuItem('Toggle Counter', toggleCounter)
|
|
end
|
|
|
|
function onSave()
|
|
return JSON.encode({saved_display = display})
|
|
end
|
|
|
|
function toggleCounter()
|
|
display = not display
|
|
|
|
if display then
|
|
createUpdateDisplay()
|
|
loopId = Wait.time(|| createUpdateDisplay(), 2, -1)
|
|
else
|
|
if loopId ~= nil then
|
|
Wait.stop(loopId)
|
|
end
|
|
|
|
self.clearButtons()
|
|
loopId = nil
|
|
end
|
|
end
|
|
|
|
function createUpdateDisplay()
|
|
count = math.max(math.floor(getPlayerResources() / modValue), 0)
|
|
|
|
b_display.label = tostring(count)
|
|
|
|
if loopId == nil then
|
|
self.createButton(b_display)
|
|
else
|
|
self.editButton(b_display)
|
|
end
|
|
end
|
|
|
|
function getPlayerResources()
|
|
local matColor = playmatApi.getMatColorByPosition(self.getPosition())
|
|
|
|
return playmatApi.getResourceCount(matColor)
|
|
end
|
|
end)
|
|
__bundle_register("playermat/PlaymatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
do
|
|
local PlaymatApi = { }
|
|
local internal = { }
|
|
|
|
local MAT_IDS = {
|
|
White = "8b081b",
|
|
Orange = "bd0ff4",
|
|
Green = "383d8b",
|
|
Red = "0840d5"
|
|
}
|
|
|
|
local CLUE_COUNTER_GUIDS = {
|
|
White = "37be78",
|
|
Orange = "1769ed",
|
|
Green = "032300",
|
|
Red = "d86b7c"
|
|
}
|
|
|
|
local CLUE_CLICKER_GUIDS = {
|
|
White = "db85d6",
|
|
Orange = "3f22e5",
|
|
Green = "891403",
|
|
Red = "4111de"
|
|
}
|
|
|
|
-- Returns the color of the by position requested playermat as string
|
|
---@param startPos Table Position of the search, table get's roughly cut into 4 quarters to assign a playermat
|
|
PlaymatApi.getMatColorByPosition = function(startPos)
|
|
if startPos.x < -42 then
|
|
if startPos.z > 0 then
|
|
return "White"
|
|
else
|
|
return "Orange"
|
|
end
|
|
else
|
|
if startPos.z > 0 then
|
|
return "Green"
|
|
else
|
|
return "Red"
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Returns the color of the player's hand that is seated next to the playermat
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.getPlayerColor = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.getVar("playerColor")
|
|
end
|
|
|
|
-- Returns the color of the playermat that owns the playercolor's hand
|
|
---@param handColor String Color of the playermat
|
|
PlaymatApi.getMatColor = function(handColor)
|
|
local matColors = {"White", "Orange", "Green", "Red"}
|
|
for i, mat in ipairs(internal.getMatForColor("All")) do
|
|
local color = mat.getVar("playerColor")
|
|
if color == handColor then return matColors[i] end
|
|
end
|
|
return "NOT_FOUND"
|
|
end
|
|
|
|
-- Returns the result of a cast in the specificed playermat's area
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.searchPlaymat = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.call("searchAroundSelf")
|
|
end
|
|
|
|
-- Returns if there is the card "Dream-Enhancing Serum" on the requested playermat
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.isDES = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.getVar("isDES")
|
|
end
|
|
|
|
-- Returns the draw deck of the requested playmat
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.getDrawDeck = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
mat.call("getDrawDiscardDecks")
|
|
return mat.getVar("drawDeck")
|
|
end
|
|
|
|
-- Returns the position of the discard pile of the requested playmat
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.getDiscardPosition = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.call("returnGlobalDiscardPosition")
|
|
end
|
|
|
|
-- Transforms a local position into a global position
|
|
---@param localPos Table Local position to be transformed
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.transformLocalPosition = function(localPos, matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.positionToWorld(localPos)
|
|
end
|
|
|
|
-- Returns the rotation of the requested playmat
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.returnRotation = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.getRotation()
|
|
end
|
|
|
|
-- Triggers the Upkeep for the requested playmat
|
|
---@param matColor String Color of the playermat
|
|
---@param playerColor String Color of the calling player (for messages)
|
|
PlaymatApi.doUpkeepFromHotkey = function(matColor, playerColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.call("doUpkeepFromHotkey", playerColor)
|
|
end
|
|
|
|
-- Returns the active investigator id
|
|
---@param matColor String Color of the playermat
|
|
PlaymatApi.returnInvestigatorId = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.getVar("activeInvestigatorId")
|
|
end
|
|
|
|
-- Sets the requested playermat'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 for one of the active player colors - White, Orange, Green, Red. Also
|
|
-- accepts "All" as a special value which will apply the setting to all four mats.
|
|
PlaymatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("setLimitSnapsByType", matchCardTypes)
|
|
end
|
|
end
|
|
|
|
-- Sets the requested playermat's draw 1 button to visible
|
|
---@param isDrawButtonVisible Boolean. Whether the draw 1 button should be visible or not
|
|
---@param matColor String for one of the active player colors - White, Orange, Green, Red. Also
|
|
-- accepts "All" as a special value which will apply the setting to all four mats.
|
|
PlaymatApi.showDrawButton = function(isDrawButtonVisible, matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("showDrawButton", isDrawButtonVisible)
|
|
end
|
|
end
|
|
|
|
-- Shows or hides the clickable clue counter for the requested playermat
|
|
---@param showCounter Boolean. Whether the clickable counter should be present or not
|
|
---@param matColor String for one of the active player colors - White, Orange, Green, Red. Also
|
|
-- accepts "All" as a special value which will apply the setting to all four mats.
|
|
PlaymatApi.clickableClues = function(showCounter, matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("clickableClues", showCounter)
|
|
end
|
|
end
|
|
|
|
-- Removes all clues (to the trash for tokens and counters set to 0) for the requested playermat
|
|
---@param matColor String for one of the active player colors - White, Orange, Green, Red. Also
|
|
-- accepts "All" as a special value which will apply the setting to all four mats.
|
|
PlaymatApi.removeClues = function(matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("removeClues")
|
|
end
|
|
end
|
|
|
|
-- Reports the clue count for the requested playermat
|
|
---@param useClickableCounters Boolean Controls which type of counter is getting checked
|
|
PlaymatApi.getClueCount = function(useClickableCounters, matColor)
|
|
local count = 0
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
count = count + tonumber(mat.call("getClueCount", useClickableCounters))
|
|
end
|
|
return count
|
|
end
|
|
|
|
-- Adds the specified amount of resources to the requested playermat's resource counter
|
|
PlaymatApi.gainResources = function(amount, matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("gainResources", amount)
|
|
end
|
|
end
|
|
|
|
-- Returns the resource counter amount for the requested playermat
|
|
PlaymatApi.getResourceCount = function(matColor)
|
|
local mat = getObjectFromGUID(MAT_IDS[matColor])
|
|
return mat.call("getResourceCount")
|
|
end
|
|
|
|
-- Discard a non-hidden card from the corresponding player's hand
|
|
PlaymatApi.doDiscardOne = function(matColor)
|
|
for _, mat in ipairs(internal.getMatForColor(matColor)) do
|
|
mat.call("doDiscardOne")
|
|
end
|
|
end
|
|
|
|
PlaymatApi.syncAllCustomizableCards = function()
|
|
for _, mat in ipairs(internal.getMatForColor("All")) do
|
|
mat.call("syncAllCustomizableCards")
|
|
end
|
|
end
|
|
|
|
PlaymatApi.updateClueClicker = function(playerColor, val)
|
|
return getObjectFromGUID(CLUE_CLICKER_GUIDS[playerColor]).call("updateVal", val)
|
|
end
|
|
|
|
-- Convenience function to look up a mat's object by color, or get all mats.
|
|
---@param matColor String for one of the active player colors - White, Orange, Green, Red. Also
|
|
-- accepts "All" as a special value which will return all four mats.
|
|
---@return: Array of playermat objects. If a single mat is requested, will return a single-element
|
|
-- array to simplify processing by consumers.
|
|
internal.getMatForColor = function(matColor)
|
|
local targetMatGuid = MAT_IDS[matColor]
|
|
if targetMatGuid != nil then
|
|
return { getObjectFromGUID(targetMatGuid) }
|
|
end
|
|
if matColor == "All" then
|
|
return {
|
|
getObjectFromGUID(MAT_IDS.White),
|
|
getObjectFromGUID(MAT_IDS.Orange),
|
|
getObjectFromGUID(MAT_IDS.Green),
|
|
getObjectFromGUID(MAT_IDS.Red),
|
|
}
|
|
end
|
|
end
|
|
|
|
return PlaymatApi
|
|
end
|
|
end)
|
|
return __bundle_require("__root") |