🧰utils

Functions:

console_exec

utils.console_exec(cmd: string[, ...])

Executes a console command. Multiple commands can be combined with ';'. Be careful when passing user input (including usernames) to it.

execute_after

utils.execute_after(delay: number, callback: function[, ...])

Executes the callback after delay seconds, passing the arguments to it.

net_channel

utils.net_channel(): NetChannel

Returns the NetChannel struct.

trace_line

utils.trace_line(from: vector, to: vector[, skip: entity/table/function, mask: number, type: number]): trace

📌 The skip argument can either be an entity object, a table with entity objects, or a function, like the ShouldHitEntity callback. If you use it as a callback, you can access the entity and contents_mask by adding them to the function arguments. Inside the callback, return true if tracing should not skip the entity, otherwise return false.

Returns a trace struct containing all the information.

trace_hull

utils.trace_hull(from: vector, to: vector, mins: vector, maxs: vector[, skip: entity/table/function, mask: number, type: number]): trace

📌 The skip argument can either be an entity object, a table with entity objects, or a function, like the ShouldHitEntity callback. If you use it as a callback, you can access the entity and contents_mask by adding them to the function arguments. Inside the callback, return true if tracing should not skip the entity, otherwise return false.

Returns a trace struct containing all the information.

trace_bullet

utils.trace_bullet(from_entity: entity, from: vector, to: vector[, skip: entity/table/function]): number, trace

📌 The skip argument can either be an entity object, a table with entity objects, or a function, like the ShouldHitEntity callback. If you use it as a callback, you can access the entity and contents_mask by adding them to the function arguments. Inside the callback, return true if tracing should not skip the entity, otherwise return false.

Returns the damage, trace arguments.

🔗 struct trace

opcode_scan

utils.opcode_scan(module: string, signature: string[, offset: number]): userdata

Returns a pointer to the specified pattern if it was found. Otherwise returns nil.

create_interface

utils.create_interface(module: string, interface: string): userdata

Returns a pointer to the specified interface if it was found. Otherwise returns nil.

get_netvar_offset

utils.get_netvar_offset(table: string, prop: string): number

Returns the offset of the specified prop. Can be used to manually navigate to the net prop.

get_vfunc

utils.get_vfunc(index: number, ...): function

Creates and returns a wrapper function that calls a virtual table function on the specified index.

get_vfunc

utils.get_vfunc(module: string, interface: string, index: number, ...): function

Creates and returns a wrapper function that calls a virtual table function from the specified interface on the specified index.

random_int

utils.random_int(min: number, max: number): number

Returns a random integer value.

random_float

utils.random_float(min: number, max: number): number

Returns a random float value.

random_seed

utils.random_seed(seed: number)

Sets the new random seed.

🔗 NetChannel

time

net.time : number

Current network time.

time_connected

net.time_connected : number

Connection time in seconds.

time_since_last_received

net.time_since_last_received : number

Time since last received packet in seconds.

is_loopback

net.is_loopback : boolean

Returns true if server is a loopback (local server).

is_playback

net.is_playback : boolean

Returns true if demo is being played.

is_timing_out

net.is_timing_out : boolean

Returns true if client is timing out.

sequence_nr[flow]

net.sequence_nr[0] : number net.sequence_nr[1] : number

Last sent sequence number.

latency[flow]

net.latency[0] : number net.latency[1] : number

Current latency (RTT), more accurate but jittering.

avg_latency[flow]

net.avg_latency[0] : number net.avg_latency[1] : number

Average latency in seconds.

loss[flow]

net.loss[0] : number net.loss[1] : number

Percentage in the range [0.0, 1.0] of the current packet loss.

choke[flow]

net.choke[0] : number net.choke[1] : number

Percentage in the range [0.0, 1.0] of the current packet choke.

packets[flow]

net.packets[0] : number net.packets[1] : number

Average amount of packets/sec.

data[flow]

net.data[0] : number net.data[1] : number

Data flow in bytes/sec.

total_packets[flow]

net.total_packets[0] : number net.total_packets[1] : number

Total amount of packets/sec.

total_data[flow]

net.total_data[0] : number net.total_data[1] : number

Total data flow in bytes/sec.

:get_server_info

net:get_server_info(): table

Returns a table containing rate, name, address, frame_time, and deviation (or nil on failure).

:is_valid_packet

net:is_valid_packet(flow: number, frame: number): number

Returns true if the packet is valid.

:get_packet_time

net:get_packet_time(flow: number, frame: number): number

Returns the time when the packet was sent.

:get_packet_bytes

net:get_packet_bytes(flow: number, frame: number, group: number): number

Returns the group size of this packet.

:get_packet_response_latency

net:get_packet_response_latency(flow: number, frame: number): number, number

Returns latency_msecs, choke of this packet.