Dcurrent at 01:02, 22 July 2026

2026-07-22T01:02:45Z

@@ Line 172: / Line 172: @@
 The <code>message</code> local variable remains available to both functions because they execute within the same script instance.
 [[Category:Script]]
 [[Category:Openbor]]

Dcurrent at 21:51, 21 July 2026

2026-07-21T21:51:27Z

← Older revision		Revision as of 17:51, 21 July 2026
Line 1:		Line 1:
			== Introduction ==
	Variables are named identifiers that store values. Anyone who has worked with algebra has already used variables. They are one of the fundamental building blocks of scripting.		Variables are named identifiers that store values. Anyone who has worked with algebra has already used variables. They are one of the fundamental building blocks of scripting.

Line 171:		Line 172:

	The <code>message</code> local variable remains available to both functions because they execute within the same script instance.		The <code>message</code> local variable remains available to both functions because they execute within the same script instance.

	~~[[Category:OpenBOR Index]]~~
	[[Category:Script]]		[[Category:Script]]
			[[Category:Openbor]]

Dcurrent: Created page with "Variables are named identifiers that store values. Anyone who has worked with algebra has already used variables. They are one of the fundamental building blocks of scripting. == Type == Variable type describes the kind of data a variable contains and how that data behaves in expressions and operations. OpenBOR Script is weakly typed. Every variable is stored internally as a variant, and the engine may change its type automatically as values are assigned or operations..."

2026-07-21T21:50:32Z

Created page with "Variables are named identifiers that store values. Anyone who has worked with algebra has already used variables. They are one of the fundamental building blocks of scripting. == Type == Variable type describes the kind of data a variable contains and how that data behaves in expressions and operations. OpenBOR Script is weakly typed. Every variable is stored internally as a variant, and the engine may change its type automatically as values are assigned or operations..."

New page

Variables are named identifiers that store values. Anyone who has worked with algebra has already used variables. They are one of the fundamental building blocks of scripting.

== Type ==

Variable type describes the kind of data a variable contains and how that data behaves in expressions and operations.

OpenBOR Script is weakly typed. Every variable is stored internally as a variant, and the engine may change its type automatically as values are assigned or operations are performed. Declaration prefixes such as <code>int</code>, <code>float</code>, and <code>char</code> indicate the intended type, but do not enforce it unless [[Type Guards|type guards]] are enabled.

Weak typing reduces the need for manual conversions, though creators should remain aware of the type a variable currently contains.

<syntaxhighlight lang="c" line>
int value = 0;

value = value + " is a string";

// value = "0 is a string"
</syntaxhighlight>

In a strongly typed C program, combining an integer and string this way would produce a type error. OpenBOR Script instead converts the result to a string and assigns both its value and type to <code>value</code>.

=== Type Inspection ===

Use <code>typeof()</code> to determine the current type of a variable. The function returns an integer constant representing the variant type.

<syntaxhighlight lang="c" line>
mixed value = "Example";

int variable_type = typeof(value);

if (variable_type == openborconstant("VT_STR")) {
log("The value is a string.");
}
</syntaxhighlight>

{| class="wikitable"
! Type
! Constant
! Example
! Notes
|-
| Decimal
| <code>openborconstant("VT_DECIMAL")</code>
| <code>float value = 0.1;</code>
| Floating-point numeric value stored internally as a C <code>double</code>. Decimal literals must include a leading digit, so <code>0.1</code> is valid while <code>.1</code> is not. Current builds provide approximately 15-17 significant decimal digits and a maximum magnitude of approximately 1.7 × 10<sup>308</sup>.
|-
| Integer
| <code>openborconstant("VT_INTEGER")</code>
| <code>int value = 1;</code>
| Signed 32-bit whole number ranging from <code>-2,147,483,648</code> to <code>2,147,483,647</code>. Integers promote to a 64-bit carrier when an operation or literal exceeds this range.
|-
| Integer 64
| <code>openborconstant("VT_INTEGER64")</code>
| <code>int value = 1LL;</code>
| Signed 64-bit whole number ranging from <code>-9,223,372,036,854,775,808</code> to <code>9,223,372,036,854,775,807</code>. The <code>LL</code> suffix explicitly requests a 64-bit signed literal. Unsuffixed values also promote automatically when required.
|-
| Unsigned Integer 64
| <code>openborconstant("VT_UINTEGER64")</code>
| <code>int value = 1ULL;</code>
| Unsigned 64-bit whole number ranging from <code>0</code> to <code>18,446,744,073,709,551,615</code>. The <code>ULL</code> suffix explicitly requests an unsigned 64-bit literal.
|-
| Empty
| <code>openborconstant("VT_EMPTY")</code>
| <code>mixed value = NULL();</code>
| Undefined variable or value containing no data.
|-
| Pointer
| <code>openborconstant("VT_PTR")</code>
| <code>void entity = getlocalvar("self");</code>
| Reference to a memory address. Pointers commonly reference structured engine objects such as entities, models, animations, or collections.
|-
| String
| <code>openborconstant("VT_STR")</code>
| <code>char value = "Example";</code>
| Collection of characters representing text.
|}

=== Strings and Numeric Conversion ===

Strings are not implicitly parsed back into numeric values. Assigning a numeric value directly to a variable can change its type, but numeric text must be converted before it can participate in arithmetic.

Use <code>string_to_float()</code> or <code>string_to_int()</code> to convert numeric text:

<syntaxhighlight lang="c" line>
char string_value = "5";

int integer_value = string_to_int(string_value);
float decimal_value = string_to_float(string_value);
</syntaxhighlight>

After conversion, <code>integer_value</code> and <code>decimal_value</code> may be used in arithmetic expressions.

== Scope ==

Scope determines where a variable is accessible and how long it remains available. Creators should generally use the narrowest scope suitable for a task.

=== Function Variables ===

Variables declared inside a function are visible only within that function call. They are created when execution enters the function and destroyed when the function returns.

These are commonly called local variables in other programming languages. OpenBOR documentation refers to them as ''function variables'' to distinguish them from the persistent script storage accessed through <code>getlocalvar()</code> and <code>setlocalvar()</code>.

<syntaxhighlight lang="c" line>
void some_function() {
int value = 10;

log(value);
}
</syntaxhighlight>

Other functions cannot directly access <code>value</code>.

=== Global Variables ===

<syntaxhighlight lang="c" line>
setglobalvar("identifier", value);

mixed value = getglobalvar("identifier");
</syntaxhighlight>

Global variables are available to all scripts and functions through a shared identifier. They may also be stored with saved game data and restored during a later session.

Global variables are powerful, though excessive use can make state changes difficult to trace and debug. Prefer narrower scopes unless information genuinely needs to be shared throughout the entire game.

=== Entity Variables ===

<syntaxhighlight lang="c" line>
setentityvar(entity, "identifier", value);

mixed value = getentityvar(entity, "identifier");
</syntaxhighlight>

Entity variables associate a value with a specific entity. Any script with a pointer to that entity may access the value using its identifier.

Entity variables remain available until the associated entity is destroyed.

<syntaxhighlight lang="c" line>
void main() {
void entity = getlocalvar("self");

setentityvar(entity, "birthdate", "2004-01-01");
}
</syntaxhighlight>

Entity variables are useful for storing custom state without placing it in the global variable collection.

=== Local Variables ===

<syntaxhighlight lang="c" line>
setlocalvar("identifier", value);

mixed value = getlocalvar("identifier");
</syntaxhighlight>

OpenBOR local variables belong to an individual script instance. Every function executed by that instance may access them, and their values remain available across repeated executions. The engine destroys them automatically when the script instance is destroyed.

Local variables are useful for sharing information between functions without passing numerous parameters or using global storage.

<syntaxhighlight lang="c" line>
void main() {
setlocalvar("message", "Hello world!");

print_message();
}

void print_message() {
char message = getlocalvar("message");

log(message);
}
</syntaxhighlight>

The <code>message</code> local variable remains available to both functions because they execute within the same script instance.

[[Category:OpenBOR Index]]
[[Category:Script]]

Variables Overview - Revision history

Dcurrent at 01:02, 22 July 2026

Dcurrent at 21:51, 21 July 2026