Argus

Contents

• World Draw Fields
• World Draw Structures
• World Draw Functions
• Detection Structures
• Detection Functions

Modules

• argus

Module argus

Advanced detections/drawing library

World Draw Fields

World Draw Structures

World Draw Functions

Detection Structures

Detection Functions

World Draw Fields

u32color

Integer color value used in Argus functions

• u32color Use GUI:ColorConvertFloat4ToU32(r, g, b, a) to get this U32 value. The r, g, b, a values are all [0,1], not [0,255].

World Draw Structures

rgbFill

Structure used for old Argus timed draws

Fields:

• r number [0,1]
• g number [0,1]
• b number [0,1]
• a number [0,1]

World Draw Functions

Argus.addArrowFilled (x, y, z, length, baseWidth, tipLength, tipWidth, heading, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a filled arrow on the ground at world coordinates for this frame. The arrow base/bottom is centered on x,y,z, and then rotated such that there is an arrow facing the specified heading.

Parameters:

• x number
• y number
• z number
• length number Length of the base rectangle of the arrow.
• baseWidth number Width of the base rectangle of the arrow.
• tipLength number Length of the tip triangle of the arrow.
• tipWidth number Width of the tip triangle of the arrow.
• heading number The direction the arrow will point towards in radians.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addChevronFilled (x, y, z, length, thickness, heading, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a filled chevron on the ground at world coordinates for this frame. The chevron base/bottom is centered on x,y,z, and then rotated such that it is pointing towards specified heading.

Parameters:

• x number
• y number
• z number
• length number
• thickness number Width of the base rectangle of the arrow.
• heading number The direction the chevron will point towards in radians.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addCircleFilled (x, y, z, radius, segments, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a filled circle on the ground at world coordinates for this frame.

Parameters:

• x number
• y number
• z number
• radius number Radius of the circle in yalms.
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• colorFill u32color Fill Color of circle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addConeFilled (x, y, z, radius, angle, heading, segments, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a timed cone on the ground at world coordinates for this frame. The cone originates from x,y,z, and will go in the direction of heading.

Parameters:

• x number
• y number
• z number
• radius number If the cone was a circle instead, this gives the radius of that circle. Basically this is the length of the cone.
• angle number Arc angle of the cone in radians. Basically, this is how wide the cone is.
• heading number The direction the cone will face in radians.
• segments int Generally only 30 segments is needed to draw a cone that looks round. For performance reasons I would recommend not going above 30 segments.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addCrossFilled (x, y, z, length, width, heading, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a filled cross on the ground at world coordinates for this frame. The cross is centered on x,y,z, and then rotated such that there is a rectangle facing the specified heading.

Parameters:

• x number
• y number
• z number
• length number
• width number
• heading number The direction the cross will face in radians.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addDonutFilled (x, y, z, radiusInner, radiusOuter, segments, colorFill[, colorOutline][, outlineThickness=1.0])

Draw a filled donut (torus) on the ground at world coordinates for this frame.

Parameters:

• x number
• y number
• z number
• radiusInner number Inner radius of the donut.
• radiusOuter number Outer radius of the donut
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Argus.addLineFilled (x1, y1, z1, x2, y2, z2, colorFill, outlineThickness, endpointThickness)

Draw a timed line between two world coordinate positions for this frame.

Parameters:

• x1 number
• y1 number
• z1 number
• x2 number
• y2 number
• z2 number
• colorFill u32color
• outlineThickness number
• endpointThickness number

Argus.addRectFilled (x, y, z, length, width, heading, colorFill[, colorOutline][, outlineThickness][, ignoreBase=false])

Draw a filled rectangle on the ground at world coordinates for this frame. The rectangle originates from x,y,z, and will go width/2 yalms out in each direction up and down, then length yalms out in the direction of heading.

Parameters:

• x number
• y number
• z number
• length number
• width number
• heading number The direction the rectangle will face in radians.
• colorFill u32color Fill Color of rectangle. If argument is nil, then no fill will be drawn.
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (optional)
• ignoreBase bool If true, Argus will not draw the outline connecting the base of the rectangle. Useful for drawing crosses, however Argus already has a function for that, see Argus.addCrossFilled. (default false)

Argus.addTimedCircleFilled (timeout, x, y, z, radius, segments, rgbFill, alphaMin, alphaMax[, delay=0][, entityAttachID][, colorOutline][, outlineThickness=1.0])

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedCircleFilled instead. Draw a filled circle on the ground at world coordinates for a specified duration.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radius number Radius of the circle in yalms.
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• rgbFill rgbFill
• alphaMin number Starting alpha value [0,1]
• alphaMax number Ending alpha value, Argus will gradually increase from alphaMin to alphaMax over the duration of the draw. [0,1]
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus.addTimedConeFilled (timeout, x, y, z, radius, angle, heading, segments, rgbFill, alphaMin, alphaMax[, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedConeFilled instead. Draw a filled cone on the ground at world coordinates for a specified duration. The cone originates from x,y,z, and will go in the direction of heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radius number If the cone was a circle instead, this gives the radius of that circle. Basically this is the length of the cone.
• angle number Arc angle of the cone in radians. Basically, this is how wide the cone is.
• heading number The direction the cone will face in radians.
• segments int Generally only 30 segments is needed to draw a cone that looks round. For performance reasons I would recommend not going above 30 segments.
• rgbFill rgbFill
• alphaMin number Starting alpha value [0,1]
• alphaMax number Ending alpha value, Argus will gradually increase from alphaMin to alphaMax over the duration of the draw. [0,1]
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the cone will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus.addTimedCrossFilled (timeout, x, y, z, length, width, heading, rgbFill, alphaMin, alphaMax[, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedCrossFilled instead. Draw a filled cross on the ground at world coordinates for a specified duration. The cross is centered on x,y,z, and then rotated such that there is a rectangle facing the specified heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number
• width number
• heading number The direction the cross will face in radians.
• rgbFill rgbFill
• alphaMin number Starting alpha value [0,1]
• alphaMax number Ending alpha value, Argus will gradually increase from alphaMin to alphaMax over the duration of the draw. [0,1]
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the cone will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus.addTimedDonutFilled (timeout, x, y, z, radiusInner, radiusOuter, segments, rgbFill, alphaMin, alphaMax[, delay=0][, entityAttachID][, colorOutline][, outlineThickness=1.0])

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedDonutFilled instead. Draw a filled donut (torus) on the ground at world coordinates for a specified duration.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radiusInner number Inner radius of the donut.
• radiusOuter number Outer radius of the donut
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• rgbFill rgbFill
• alphaMin number Starting alpha value [0,1]
• alphaMax number Ending alpha value, Argus will gradually increase from alphaMin to alphaMax over the duration of the draw. [0,1]
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus.addTimedLineFilled (timeout, x1, y1, z1, x2, y2, z2[, delay=0], rgbFill, outlineThickness, endpointThickness)

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedLineFilled instead. Draw a filled line between two world coordinate positions for a specified duration.

Parameters:

• timeout int Duration of the draw
• x1 number
• y1 number
• z1 number
• x2 number
• y2 number
• z2 number
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• rgbFill rgbFill Color of line
• outlineThickness number
• endpointThickness number

Returns:

string uuid, see Argus.deleteTimedShape

Argus.addTimedRectFilled (timeout, x, y, z, length, width, heading, rgbFill, alphaMin, alphaMax[, delay=0][, entityAttachID][, targetAttachID[, keepLength=false]][, colorOutline][, outlineThickness=1.0])

THIS FUNCTION IS DEPRECATED. Use Argus2.addTimedRectFilled instead. Draws a filled rectangle on the ground for a specified duration. The rectangle originates from x,y,z, and will go width/2 yalms out in each direction up and down, then length yalms out in the direction of heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number
• width number
• heading number The direction the rectangle will face in radians.
• rgbFill rgbFill
• alphaMin number Starting alpha value [0,1]
• alphaMax number Ending alpha value, Argus will gradually increase from alphaMin to alphaMax over the duration of the draw. [0,1]
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the rectangle will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• keepLength bool If specified with targetAttach, then the length won't be adjusted to the target, the length will stay constant. (default false)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus.deleteTimedShape (uuid)

Deletes a timed draw given a uuid

Parameters:

• uuid string

Argus2.addTimedArrowFilled (timeout, x, y, z, length, baseWidth, tipLength, tipWidth, heading, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

Draw a filled arrow on the ground at world coordinates for a specified duration. The arrow base/bottom is centered on x,y,z, and then rotated such that there is an arrow facing the specified heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number Length of the base rectangle of the arrow.
• baseWidth number Width of the base rectangle of the arrow.
• tipLength number Length of the tip triangle of the arrow.
• tipWidth number Width of the tip triangle of the arrow.
• heading number The direction the arrow will point towards in radians.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z,h will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the arrow will point from it's source position (either specified or attached to entity) -> the position of targetAttach entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedChevronFilled (timeout, x, y, z, length, thickness, heading, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

Draw a filled chevron on the ground at world coordinates for a specified duration. The chevron base/bottom is centered on x,y,z, and then rotated such that it is pointing towards specified heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number
• thickness number Width of the base rectangle of the arrow.
• heading number The direction the chevron will point towards in radians.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z,h will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the chevron will point from it's source position (either specified or attached to entity) -> the position of targetAttach entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedCircleFilled (timeout, x, y, z, radius, segments, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, colorOutline][, outlineThickness=1.0])

Draw a filled circle on the ground at world coordinates for a specified duration.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radius number Radius of the circle in yalms.
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• colorStart u32color Color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedConeFilled (timeout, x, y, z, radius, angle, heading, segments, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

Draw a timed cone on the ground at world coordinates for a specified duration. The cone originates from x,y,z, and will go in the direction of heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radius number If the cone was a circle instead, this gives the radius of that circle. Basically this is the length of the cone.
• angle number Arc angle of the cone in radians. Basically, this is how wide the cone is.
• heading number The direction the cone will face in radians.
• segments int Generally only 30 segments is needed to draw a cone that looks round. For performance reasons I would recommend not going above 30 segments.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the cone will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedCrossFilled (timeout, x, y, z, length, width, heading, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, targetAttachID][, colorOutline][, outlineThickness=1.0])

Draw a filled cross on the ground at world coordinates for a specified duration. The cross is centered on x,y,z, and then rotated such that there is a rectangle facing the specified heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number
• width number
• heading number The direction the cross will face in radians.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the cone will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedDonutFilled (timeout, x, y, z, radiusInner, radiusOuter, segments, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, colorOutline][, outlineThickness=1.0])

Draw a filled donut (torus) on the ground at world coordinates for a specified duration.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• radiusInner number Inner radius of the donut.
• radiusOuter number Outer radius of the donut
• segments int Number of segments for the circle. Generally only 50 segments is needed to draw a circle that looks round. For performance reasons I would recommend not going above 50 segments.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (default 1.0)

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedLineFilled (timeout, x1, y1, z1, x2, y2, z2[, delay=0], colorFill, outlineThickness, endpointThickness)

Draw a timed line between two world coordinate positions for a specified duration.

Parameters:

• timeout int duration of the draw
• x1 number
• y1 number
• z1 number
• x2 number
• y2 number
• z2 number
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• colorFill u32color
• outlineThickness number
• endpointThickness number

Returns:

string uuid, see Argus.deleteTimedShape

Argus2.addTimedRectFilled (timeout, x, y, z, length, width, heading, colorStart, colorEnd[, colorMid][, delay=0][, entityAttachID][, targetAttachID[, keepLength=false]][, colorOutline][, outlineThickness])

Draw a filled rectangle on the ground at world coordinates for a specified duration. The rectangle originates from x,y,z, and will go width/2 yalms out in each direction up and down, then length yalms out in the direction of heading.

Parameters:

• timeout int duration of the draw
• x number
• y number
• z number
• length number
• width number
• heading number The direction the rectangle will face in radians.
• colorStart u32color color to start with.
• colorEnd u32color U32 Color to end with. Argus will transition from color start to color end.
• colorMid u32color If specified, Argus will shift from start -> mid -> end color instead of start -> finish (optional)
• delay int Time in milliseconds to wait before the draw is shown. Useful for when mechanics happen back to back, and you want to delay showing the circles without precise timing. (default 0)
• entityAttachID int Will attach to specified entity ID, and x,y,z will dynamically be changed to specified entity (optional)
• targetAttachID int If specified, the rectangle will be drawn from it's source position (either specified or attached to entity) and stopping at the position of targetAttach entity. (optional)
• keepLength bool If specified with targetAttach, then the length won't be adjusted to the target, the length will stay constant. (default false)
• colorOutline u32color U32 Color for outline. If unspecified, an outline is not drawn. (optional)
• outlineThickness number If outlineThickness is specified and colorOutline is not specified, Argus will use your current color shift value based on percent complete, and the alpha will be 1. (optional)

Returns:

string uuid, see Argus.deleteTimedShape

Detection Structures

DirectionalAOE

Structure for Directional AOEs that are usually originating from an entity

Fields:

• x number X position of aoe
• y number Y position of aoe
• z number Z position of aoe
• aoeType int Animation/omen type of aoe
• heading number Direction the aoe is facing
• aoeLength int Length of aoe
• aoeWidth int Width of aoe, mostly used for Line aoes. This value is 0 for cones and circles.
• aoeName string Name of aoe
• aoeID number Cast/Spell ID of aoe
• aoeCastType number Cast type/shape of AOE. See castType for known castType values.
• targetAttach int ID of entity that current aoe is attached to, if found. Value is nil otherwise.
• aoeAnimationInfo aoeAnimationInfo Contains information about the animation that will play when the aoe completes and gets casted.
• aoeEffectInfo aoeEffectInfo Contains information about the aoe's omen/telegraph.
• isAreaTarget bool If the spell is a free target ability or not, this is useful for identifying aoes that will attach to target or not. Argus already processes this information combined with a few more heuristics internally, and will update the x,y,z and well as targetAttachID correctly.

GroundAOE

Structure for Ground AOEs that are not usually attached to any entity

Fields:

• x number X position of aoe
• y number Y position of aoe
• z number Z position of aoe
• aoeType int Animation/omen type of aoe
• aoeLength int Length/radius in yalms of aoe
• aoeWidth int Width in yalms of aoe (0 for circles and cones etc)
• aoeName string Name of aoe
• aoeID int Cast/Spell ID of aoe
• aoeCastType int Cast type/shape of AOE. See castType for known castType values.
• targetAttach int ID of entity that current aoe is attached to, if found. Value is nil otherwise.
• aoeAnimationInfo aoeAnimationInfo Contains information about the animation that will play when the aoe completes and gets casted.
• aoeEffectInfo aoeEffectInfo Contains information about the aoe's omen/telegraph.
• isAreaTarget bool If the spell is a free target ability or not, this is useful for identifying aoes that will attach to target or not. Argus already processes this information combined with a few more heuristics internally, and will update the x,y,z and well as targetAttachID correctly.

aoeAnimationInfo

Structure that contains information about an aoe's animation. Useful in case there is additional info that can be grabbed to determine cone width/donut inner radius.

Fields:

• aoeAnimationTypeStart int
• aoeAnimationTypeEnd int
• aoeAnimationTimelineHit int
• aoeCastVFX int

aoeEffectInfo

Structure that contains information about an omen/telegraph. Useful for identifying cone width and donut inner radius for telegraphed aoes.

Fields:

• aoeEffectName string Name of omen
• aoeEffectCastType int If this value is non-zero, then the game override the original aoeCastType with this castType value internally. Argus already updates the original aoeCastType value correctly, so this field can be generally ignored. See castType for known castType values.
• aoeEffectRestrictYScale bool If true, the aoe will be 10% of it's original size. Argus already adjusts the original aoe size values correctly, so this field can be generally ignored.
• aoeEffectLargeScale int Some value that changes internal orientation for drawing the telegraph effects. Argus already handles this value interanlly, so it can be generally ignored.

castType

An integer to identify some aoe types. These are not guaranteed for every AOE. But generally, these are how AOEs are categorized in the game.

Fields:

• [2, 5, 7] Circle AOE
• [3, 13] Directional Cone/arc AOE
• [4, 12] Directional Line AOE
• [6] Meteor mechanic (more damage the closer you are to the center), usually unavoidable
• [8] Line AOE that's targeted to either a position, or specific entity. Argus will adjust the length and heading automatically
• [10] Donut AOE
• [11] Cross AOE (new type to shadowbringers, like last boss of grand cosmos)

Detection Functions

Argus.forceMisdirectionMovement (value)

Normal movement options in minion will not move the player when under misdirection. This function will allow you to start/stop movement while under misdirection. Note that the movement will always go in the direction of Argus.getMisdirectionHeading.

Parameters:

• value bool true to start movement, false or nil to stop movement

Returns:

bool Returns the value set if successful, nil if not (cases of nil can be TensorCore Exe not being loaded.)

Argus.getCurrentAOEs ()

Returns a merged list of GroundAOEs and DirectionalAOEs. Due to the nature of this function, this list is always in order.

Returns:

table Merged list of GroundAOEs and DirectionalAOEs.

Argus.getCurrentDirectionalAOEs ([inOrder=false])

Returns list of current AOEs that are cast on the ground where each key is the entityID source, and value is the DirectionalAOE structure. These are not attached to an entity (they do not originate from an entity centerpoint). Also returns AOEs before the telegraphs are drawn, and returns AOEs with no telegraphs.

Parameters:

• inOrder bool If true, then the AOEs will return in order of appearance, instead of having each key be entityID. (default false)

Returns:

table List of DirectionalAOE, keys based on inOrder

Argus.getCurrentGroundAOEs ([inOrder=false])

Returns list of current AOEs that are on the ground where each key is the entityID source, and value is the DirectionalAOE. These are attached to an entity (they originate from the source entity's center point). Most commonly used for line AOEs, conals, and donuts, but also includes circles. Also returns AOEs before the telegraphs are drawn, and returns AOEs with no telegraphs.

Parameters:

• inOrder bool If true, then the AOEs will return in order of appearance, instead of having each key be entityID. (default false)

Returns:

table List of GroundAOE, keys based on inOrder.

Argus.getCurrentTethers ()

Returns table where each key is number entityID and each value is table tethers. The list is all active tethers/chains/links between 2 entities. Each tether table has the following values: number type, number targetID. This type is similar to overhead marker types, each type will have exactly the same animation for every instance that shares that type (ex type 2 tethers will always look the same). However, how or when the tether resolves, is not known to the client.

Returns:

table List where each key is number entityID and each value is table tethers.

Usage:

-- simple function to print all tethers on player
local tethers = Argus.getCurrentTethers()

for id, ts in pairs(tethers) do
    for t = 1, #ts do -- there can be multiple tethers going from one entity
        local tether = ts[t]
        if tether.targetid == Player.id then
            d("Entity " .. id .. " is tethered to player with type " .. tether.type)
        end
    end
end

Argus.getEntityAuras (ent)

Returns the current auras on the target entity. This function returns 3 values: persistentAura, activeAura1, activeAura2.

Parameters:

• ent int or table Entity Object (from EntityList:Get()) or entity ID to check

Returns:

1. int persistentAura
2. int activeAura1
3. int activeAura2

Argus.getEntityModel (ent)

Sometimes contentid isn't enough to distinguish an entity (such as housing target dummies), in which case this function will provide a subcontentid.

Parameters:

• ent int or table Entity Object (from EntityList:Get()) or entity ID to check

Returns:

int modelID

Argus.getMisdirectionHeading ()

This is for buffs where the finger points above the players head in a direction, and the player is forced to go in that direction. This mechanic is always associated with a buff. Examples include first boss of Vanaspati, and the final boss of Alzadaal's Legacy. While Vanaspati is the standard mechanic where the game spins the finger, Alzadaal has a special variant of this mechanic where the player can control the direction of this finger. For this mechanic, use Argus.setMisdirectionHeading to set the direction and Player:Move(FFXIV.MOVEMENT.FORWARD) to move in that direction.

Returns:

number Heading in radians, betwee -pi and +pi, same format as the game.

Argus.getSpellAOEInfo (id)

Returns a structure similar to DirectionalAOE or GroundAOE but without any instance specific data. That is, there will be no entity/target attach nor any position info. However the other identifiers will be present. Can be combined with onEntityCast to draw snapshots after an aoe has been casted.

Parameters:

• id

Returns:

table

Argus.getTethersOnEnt (entityID)

Returns a list of tethers that are attached to entity. This includes tethers that are both going from entity, and attached to entity. Each tether object in the list has 2 fields, .type and .partnerid

Parameters:

• entityID int ID of the entity to get tethers for

Returns:

table List of tethers attached to entity

Usage:

local pTethers = Argus.getTethersOnEnt(Player.id) -- returned table is a list, indices are keys and not entity ID

-- draw a circle on all entities tethered to player
for i = 1, #pTethers do
    local tether = pTethers[i]
    local partner = EntityList:Get(tether.partnerid)
    if partner ~= nil then
        Argus.addCircleFilled(
            partner.pos.x,
            partner.pos.y,
            partner.pos.z,
            3,
            30,
            GUI:ColorConvertFloat4ToU32(1, 1, 0, 0.1),
            GUI:ColorConvertFloat4ToU32(1, 1, 0, 1),
            1.5
        )
    end
end

Argus.isEntityVisible (ent)

Returns whether or not the entity is visible to the player.

Parameters:

• ent int or table Entity Object (from EntityList:Get()) or entity ID to check

Returns:

bool True if entity is visible to the player, false if not

Argus.registerOnEntityCast (func)

Registers func into entity cast func list. This func will get called any time the server sends a successful entity cast packet to the client. This means that this function is almost 100% reliable to use. This is also useful to detect certain mechanics, such as Sirensong Sea 2nd boss, where there are 6 entities in the middle facing a certain way, and they cast an action with no preceding channel.

Parameters:

• func onEntityCastFunc

Argus.registerOnEntityChannel (func)

Registers func into entity channel func list. This func will get called any time the server sends a packet to the client, that entity has begun channeling. This means that the function is almost 100% reliable to use.

Parameters:

• func onEntityChannelFunc

Argus.registerOnMapEffect (func)

Registers func into on map effect func list. This function is called any time a visual map effect happens. For example: Zodiark snakes, star patterns in zodiark (when the arrows come down, to see what the star is), shiva savage mirror colors, wol triangle patterns, etc. Seems to be only used in shadowbringers and beyond, stormblood and before don't really have map effects, everything is done through channel animation or cast animations, or entities themselves.

Parameters:

• func onMapEffectFunc

Argus.registerOnMarkerAdd (func)

Registers func into marker func list, and func will get called any time there is an overhead marker added to an entity.

Parameters:

• func onMarkerAddFunc

Argus.registerOnTetherChange (func)

Registers func into on tether change func list. This function is called any time tether id, tether flags, or tether target id changes for a given enity. In other words, it reports any time an entity adds/removes/modifies it's tether. This can be useful to track certain changes since checking onupdate for tethers can be unreliable.

Parameters:

• func onTetherChangeFunc

Argus.setMisdirectionHeading (value)

This is for buffs where the finger points above the players head in a direction, and the player can adjust the direction of the finger with their movement. This mechanic is always associated with a buff. For example, the final boss of Alzadaal's Legacy has a special variant of this mechanic where the player can control the direction of this finger. Use this function to set the direction and Player:Move(FFXIV.MOVEMENT.FORWARD) to move in that direction.

Parameters:

• value number Heading in radians, betwee -pi and +pi, same format as the game.

onEntityCastFunc (entityID, actionID, castPosX, castPosY, castPosZ, heading, mainTargetID, targets)

Cast position may be nil if the cast was not casted at a specific position. For example, if the spell was casted on self, the position will be nil. Tip: You can get the radius of the ability through ActionList:Get(1, actionID).radius

Parameters:

• entityID int ID of the caster
• actionID int Spell ID of action being casted
• castPosX number X position of cast
• castPosY number Y position of cast
• castPosZ number Z position of cast
• heading number Heading of the casted ability, this is only used for rectangles and cones
• mainTargetID number This is the main target of the spell, however it may not be the target that gets hit by the spell. Use the targets list to get the targets hit. For example, if a white mage casts holy, the mainTargetID would be the player.id, but the targets list would contain the list of enemies hit.
• targets table List of target IDs the ability is cast on

onEntityChannelFunc (entityID, channelID, targetID, channelTimeMax)

Parameters:

• entityID int ID of the caster
• channelID int Spell ID of the ability being channeled
• targetID int Target that the spell is being channeled on
• channelTimeMax number How long the cast will be channeled for

onMapEffectFunc (a1, a2, a3)

The numbers/identifiers sent to this function are simply numbers to indicate which pattern it is. They appear to be indexes/types of map effects, however usually a combination of all this data can give you which pattern it is exactly.

Parameters:

• a1 int
• a2 int
• a3 int

onMarkerAddFunc (entityID, markerType)

Parameters:

• entityID int The id of the entity to which the marker is being added to.
• markerType int The marker type that is added to entity. Marker type is consistent across mechanics. A marker of type 2 will always have the same animation.

onTetherChangeFunc (sourceEntityID, oldTetherID, oldTetherFlags, oldTargetID, newTetherID, newTetherFlags, newTargetID)

Parameters:

• sourceEntityID int Source entity of the tether
• oldTetherID int Previous tether type/id
• oldTetherFlags int Previous tether flags
• oldTargetID int Previous target ID
• newTetherID int New tether type/id
• newTetherFlags int New tether flags
• newTargetID int New target ID