📖 Wall Plast Documentation

The programming language has a simple and intuitive syntax. The syntax is as follows: first comes a command (case doesn't matter), and parameters are separated by underscores _.

Basic syntax rules:

• Command name is case-insensitive (Log, log, LOG - all work the same)
• Parameters are separated by underscores _
• Text parameters are usually written in quotes for clarity to the script
• Multiple commands are separated by ; for sequential execution

Math in Scripts

The language supports mathematical calculations and lets you compute values right in the code. Supported operators: + (addition), - (subtraction), * (multiplication), / (division).

Assignment operators:

When you change values (position, text, etc), you can use different operators:

• = - set exact value
• += - add to current value
• -= - subtract from current value
• *= - multiply current value
• /= - divide current value

Working with text (concatenation):

Text values can be "concatenated" using +. This lets you combine text strings and variable values:

Scripts are attached to specific plate events. It's important to understand when each one triggers. The event determines the moment and conditions when your script will execute.

Event execution logic:

To manage objects in three-dimensional space (position, size, rotation), use the vector concept Vector3_X_Y_Z, where X, Y, Z are numbers, variable values, or mathematical expressions. X is horizontal position (left-right), Y is vertical position (up-down), Z is depth (forward-backward).

Applying a vector to an object:

You can apply the entire vector to an object to change all coordinates simultaneously:

Or change only a specific axis (x, y or z):

Supported axes: x, y, z

Working with vectors in math:

You can use mathematical expressions when creating vectors:

To display coordinates, properties, or calculation results on a text panel, add the _tostring suffix at the end of the variable or property.

Controls whether objects are active in the game world. Inactive objects are not rendered, don't interact with physics, and don't execute scripts. This is useful for hiding/revealing objects, managing scene complexity, and creating dynamic game mechanics.

Syntax:

Common use cases:

Allows you to manage speaker parameters in real time. Change music, volume, playback speed, working range and other properties of the audio source.

Syntax:

Parameters:

Usage examples:

Outputs debug messages to the developer console. Useful for tracking script execution, variable values, and diagnosing problems.

Syntax:

Message types:

Message types:

• Normal: Log_"Message"; (white message)
• Warning: Log_"Message"_"warning"; (yellow message)
• Error: Log_"Message"_"error"; (red message)

Stops script execution for a specified number of seconds. Useful for creating pauses between events, synchronizing animations, or creating delays in game logic.

Syntax:

Parameters:

Features:

• Time is specified in seconds
• Decimal numbers are supported for delays less than 1 second
• Mathematical expressions can be used
• While waiting, the rest of the code does not execute
• Variables can be used for time values

Executes a block of code a certain number of times.

Allows you to change object position, rotation, and scale.

Creates exact copies of objects during script execution.

Method 1: Automatic name

Method 2: Custom name

Method 3: Save to variable

Clone yourself:

Removes an object from the map during gameplay.

Connects objects in a hierarchy. Parented objects follow their parent's movement.

Parent block to another block:

Parent block to player:

Unparent object:

Parent player to platform:

Changes text on text objects.

Parameters:

• a - Text object name in quotes
• b - Text in quotes (supports + concatenation)

Difference between text and textraw:

• text - supports concatenation and variables
• textraw - inserts text as-is, without processing

Powerful command for interacting with players, changing stats, and teleporting.

Search modes (mode):

• target - search by target
• nickname - search by nickname
• saved - use saved player

Selectors for target:

• all - all players
• nearest - nearest player
• farthest - farthest player
• random - random player
• activated - player who triggered the plate
• local - local player

Usage examples:

Save a player:

All available parameters for controlling player characteristics.

Basic stats:

Stamina:

Variables are virtual "boxes" for storing values. Creating and modifying variables requires no special commands.

Variable types by scope:

Working with numbers and text:

The language has a built-in powerful random number generator that works like an "on-demand" variable. Instead of a variable name, you write the random command and the game automatically substitutes a random number! This lets you create diverse and unpredictable gameplay mechanics.

Basic syntax:

Random integer (int):

Generates an integer in the range, including boundaries:

Random float (with decimal):

Generates a number with a decimal part:

Random with step (rounding):

Generates a number that is a multiple of a specific step:

Practical usage examples:

Conditions allow you to execute different code depending on the situation.

Basic syntax:

Comparison operators:

• == - equal
• != - not equal
• > - greater than
• < - less than
• >= - greater than or equal
• <= - less than or equal

Logical operators:

• && - AND (both parts must be true)
• || - OR (at least one part must be true)

Password check example:

Player health check:

Complex check with AND/OR:

Operator contains checks if one text is inside another. Case-insensitive.

Syntax:

Check object name:

Password check:

Foreach is a loop that iterates through each element in a list (array) and stores the current element's name in a variable at each step. Inside the curly braces you write code that executes for EACH list element in sequence.

Syntax:

You can use any variable type (local_, global_, self_ etc) as the variable. At each step it will record the name (name) of the current object or player from the list.

Available lists (arrays):

• GetAllObjects - list of all objects present on the map
• GetAllPlayers - list of all players currently in the game
• transform_(a)_childs - list of child objects "attached" to object (a)
• player_(mode)_(selector)_childs - list of child objects "attached" to a player

Usage examples:

Each object in the world and each player has a name property that uniquely identifies them. Object names can be read and modified at any time, while player names are read-only for security reasons.

Object Names:

Every object has a unique name that persists if you save the map or clone the object.

Getting an object name:

Player Names (Name vs Nickname):

Players have two name properties:

Syntax for reading player names:

Modifying object names:

Object names can be changed during script execution. This is useful for tracking objects or simplifying references later.

Real-world usage examples: