652 lines
21 KiB
Plaintext
652 lines
21 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("chaosbag/BlessCurseManager")
|
|
end)
|
|
__bundle_register("chaosbag/BlessCurseManager", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
local chaosBagApi = require("chaosbag/ChaosBagApi")
|
|
local tokenArrangerApi = require("accessories/TokenArrangerApi")
|
|
|
|
-- common button parameters
|
|
local buttonParamaters = {}
|
|
buttonParamaters.function_owner = self
|
|
buttonParamaters.color = { 0, 0, 0, 0 }
|
|
buttonParamaters.width = 700
|
|
buttonParamaters.height = 700
|
|
|
|
local updating
|
|
|
|
---------------------------------------------------------
|
|
-- creating buttons and menus + initializing tables
|
|
---------------------------------------------------------
|
|
|
|
function onLoad()
|
|
-- index: 0 - bless
|
|
buttonParamaters.click_function = "clickBless"
|
|
buttonParamaters.position = { -1.03, 0, 0.46 }
|
|
buttonParamaters.tooltip = "Add / Remove Bless"
|
|
self.createButton(buttonParamaters)
|
|
|
|
-- index: 1 - curse
|
|
buttonParamaters.click_function = "clickCurse"
|
|
buttonParamaters.position[1] = -buttonParamaters.position[1]
|
|
buttonParamaters.tooltip = "Add / Remove Curse"
|
|
self.createButton(buttonParamaters)
|
|
|
|
-- index: 2 - bless count
|
|
buttonParamaters.tooltip = ""
|
|
buttonParamaters.click_function = "none"
|
|
buttonParamaters.width = 0
|
|
buttonParamaters.height = 0
|
|
buttonParamaters.color = { 0.4, 0.4, 0.4 }
|
|
buttonParamaters.font_color = { 1, 1, 1 }
|
|
buttonParamaters.font_size = 235
|
|
buttonParamaters.position = { -1.03, 0.06, -0.8 }
|
|
self.createButton(buttonParamaters)
|
|
|
|
-- index: 3 - curse count
|
|
buttonParamaters.position[1] = -buttonParamaters.position[1]
|
|
self.createButton(buttonParamaters)
|
|
|
|
-- context menu
|
|
self.addContextMenuItem("Remove all", doRemove)
|
|
self.addContextMenuItem("Reset", doReset)
|
|
|
|
-- initializing tables
|
|
initializeState()
|
|
broadcastCount("Curse")
|
|
broadcastCount("Bless")
|
|
end
|
|
|
|
function resetTables()
|
|
numInPlay = { Bless = 0, Curse = 0 }
|
|
tokensTaken = { Bless = {}, Curse = {} }
|
|
sealedTokens = {}
|
|
end
|
|
|
|
function initializeState()
|
|
resetTables()
|
|
|
|
-- count tokens in the bag
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
for _, v in ipairs(chaosBag.getObjects()) do
|
|
if v.name == "Bless" then
|
|
numInPlay.Bless = numInPlay.Bless + 1
|
|
elseif v.name == "Curse" then
|
|
numInPlay.Curse = numInPlay.Curse + 1
|
|
end
|
|
end
|
|
|
|
-- find tokens in the play area
|
|
for _, obj in ipairs(getObjects()) do
|
|
local pos = obj.getPosition()
|
|
if obj.hasTag("tempToken") then
|
|
-- skip the tokens from the Token Arranger
|
|
elseif pos.x > -65 and pos.x < 10 and pos.z > -35 and pos.z < 35 and obj.type == "Tile" then
|
|
if obj.getName() == "Bless" then
|
|
table.insert(tokensTaken.Bless, obj.getGUID())
|
|
numInPlay.Bless = numInPlay.Bless + 1
|
|
elseif obj.getName() == "Curse" then
|
|
table.insert(tokensTaken.Curse, obj.getGUID())
|
|
numInPlay.Curse = numInPlay.Curse + 1
|
|
end
|
|
end
|
|
end
|
|
|
|
updateButtonLabels()
|
|
end
|
|
|
|
function updateButtonLabels()
|
|
self.editButton({ index = 2, label = formatTokenCount("Bless", true)})
|
|
self.editButton({ index = 3, label = formatTokenCount("Curse", true)})
|
|
end
|
|
|
|
function broadcastCount(token)
|
|
local count = formatTokenCount(token)
|
|
if count == "(0 + 0)" then return end
|
|
broadcastToAll(token .. " Tokens " .. count, "White")
|
|
end
|
|
|
|
function broadcastStatus(color)
|
|
broadcastToColor("Curse Tokens " .. formatTokenCount("Curse"), color, "White")
|
|
broadcastToColor("Bless Tokens " .. formatTokenCount("Bless"), color, "White")
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- TTS event handling
|
|
---------------------------------------------------------
|
|
|
|
-- enable tracking of bag changes for 1 second
|
|
function onObjectDrop(_, object)
|
|
if not isBlurseToken(object) then return end
|
|
|
|
-- check if object was dropped in chaos bag area
|
|
for _, zone in ipairs(object.getZones()) do
|
|
if zone.getName() == "ChaosBagZone" then
|
|
trackBagChange = true
|
|
Wait.time(function() trackBagChange = false end, 1)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
|
|
-- handle manual returning of bless / curse tokens
|
|
function onObjectEnterContainer(container, object)
|
|
if not (trackBagChange and isChaosbag(container) and isBlurseToken(object)) then return end
|
|
|
|
-- small delay to ensure token has entered bag
|
|
Wait.time(doReset, 0.5)
|
|
end
|
|
|
|
function isChaosbag(obj)
|
|
if obj.getDescription() ~= "Chaos Bag" then return end -- early exit for performance
|
|
return obj == chaosBagApi.findChaosBag()
|
|
end
|
|
|
|
function isBlurseToken(obj)
|
|
local name = obj.getName()
|
|
return name == "Bless" or name == "Curse"
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- context menu functions
|
|
---------------------------------------------------------
|
|
|
|
function doRemove(color)
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
|
|
-- remove tokens from chaos bag
|
|
local count = { Bless = 0, Curse = 0 }
|
|
for _, v in ipairs(chaosBag.getObjects()) do
|
|
if v.name == "Bless" or v.name == "Curse" then
|
|
chaosBag.takeObject({
|
|
guid = v.guid,
|
|
position = { 0, 5, 0 },
|
|
callback_function = function(obj) obj.destruct() end
|
|
})
|
|
count[v.name] = count[v.name] + 1
|
|
end
|
|
end
|
|
|
|
broadcastToColor("Removed " .. count.Bless .. " Bless and " .. count.Curse .. " Curse tokens from the chaos bag.", color, "White")
|
|
broadcastToColor("Removed " .. removeTakenTokens("Bless") .. " Bless and " .. removeTakenTokens("Curse") .. " Curse tokens from play.", color, "White")
|
|
|
|
resetTables()
|
|
updateButtonLabels()
|
|
tokenArrangerApi.layout()
|
|
end
|
|
|
|
function doReset()
|
|
initializeState()
|
|
broadcastCount("Curse")
|
|
broadcastCount("Bless")
|
|
tokenArrangerApi.layout()
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- click functions
|
|
---------------------------------------------------------
|
|
|
|
function clickBless(_, color, isRightClick)
|
|
playerColor = color
|
|
callFunctions("Bless", isRightClick)
|
|
end
|
|
|
|
function clickCurse(_, color, isRightClick)
|
|
playerColor = color
|
|
callFunctions("Curse", isRightClick)
|
|
end
|
|
|
|
function callFunctions(type, isRightClick)
|
|
if not chaosBagApi.canTouchChaosTokens() then return end
|
|
|
|
if isRightClick then
|
|
removeToken(type)
|
|
else
|
|
addToken(type)
|
|
end
|
|
|
|
tokenArrangerApi.layout()
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- called functions
|
|
---------------------------------------------------------
|
|
|
|
-- returns a formatted string with information about the provided token type (bless / curse)
|
|
---@param type string Type of chaos token ("Bless" or "Curse")
|
|
---@param omitBrackets? boolean Controls whether the brackets should be omitted from the return
|
|
---@return string tokenCount
|
|
function formatTokenCount(type, omitBrackets)
|
|
if omitBrackets then
|
|
return (numInPlay[type] - #tokensTaken[type]) .. " + " .. #tokensTaken[type]
|
|
else
|
|
return "(" .. (numInPlay[type] - #tokensTaken[type]) .. " + " .. #tokensTaken[type] .. ")"
|
|
end
|
|
end
|
|
|
|
-- seals a token on a card (called by cards that seal bless/curse tokens)
|
|
---@param param table This contains the type and guid of the sealed token
|
|
function sealedToken(param)
|
|
table.insert(tokensTaken[param.type], param.guid)
|
|
broadcastCount(param.type)
|
|
updateButtonLabels()
|
|
end
|
|
|
|
-- returns a token to the bag (called by cards that seal bless/curse tokens)
|
|
---@param param table This contains the type and guid of the released token
|
|
function releasedToken(param)
|
|
for i, v in ipairs(tokensTaken[param.type]) do
|
|
if v == param.guid then
|
|
table.remove(tokensTaken[param.type], i)
|
|
break
|
|
end
|
|
end
|
|
|
|
if not param.fromBag then
|
|
updateDisplayAndBroadcast(param.type)
|
|
end
|
|
end
|
|
|
|
-- removes a token (called by cards that seal bless/curse tokens)
|
|
---@param param table This contains the type and guid of the released token
|
|
function returnedToken(param)
|
|
for i, v in ipairs(tokensTaken[param.type]) do
|
|
if v == param.guid then
|
|
table.remove(tokensTaken[param.type], i)
|
|
numInPlay[param.type] = numInPlay[param.type] - 1
|
|
break
|
|
end
|
|
end
|
|
updateDisplayAndBroadcast(param.type)
|
|
end
|
|
|
|
function updateDisplayAndBroadcast(type)
|
|
if not updating then
|
|
updating = true
|
|
Wait.frames(function()
|
|
broadcastCount(type)
|
|
updateButtonLabels()
|
|
updating = false
|
|
end, 5)
|
|
end
|
|
end
|
|
|
|
function getBlessCurseInBag()
|
|
local numInBag = { Bless = 0, Curse = 0 }
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
|
|
for _, v in ipairs(chaosBag.getObjects()) do
|
|
if v.name == "Bless" or v.name == "Curse" then
|
|
numInBag[v.name] = numInBag[v.name] + 1
|
|
end
|
|
end
|
|
|
|
return numInBag
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- main functions: add and remove
|
|
---------------------------------------------------------
|
|
|
|
function addToken(type)
|
|
if numInPlay[type] == 10 then
|
|
printToColor("10 tokens already in play, not adding any.", playerColor)
|
|
return
|
|
end
|
|
numInPlay[type] = numInPlay[type] + 1
|
|
printToAll("Adding " .. type .. " token " .. formatTokenCount(type))
|
|
updateButtonLabels()
|
|
return chaosBagApi.spawnChaosToken(type)
|
|
end
|
|
|
|
function removeToken(type)
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
local tokens = {}
|
|
|
|
for _, v in ipairs(chaosBag.getObjects()) do
|
|
if v.name == type then
|
|
table.insert(tokens, v.guid)
|
|
end
|
|
end
|
|
|
|
if #tokens == 0 then
|
|
printToColor("No " .. type .. " tokens in the chaos bag.", playerColor)
|
|
return
|
|
end
|
|
|
|
chaosBag.takeObject({
|
|
guid = table.remove(tokens),
|
|
smooth = false,
|
|
callback_function = function(obj)
|
|
numInPlay[type] = numInPlay[type] - 1
|
|
printToAll("Removing " .. type .. " token " .. formatTokenCount(type))
|
|
updateButtonLabels()
|
|
obj.destruct()
|
|
end
|
|
})
|
|
end
|
|
|
|
-- removing tokens that were 'taken'
|
|
function removeTakenTokens(type)
|
|
local count = 0
|
|
for _, guid in ipairs(tokensTaken[type]) do
|
|
local token = getObjectFromGUID(guid)
|
|
if token ~= nil then
|
|
token.destruct()
|
|
count = count + 1
|
|
end
|
|
end
|
|
return count
|
|
end
|
|
|
|
---------------------------------------------------------
|
|
-- Wendy's Menu (context menu for cards on hotkey press)
|
|
---------------------------------------------------------
|
|
|
|
function addMenuOptions(parameters)
|
|
local playerColor = parameters.playerColor
|
|
local hoveredObject = parameters.hoveredObject
|
|
if hoveredObject == nil or hoveredObject.type ~= "Card" then
|
|
broadcastToColor("Right-click seal options can only be added to cards.", playerColor)
|
|
return
|
|
elseif hoveredObject.hasTag("CardThatSeals") or hoveredObject.getVar("MENU_ADDED") == true then
|
|
broadcastToColor("This card already has a sealing context menu.", playerColor)
|
|
return
|
|
end
|
|
|
|
hoveredObject.addContextMenuItem("Seal Bless", function(color)
|
|
sealToken("Bless", color, hoveredObject)
|
|
tokenArrangerApi.layout()
|
|
end, true)
|
|
|
|
hoveredObject.addContextMenuItem("Release Bless", function(color)
|
|
releaseToken("Bless", color, hoveredObject)
|
|
tokenArrangerApi.layout()
|
|
end, true)
|
|
|
|
hoveredObject.addContextMenuItem("Seal Curse", function(color)
|
|
sealToken("Curse", color, hoveredObject)
|
|
tokenArrangerApi.layout()
|
|
end, true)
|
|
|
|
hoveredObject.addContextMenuItem("Release Curse", function(color)
|
|
releaseToken("Curse", color, hoveredObject)
|
|
tokenArrangerApi.layout()
|
|
end, true)
|
|
|
|
broadcastToColor("Right-click seal options added to " .. hoveredObject.getName(), playerColor)
|
|
hoveredObject.setVar("MENU_ADDED", true)
|
|
sealedTokens[hoveredObject.getGUID()] = {}
|
|
end
|
|
|
|
function sealToken(type, playerColor, hoveredObject)
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
|
|
for i, token in ipairs(chaosBag.getObjects()) do
|
|
if token.name == type then
|
|
return chaosBag.takeObject({
|
|
position = hoveredObject.getPosition() + Vector(0, 1, 0),
|
|
index = i - 1,
|
|
smooth = false,
|
|
callback_function = function(obj)
|
|
table.insert(sealedTokens[hoveredObject.getGUID()], obj)
|
|
table.insert(tokensTaken[type], obj.getGUID())
|
|
tokenArrangerApi.layout()
|
|
updateDisplayAndBroadcast(type)
|
|
end
|
|
})
|
|
end
|
|
end
|
|
printToColor(type .. " token not found in bag", playerColor)
|
|
end
|
|
|
|
function releaseToken(type, playerColor, hoveredObject)
|
|
local chaosBag = chaosBagApi.findChaosBag()
|
|
local tokens = sealedTokens[hoveredObject.getGUID()]
|
|
if tokens == nil or #tokens == 0 then return end
|
|
|
|
for i, token in ipairs(tokens) do
|
|
if token ~= nil and token.getName() == type then
|
|
local guid = token.getGUID()
|
|
chaosBag.putObject(token)
|
|
for j, v in ipairs(tokensTaken[type]) do
|
|
if v == guid then
|
|
table.remove(tokensTaken[type], j)
|
|
table.remove(tokens, i)
|
|
tokenArrangerApi.layout()
|
|
updateDisplayAndBroadcast(type)
|
|
return
|
|
end
|
|
end
|
|
end
|
|
end
|
|
printToColor(type .. " token not sealed on " .. hoveredObject.getName(), playerColor)
|
|
end
|
|
|
|
function none() end
|
|
end)
|
|
__bundle_register("accessories/TokenArrangerApi", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
do
|
|
local TokenArrangerApi = {}
|
|
local guidReferenceApi = require("core/GUIDReferenceApi")
|
|
|
|
-- local function to call the token arranger, if it is on the table
|
|
---@param functionName string Name of the function to cal
|
|
---@param argument? table Parameter to pass
|
|
local function callIfExistent(functionName, argument)
|
|
local tokenArranger = guidReferenceApi.getObjectByOwnerAndType("Mythos", "TokenArranger")
|
|
if tokenArranger ~= nil then
|
|
tokenArranger.call(functionName, argument)
|
|
end
|
|
end
|
|
|
|
-- updates the token modifiers with the provided data
|
|
---@param fullData table Contains the chaos token metadata
|
|
TokenArrangerApi.onTokenDataChanged = function(fullData)
|
|
callIfExistent("onTokenDataChanged", fullData)
|
|
end
|
|
|
|
-- deletes already laid out tokens
|
|
TokenArrangerApi.deleteCopiedTokens = function()
|
|
callIfExistent("deleteCopiedTokens")
|
|
end
|
|
|
|
-- updates the laid out tokens
|
|
TokenArrangerApi.layout = function()
|
|
Wait.time(function() callIfExistent("layout") end, 0.1)
|
|
end
|
|
|
|
return TokenArrangerApi
|
|
end
|
|
end)
|
|
__bundle_register("chaosbag/ChaosBagApi", function(require, _LOADED, __bundle_register, __bundle_modules)
|
|
do
|
|
local ChaosBagApi = {}
|
|
|
|
-- respawns the chaos bag with a new state of tokens
|
|
---@param tokenList table List of chaos token ids
|
|
ChaosBagApi.setChaosBagState = function(tokenList)
|
|
Global.call("setChaosBagState", tokenList)
|
|
end
|
|
|
|
-- returns a Table List of chaos token ids in the current chaos bag
|
|
-- requires copying the data into a new table because TTS is weird about handling table return values in Global
|
|
ChaosBagApi.getChaosBagState = function()
|
|
local chaosBagContentsCatcher = Global.call("getChaosBagState")
|
|
local chaosBagContents = {}
|
|
for _, v in ipairs(chaosBagContentsCatcher) do
|
|
table.insert(chaosBagContents, v)
|
|
end
|
|
return chaosBagContents
|
|
end
|
|
|
|
-- checks scripting zone for chaos bag (also called by a lot of objects!)
|
|
ChaosBagApi.findChaosBag = function()
|
|
return Global.call("findChaosBag")
|
|
end
|
|
|
|
-- returns a table of object references to the tokens in play (does not include sealed tokens!)
|
|
ChaosBagApi.getTokensInPlay = function()
|
|
return Global.call("getChaosTokensinPlay")
|
|
end
|
|
|
|
-- returns all sealed tokens on cards to the chaos bag
|
|
---@param playerColor string Color of the player to show the broadcast to
|
|
ChaosBagApi.releaseAllSealedTokens = function(playerColor)
|
|
Global.call("releaseAllSealedTokens", playerColor)
|
|
end
|
|
|
|
-- returns all drawn tokens to the chaos bag
|
|
ChaosBagApi.returnChaosTokens = function()
|
|
Global.call("returnChaosTokens")
|
|
end
|
|
|
|
-- removes the specified chaos token from the chaos bag
|
|
---@param id string ID of the chaos token
|
|
ChaosBagApi.removeChaosToken = function(id)
|
|
Global.call("removeChaosToken", id)
|
|
end
|
|
|
|
-- returns a chaos token to the bag and calls all relevant functions
|
|
---@param token tts__Object Chaos token to return
|
|
---@param fromBag boolean whether or not the token to return was in the middle of being drawn (true) or elsewhere (false)
|
|
ChaosBagApi.returnChaosTokenToBag = function(token, fromBag)
|
|
Global.call("returnChaosTokenToBag", { token = token, fromBag = fromBag })
|
|
end
|
|
|
|
-- spawns the specified chaos token and puts it into the chaos bag
|
|
---@param id string ID of the chaos token
|
|
ChaosBagApi.spawnChaosToken = function(id)
|
|
Global.call("spawnChaosToken", id)
|
|
end
|
|
|
|
-- Checks to see if the chaos bag can be manipulated. If a player is searching the bag when tokens
|
|
-- are drawn or replaced a TTS bug can cause those tokens to vanish. Any functions which change the
|
|
-- contents of the bag should check this method before doing so.
|
|
-- This method will broadcast a message to all players if the bag is being searched.
|
|
---@return any: True if the bag is manipulated, false if it should be blocked.
|
|
ChaosBagApi.canTouchChaosTokens = function()
|
|
return Global.call("canTouchChaosTokens")
|
|
end
|
|
|
|
-- draws a chaos token to a playermat
|
|
---@param mat tts__Object Playermat that triggered this
|
|
---@param drawAdditional boolean Controls whether additional tokens should be drawn
|
|
---@param tokenType? string Name of token (e.g. "Bless") to be drawn from the bag
|
|
---@param guidToBeResolved? string GUID of the sealed token to be resolved instead of drawing a token from the bag
|
|
---@param takeParameters? table Position and rotation of the location where the new token should be drawn to, usually to replace a returned token
|
|
---@return tts__Object: Object reference to the token that was drawn
|
|
ChaosBagApi.drawChaosToken = function(mat, drawAdditional, tokenType, guidToBeResolved, takeParameters)
|
|
return Global.call("drawChaosToken", {
|
|
mat = mat,
|
|
drawAdditional = drawAdditional,
|
|
tokenType = tokenType,
|
|
guidToBeResolved = guidToBeResolved,
|
|
takeParameters = takeParameters
|
|
})
|
|
end
|
|
|
|
-- returns a Table List of chaos token ids in the current chaos bag
|
|
-- requires copying the data into a new table because TTS is weird about handling table return values in Global
|
|
ChaosBagApi.getIdUrlMap = function()
|
|
return Global.getTable("ID_URL_MAP")
|
|
end
|
|
|
|
return ChaosBagApi
|
|
end
|
|
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)
|
|
return __bundle_require("__root") |