Bit and math built-ins

These functions operate on current 32-bit GPC integers. Valid bit indexes are 0..31. GPC integer division truncates, and arithmetic overflow must be prevented by the script.

set_bit

Compiler category: Bit Operations Backing opcode: sbit (sbita when the compiler selects an array form)

Sets one bit in a writable variable.

Syntax

set_bit(variable, bit_index);

Parameters

• variable: a runtime variable to modify; an expression or const value is not accepted.

• bit_index: 0..31, where 0 is the least-significant bit.

Returns

Nothing. The first argument is modified.

Example

int flags;

main {
    if(event_press(PS5_CROSS)) set_bit(flags, 3);
    set_val(TRACE_1, flags);
}

---

clear_bit

Compiler category: Bit Operations Backing opcode: cbit (cbita for the compiler-selected array form)

Clears one bit in a writable variable without changing its other bits.

Syntax

clear_bit(variable, bit_index);

Parameters

• variable: a runtime variable to modify.

• bit_index: 0..31.

Returns

Nothing.

Example

int flags = 15;

main {
    if(event_press(PS5_CIRCLE)) clear_bit(flags, 2);
    set_val(TRACE_1, flags);
}

---

test_bit

Compiler category: Bit Operations Backing opcode: tbit

Tests whether one bit is set.

Syntax

result = test_bit(value, bit_index);

Parameters

• value: the integer to inspect.

• bit_index: 0..31.

Returns

TRUE when the bit is set; otherwise FALSE.

Example

int flags = 8;
int feature_enabled;

main {
    feature_enabled = test_bit(flags, 3);
    set_val(TRACE_1, feature_enabled);
}

---

set_bits

Compiler category: Bit Operations Backing opcode: sbits (sbitsa for the compiler-selected array form)

Writes a masked multi-bit field into a writable variable at a starting bit index.

Syntax

set_bits(variable, value, bit_index, bit_mask);

Parameters

• variable: the runtime variable to modify.

• value: the field value to insert.

• bit_index: starting position 0..31.

• bit_mask: the low-bit mask describing the field width, such as 0x0F for four bits.

Returns

Nothing.

Example

int packed;

main {
    // Store value 9 in the four-bit field beginning at bit 4.
    set_bits(packed, 9, 4, 0x0F);
    set_val(TRACE_1, packed);
}

Keep the mask and starting index identical when the field is later read.

---

get_bits

Compiler category: Bit Operations Backing opcode: gbits

Extracts a masked field and shifts it down to the low bits.

Syntax

result = get_bits(value, bit_index, bit_mask);

Parameters

• value: packed integer to inspect.

• bit_index: starting position 0..31.

• bit_mask: low-bit mask for the field.

Returns

The extracted field value.

Example

int packed = 0x90;
int field;

main {
    field = get_bits(packed, 4, 0x0F);
    set_val(TRACE_1, field); // 9
}

---

abs

Compiler category: Math Functions Backing opcode: abs

Returns the magnitude of a signed value.

Syntax

result = abs(expression);

Parameters

• expression: any current-target integer expression.

Returns

The non-negative magnitude. Avoid the INT32_MIN edge because its positive magnitude is outside the signed 32-bit range.

Example

int stick_distance;

main {
    stick_distance = abs(get_ival(PS5_RX));
    if(stick_distance > 70) set_val(TRACE_1, 1);
}

---

inv

Compiler category: Math Functions Backing opcode: inv

Negates a value. This is equivalent to multiplying by -1.

Syntax

result = inv(expression);

Parameters

• expression: integer expression to negate.

Returns

The sign-inverted value.

Example

main {
    set_val(PS5_RY, inv(get_ival(PS5_RY)));
}

---

pow

Compiler category: Math Functions Backing opcode: pow

Raises a base integer to an integer exponent.

Syntax

result = pow(base, exponent);

Parameters

• base: integer base.

• exponent: integer exponent accepted by the target function.

Returns

The integer power result.

Example

int cubed;

init {
    cubed = pow(5, 3); // 125
}

Powers grow quickly. Prove the result remains inside the signed 32-bit range before using runtime-controlled inputs.

---

isqrt

Compiler category: Math Functions Backing opcode: isqrt

Calculates an integer square root and discards any fractional part.

Syntax

result = isqrt(value);

Parameters

• value: non-negative integer whose square root is required.

Returns

The truncated integer square root.

Example

int root;

init {
    root = isqrt(10); // 3
}

Validate or clamp runtime input so a negative value is never passed.

---

random

Compiler category: Miscellaneous Functions Backing opcode: rand

Returns a pseudo-random integer between the supplied bounds.

Syntax

result = random(minimum, maximum);

Parameters

• minimum: lower signed 32-bit bound.

• maximum: upper signed 32-bit bound.

Returns

A pseudo-random integer in the requested range.

Example

int delay_ms;

main {
    if(event_press(PS5_CROSS)) delay_ms = random(40, 80);
    set_val(TRACE_1, delay_ms);
}

Keep minimum <= maximum and do not use this as a security or authorization mechanism.

---

clamp

Compiler category: Bit Operations Backing opcode: clamp

Restricts a value to an inclusive lower and upper bound.

Syntax

result = clamp(value, low, high);

Parameters

• value: value to restrict.

• low: minimum permitted result.

• high: maximum permitted result.

Returns

low when the value is too small, high when it is too large, or the original value when already in range.

Example

int output_x;

main {
    output_x = clamp(get_ival(PS5_RX) * 2, -100, 100);
    set_val(PS5_RX, output_x);
}

---

min

Compiler category: Bit Operations Backing opcode: min

Returns the smaller of two integers.

Syntax

result = min(value1, value2);

Parameters

• value1: first integer.

• value2: second integer.

Returns

The smaller value.

Example

int limited_trigger;

main {
    limited_trigger = min(get_ival(PS5_R2), 50);
    set_val(TRACE_1, limited_trigger);
}

---

max

Compiler category: Bit Operations Backing opcode: max

Returns the larger of two integers.

Syntax

result = max(value1, value2);

Parameters

• value1: first integer.

• value2: second integer.

Returns

The larger value.

Example

int trigger_floor;

main {
    trigger_floor = max(get_ival(PS5_R2), 25);
    set_val(TRACE_1, trigger_floor);
}

Back to the additional built-in index