script-sdk/org.tribot.script.sdk.query/WidgetQuery

WidgetQuery

open class WidgetQuery : StreamBackedQuery<Widget, WidgetQuery> , ActionableQuery<Widget, WidgetQuery> , ClickableQuery<Widget, WidgetQuery> , IndexableQuery<Widget, WidgetQuery>

A query to search over entities of type Widget

Functions

actionContains

open fun actionContains(actions: Array<String>): QueryType

Checks if any of the actions of this entity contains any of the specified actions, case insensitive

actionEquals

open fun actionEquals(actions: Array<String>): QueryType

Checks if any of the actions of this entity equal any of the specified actions, case sensitive

actionNotContains

open fun actionNotContains(actions: Array<String>): QueryType

Checks if none of the actions of this entity contains any of the specified actions, case insensitive

actionNotEquals

open fun actionNotEquals(actions: Array<String>): QueryType

Checks if none of the actions of this entity equal any of the specified actions, case sensitive

animationEquals

open fun animationEquals(animationId: Array<Int>): WidgetQuery

Only match widgets whose animation id does not exactly equal any of the specified animation ids

animationNotEquals

open fun animationNotEquals(animationId: Array<Int>): WidgetQuery

Only match widgets whose animation id does not exactly equal any of the specified animation ids

asQueryType

protected fun asQueryType(): QueryType

bank

open fun bank(): BankQuery

Creates a new BankQuery

count

open fun count(): Int

Executes this query and gets the number of results

createSourceStream

protected open fun createSourceStream(): Stream<Widget>

equipment

open fun equipment(): EquipmentQuery

Creates a new EquipmentQuery

filter

open fun filter(filter: Predicate<EntityType>): QueryType

Applies the specified filter to this query.

findFirst

open fun findFirst(): Optional<EntityType>

Executes this query, and gets the first result if it exists

findRandom

open fun findRandom(): Optional<EntityType>

Executes this query, and selects a random result based on a uniform distribution

forEach

open fun forEach(consumer: Consumer<EntityType>)

Executes this query and passes each result to the specified consumer

gameObjects

open fun gameObjects(): GameObjectQuery

Creates a new GameObjectQuery

grandExchangeOffers

open fun grandExchangeOffers(): GrandExchangeOfferQuery

Creates a new GrandExchangeOfferQuery

graphicObjects

open fun graphicObjects(): GraphicObjectQuery

Creates a new GraphicObjectQuery

groundItems

open fun groundItems(): GroundItemQuery

Creates a new GroundItemQuery

hasChildren

open fun hasChildren(): WidgetQuery

Only match widgets who have children

heightEquals

open fun heightEquals(height: Array<Int>): WidgetQuery

Only match widgets whose height exactly equals one of the specified heights

heightNotEquals

open fun heightNotEquals(height: Array<Int>): WidgetQuery

Only match widgets whose height does not exactly equal any of the specified heights

indexEquals

open fun indexEquals(index: Array<Int>): QueryType

Only match entities with the specified index

indexNotEquals

open fun indexNotEquals(index: Array<Int>): QueryType

Only match entities who do not have the specified index

inIndexPath

open fun inIndexPath(indexPath: Array<Int>): WidgetQuery

Adds the specified index path as one of the roots that will be searched.

inRoots

open fun inRoots(roots: Array<Int>): WidgetQuery

See how inIndexPath works - this is equivalent to:

    for (int i : roots) {
        inIndexPath(i);
    }

inventory

open fun inventory(): InventoryQuery

Creates a new InventoryQuery

isAnimating

open fun isAnimating(): WidgetQuery

Only match widgets that are animating

isAny

open fun isAny(): Boolean

Executes this query and checks if any result exists

isDepth

open fun isDepth(depth: Array<Int>): WidgetQuery

Requires that any matching widget be of the specified depth (depth is widget.getIndexPath().length)

isHovering

open fun isHovering(): QueryType

Only match entities that are being hovered

isItem

open fun isItem(): WidgetQuery

Only matches widgets that represent an item

isItemTable

open fun isItemTable(): WidgetQuery

Only matches widgets that represent an item table

isNotAnimating

open fun isNotAnimating(): WidgetQuery

Only match widgets that are not animating

isNotDepth

open fun isNotDepth(depth: Array<Int>): WidgetQuery

Requires that any matching widget not be of the specified depth (depth is widget.getIndexPath().length)

isNotHovering

open fun isNotHovering(): QueryType

Only match entities that are not being hovered

isNotVisible

open fun isNotVisible(): QueryType

Only match clickable entities that are not visible

isVisible

open fun isVisible(): QueryType

Only match clickable entities that are visible

itemDefinitions

open fun itemDefinitions(): ItemDefinitionQuery

Creates a new ItemDefinitionQuery

maxHeight

open fun maxHeight(height: Int): WidgetQuery

Only match widgets whose height is at most the specified max height

maxWidth

open fun maxWidth(width: Int): WidgetQuery

Only match widgets whose width is at most the specified max width

minHeight

open fun minHeight(height: Int): WidgetQuery

Only match widgets whose height is at least the specified min height

minWidth

open fun minWidth(width: Int): WidgetQuery

Only match widgets whose width is at least the specified min width

modelIdEquals

open fun modelIdEquals(modelId: Array<Int>): WidgetQuery

Only match widgets with the specified model id

modelIdNotEquals

open fun modelIdNotEquals(modelId: Array<Int>): WidgetQuery

Only match widgets without the specified model id

nameContains

open fun nameContains(name: Array<String>): WidgetQuery

Only matches widgets whose name contains any of the specified names

nameEquals

open fun nameEquals(name: Array<String>): WidgetQuery

Only matches widgets whose name equals any of the specified names

nameNotContains

open fun nameNotContains(name: Array<String>): WidgetQuery

Only matches widgets whose name does not contain any of the specified names

nameNotEquals

open fun nameNotEquals(name: Array<String>): WidgetQuery

Only matches widgets whose name does not equal any of the specified names

npcs

open fun npcs(): NpcQuery

Creates a new NpcQuery

players

open fun players(): PlayerQuery

Creates a new PlayerQuery

positionEquals

open fun positionEquals(p: Array<Point>): WidgetQuery

Only match widgets whose position equals one of the specified points

positionNotEquals

open fun positionNotEquals(p: Array<Point>): WidgetQuery

Only match widgets whose position does not equal one of the specified points

projectiles

open fun projectiles(): ProjectileQuery

Creates a new ProjectileQuery

shop

open fun shop(): ShopItemQuery

Creates a new ShopItemQuery

sorted

open fun sorted(comparator: Comparator<EntityType>): QueryType

Orders the query by the specified comparator.

stream

open fun stream(): Stream<EntityType>

Returns this query as a stream.

textColorEquals

open fun textColorEquals(color: Array<Int>): WidgetQuery

Only match widgets with the specified text color

textColorNotEquals

open fun textColorNotEquals(color: Array<Int>): WidgetQuery

Only match widgets without the specified text color

textContains

open fun textContains(text: Array<String>): WidgetQuery

Only matches widgets whose text contains any of the specified texts

textEquals

open fun textEquals(text: Array<String>): WidgetQuery

Only matches widgets whose text equals any of the specified texts

textNotContains

open fun textNotContains(text: Array<String>): WidgetQuery

Only matches widgets whose text does not contain any of the specified texts

textNotEquals

open fun textNotEquals(text: Array<String>): WidgetQuery

Only matches widgets whose text does not equal any of the specified texts

textureIdEquals

open fun textureIdEquals(textureId: Array<Int>): WidgetQuery

Only match widgets with the specified texture id

textureIdNotEquals

open fun textureIdNotEquals(textureId: Array<Int>): WidgetQuery

Only match widgets without the specified texture id

tiles

open fun tiles(): TileQuery

Creates a new TileQuery

toItemQuery

open fun toItemQuery(): WidgetItemQuery

Converts this widget query to an widget item query that will match any of the widgets of this query, but the entity to search over is in the form of an org.tribot.script.sdk.interfaces.Item.

toList

open fun toList(): List<EntityType>

Executes this query, and gets the results

trade

open fun trade(): TradeQuery

Creates a new TradeQuery

widgets

open fun widgets(): WidgetQuery

Creates a new WidgetQuery

widthEquals

open fun widthEquals(width: Array<Int>): WidgetQuery

Only match widgets whose width exactly equals one of the specified widths

widthNotEquals

open fun widthNotEquals(width: Array<Int>): WidgetQuery

Only match widgets whose width does not exactly equal any of the specified widths

worlds

open fun worlds(): WorldQuery

Creates a new WorldQuery

WidgetQuery

See also

Functions