ah_sce_unpacked/unpacked/Bag OptionPanel Source 830bd0/Custom_Tile Search Assistant 17aed0.ttslua

629 lines
22 KiB
Plaintext
Raw Normal View History

2023-01-29 19:31:52 -05:00
-- Bundled by luabundle {"version":"1.6.0"}
local __bundle_require, __bundle_loaded, __bundle_register, __bundle_modules = (function(superRequire)
local loadingPlaceholder = {[{}] = true}
local register
local modules = {}
local require
local loaded = {}
register = function(name, body)
if not modules[name] then
modules[name] = body
end
end
require = function(name)
local loadedModule = loaded[name]
if loadedModule then
if loadedModule == loadingPlaceholder then
return nil
end
else
if not modules[name] then
if not superRequire then
local identifier = type(name) == 'string' and '\"' .. name .. '\"' or tostring(name)
error('Tried to require ' .. identifier .. ', but no such module has been registered')
else
return superRequire(name)
end
end
loaded[name] = loadingPlaceholder
loadedModule = modules[name](require, loaded, register, modules)
loaded[name] = loadedModule
end
return loadedModule
end
return require, loaded, register, modules
end)(nil)
__bundle_register("__root", function(require, _LOADED, __bundle_register, __bundle_modules)
require("accessories/SearchAssistant")
end)
__bundle_register("accessories/SearchAssistant", function(require, _LOADED, __bundle_register, __bundle_modules)
2024-02-04 10:51:51 -05:00
local searchLib = require("util/SearchLib")
2023-04-22 16:56:01 -04:00
local playmatApi = require("playermat/PlaymatApi")
2023-01-29 19:31:52 -05:00
-- forward declaration of variables that are used across functions
2024-01-06 21:32:29 -05:00
local matColor, handColor, setAsidePosition, setAsideRotation, drawDeckPosition, topCardDetected
2023-01-29 19:31:52 -05:00
local quickParameters = {}
quickParameters.function_owner = self
quickParameters.font_size = 165
quickParameters.width = 275
quickParameters.height = 275
quickParameters.color = "White"
2022-10-19 19:07:47 -04:00
-- common parameters
2022-12-13 14:02:30 -05:00
local buttonParameters = {}
buttonParameters.function_owner = self
buttonParameters.font_size = 125
buttonParameters.width = 650
buttonParameters.height = 225
2023-01-29 19:31:52 -05:00
buttonParameters.color = "White"
2022-12-13 14:02:30 -05:00
local inputParameters = {}
inputParameters.function_owner = self
inputParameters.input_function = "updateSearchNumber"
2023-01-29 19:31:52 -05:00
inputParameters.tooltip = "custom search amount"
2022-12-13 14:02:30 -05:00
inputParameters.label = "#"
inputParameters.font_size = 175
inputParameters.width = 400
inputParameters.height = inputParameters.font_size + 23
inputParameters.position = { 0, 0.11, 0 }
inputParameters.alignment = 3
inputParameters.validation = 2
2023-01-29 19:31:52 -05:00
function onLoad()
normalView()
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- regular view with search box
2022-10-19 19:07:47 -04:00
function normalView()
2023-01-29 19:31:52 -05:00
self.clearButtons()
self.clearInputs()
self.createInput(inputParameters)
-- create custom search button
buttonParameters.click_function = "searchCustom"
buttonParameters.tooltip = "Search the entered number of cards"
buttonParameters.position = { 0, 0.11, 0.65 }
buttonParameters.label = "Search"
self.createButton(buttonParameters)
-- create buttons to search 3, 6 or 9 cards
quickParameters.click_function = "search3"
quickParameters.label = "3"
quickParameters.position = { -0.65, 0.11, -0.65 }
self.createButton(quickParameters)
quickParameters.click_function = "search6"
quickParameters.label = "6"
quickParameters.position = { 0, 0.11, -0.65 }
self.createButton(quickParameters)
quickParameters.click_function = "search9"
quickParameters.label = "9"
quickParameters.position = { 0.65, 0.11, -0.65 }
self.createButton(quickParameters)
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- click functions
function search3(_, playerColor) startSearch(playerColor, 3) end
function search6(_, playerColor) startSearch(playerColor, 6) end
function search9(_, playerColor) startSearch(playerColor, 9) end
2022-10-19 19:07:47 -04:00
-- view during a search with "done" buttons
function searchView()
2023-01-29 19:31:52 -05:00
self.clearButtons()
self.clearInputs()
-- create the "End Search" button
buttonParameters.click_function = "endSearch"
buttonParameters.tooltip = "Left-click: Return cards and shuffle\nRight-click: Return cards without shuffling"
buttonParameters.position = { 0, 0.11, 0 }
buttonParameters.label = "End Search"
self.createButton(buttonParameters)
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- input_function to get number of cards to search
function updateSearchNumber(_, _, input)
inputParameters.value = tonumber(input)
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- starts the search with the number from the input field
function searchCustom(_, messageColor)
local number = inputParameters.value
if number ~= nil then
startSearch(messageColor, number)
else
printToColor("Enter the number of cards to search in the textbox.", messageColor, "Orange")
end
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- start the search (change UI, set handCards aside, draw cards)
function startSearch(messageColor, number)
2023-04-22 16:56:01 -04:00
matColor = playmatApi.getMatColorByPosition(self.getPosition())
handColor = playmatApi.getPlayerColor(matColor)
2024-01-06 21:32:29 -05:00
topCardDetected = false
2023-01-29 19:31:52 -05:00
-- get draw deck
2024-01-06 21:32:29 -05:00
local deckAreaObjects = playmatApi.getDeckAreaObjects(matColor)
if deckAreaObjects.draw == nil then
2023-01-29 19:31:52 -05:00
printToColor(matColor .. " draw deck could not be found!", messageColor, "Red")
return
end
2024-01-06 21:32:29 -05:00
-- get bounds to know the height of the deck
local bounds = deckAreaObjects.draw.getBounds()
drawDeckPosition = bounds.center + Vector(0, bounds.size.y / 2 + 0.2, 0)
2023-01-29 19:31:52 -05:00
printToColor("Place target(s) of search on set aside hand.", messageColor, "Green")
-- get playmat orientation
local offset = -15
if matColor == "Orange" or matColor == "Red" then
offset = 15
end
-- get position and rotation for set aside cards
2023-04-22 16:56:01 -04:00
local handData = Player[handColor].getHandTransform()
local handCards = Player[handColor].getHandObjects()
2023-01-29 19:31:52 -05:00
setAsidePosition = handData.position + offset * handData.right
setAsideRotation = { handData.rotation.x, handData.rotation.y + 180, 180 }
2024-01-06 21:32:29 -05:00
-- set y-value
setAsidePosition.y = 1.5
2023-01-29 19:31:52 -05:00
for i = #handCards, 1, -1 do
2024-01-06 21:32:29 -05:00
handCards[i].setPosition(setAsidePosition + Vector(0, (#handCards - i) * 0.1, 0))
2023-01-29 19:31:52 -05:00
handCards[i].setRotation(setAsideRotation)
end
-- handling for Norman Withers
2024-01-06 21:32:29 -05:00
if deckAreaObjects.topCard then
deckAreaObjects.topCard.flip()
topCardDetected = true
2023-01-29 19:31:52 -05:00
end
2022-10-19 19:07:47 -04:00
2023-01-29 19:31:52 -05:00
searchView()
2024-01-06 21:32:29 -05:00
Wait.time(function()
deckAreaObjects = playmatApi.getDeckAreaObjects(matColor)
deckAreaObjects.draw.deal(number, handColor)
end, 1)
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
-- place handCards back into deck and optionally shuffle
function endSearch(_, _, isRightClick)
2023-04-22 16:56:01 -04:00
local handCards = Player[handColor].getHandObjects()
2023-01-29 19:31:52 -05:00
for i = #handCards, 1, -1 do
2024-01-06 21:32:29 -05:00
handCards[i].setPosition(drawDeckPosition + Vector(0, (#handCards - i) * 0.1, 0))
2023-01-29 19:31:52 -05:00
handCards[i].setRotation(setAsideRotation)
end
-- draw set aside cards (from the ground!)
2024-02-04 10:51:51 -05:00
for _, obj in ipairs(searchLib.atPosition(setAsidePosition, "isCardOrDeck")) do
2024-01-06 21:32:29 -05:00
if obj.type == "Deck" then
2024-02-04 10:51:51 -05:00
Wait.time(function() obj.deal(#obj.getObjects(), handColor) end, 1)
2024-01-06 21:32:29 -05:00
elseif obj.type == "Card" then
2023-04-22 16:56:01 -04:00
obj.setPosition(Player[handColor].getHandTransform().position)
2023-01-29 19:31:52 -05:00
obj.flip()
2022-10-19 19:07:47 -04:00
end
2023-01-29 19:31:52 -05:00
end
2022-10-19 19:07:47 -04:00
2023-01-29 19:31:52 -05:00
normalView()
2024-01-06 21:32:29 -05:00
-- delay is to wait for cards to enter deck
if not isRightClick then
Wait.time(function()
local deckAreaObjects = playmatApi.getDeckAreaObjects(matColor)
if deckAreaObjects.draw then
deckAreaObjects.draw.shuffle()
end
end, #handCards * 0.1)
end
-- Norman Withers handling
if topCardDetected then
Wait.time(function() playmatApi.flipTopCardFromDeck(matColor) end, #handCards * 0.1)
end
2023-01-29 19:31:52 -05:00
end
end)
2024-01-06 21:32:29 -05:00
__bundle_register("playermat/PlaymatApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local PlaymatApi = {}
local guidReferenceApi = require("core/GUIDReferenceApi")
2024-02-04 10:51:51 -05:00
local searchLib = require("util/SearchLib")
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
-- 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
2024-01-06 21:32:29 -05:00
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
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.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
2024-02-17 19:48:30 -05:00
---@param handColor string Color of the playmat
2024-01-06 21:32:29 -05:00
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
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
end
-- 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
end
-- 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
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")
2024-01-06 21:32:29 -05:00
PlaymatApi.getDiscardPosition = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.call("returnGlobalDiscardPosition")
end
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")
2024-01-06 21:32:29 -05:00
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
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.returnRotation = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getRotation()
end
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
2024-01-06 21:32:29 -05: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)
2024-01-06 21:32:29 -05:00
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
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
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")
2024-01-06 21:32:29 -05:00
PlaymatApi.returnInvestigatorId = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
return mat.getVar("activeInvestigatorId")
end
end
-- 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.
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
2024-01-06 21:32:29 -05:00
PlaymatApi.setLimitSnapsByType = function(matchCardTypes, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("setLimitSnapsByType", matchCardTypes)
end
end
-- 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
2024-01-06 21:32:29 -05:00
PlaymatApi.showDrawButton = function(isDrawButtonVisible, matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("showDrawButton", isDrawButtonVisible)
end
end
-- 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
2024-01-06 21:32:29 -05:00
PlaymatApi.clickableClues = function(showCounter, matColor)
for _, mat in pairs(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 playmat
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.removeClues = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("removeClues")
end
end
-- 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
2024-01-06 21:32:29 -05:00
PlaymatApi.getClueCount = function(useClickableCounters, matColor)
local count = 0
for _, mat in pairs(getMatForColor(matColor)) do
count = count + mat.call("getClueCount", useClickableCounters)
end
return count
end
-- 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)
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
end
-- 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
2024-01-06 21:32:29 -05:00
PlaymatApi.doDiscardOne = function(matColor)
for _, mat in pairs(getMatForColor(matColor)) do
mat.call("doDiscardOne")
end
end
-- Triggers the metadata sync for all playmats
PlaymatApi.syncAllCustomizableCards = function()
for _, mat in pairs(getMatForColor("All")) do
mat.call("syncAllCustomizableCards")
end
end
return PlaymatApi
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
}
-- 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
})
-- 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
-- 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
end)
2024-02-17 19:48:30 -05:00
__bundle_register("core/GUIDReferenceApi", function(require, _LOADED, __bundle_register, __bundle_modules)
do
local GUIDReferenceApi = {}
local function getGuidHandler()
return getObjectFromGUID("123456")
end
---@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
return GUIDReferenceApi
end
end)
2023-01-29 19:31:52 -05:00
return __bundle_require("__root")