📖 Wall Plast Documentation

The scripting language features a direct, easy-to-learn structure. First comes the command name (case-insensitive), followed by parameters separated by underscores _.

Primary Syntax Rules:

• Commands are case-insensitive (Log, log, and LOG execute identically).
• Parameters must be separated using a single underscore character _.
• Text parameters are enclosed in quotation marks "" to facilitate internal script processing.
• Separate distinct commands using a semicolon ; for consecutive execution.

Mathematical Operations

The engine supports math calculations dynamically within scripts. Supported operations: + (addition), - (subtraction), * (multiplication), and / (division).

Assignment Operators:

Use assignment operators to alter values of variables, spatial offsets, and textual strings:

• = - Overwrites with the exact specified value.
• += - Increases the current value.
• -= - Decreases the current value.
• *= - Multiplies the current value.
• /= - Divides the current value.

String Concatenation:

You can dynamically join text strings and numerical values using the + sign:

Scripts are bound to designated structural events belonging to active game plates. Understanding the precise timing and execution behaviors of plate events is essential to crafting robust mechanics.

Logical Event Flowchart:

3D assets utilize vectors denoted by the Vector3_X_Y_Z structure, representing spatial positions, rotation parameters, and bounding scales. X controls horizontal left/right axis, Y controls vertical up/down elevation, and Z defines depth axis.

Applying spatial modifications:

You may override the complete coordinate properties of a target object in one call:

Or shift single dimensional parameters (x, y, or z):

Evaluating mathematical operations within vectors:

Convert numerical coordinates, properties, or variables to strings to display them on message signs or textual canvas items using the _tostring suffix.

In addition to relying on user-defined storage variables, you can read properties from players or objects on the map directly inside mathematical operations or string concatenations!

Controls visibility and interactivity of items. Inactive objects are completely hidden, perform no physics calculations, do not collide, and ignore execution calls.

Syntax: SetActive_(a)_(b)

Modifies target music players and speaker states in real-time. This command controls play status, volume parameters, reach limits, and general UI model properties.

Syntax:

Required Parameters:

Outputs textual strings or variable logs onto the developer debug console screen.

Syntax: Log_(a)_(b)

• a - Text parameter containing debug details (supports string concatenation).
• b - Optional categorizer: use "warning" (highlights in yellow) or "error" (highlights in red).

Halts script progress for the specified amount of seconds. Fractional float notations are fully supported.

Repeats execution of the enclosed code block. Loop iteration parameters accept either integer quantities or the inf key to create a persistent loop.

Controls position offsets, angle parameters, and bounds of targeted world items.

Syntax: transform_(a)_(b)_(c) = (d)

• a - Name of targeted item (e.g. "Platform").
• b - Selected property: position, localposition, rotation, localrotation, or scale.
• c - Selected axis dimension (optional): x, y, or z.
• d - Numerical value or Vector3 statement.

Creates duplicates of objects during active gameplay. Duplicates inherit all original properties, scripting layers, and assets.

Creating a clone with automated naming:

Creating a clone with a specific name:

Cloning self:

Recording cloned references directly into variables:

Removes targeted objects from the game map dynamically during runtime.

Creates parent-child relationships between physical objects or players, making child objects follow the coordinates, scaling changes, and rotation offsets of their parent assets.

Modifies text displayed on world canvas items.

• text - Processes mathematical statements, operations, and variables inside the string.
• textraw - Displays the assigned characters exactly as written without translating scripting variables.

A set of properties to control player positions, stats, and states during runtime.

Query Modes (mode):

• target - Scans based on targeting conditions.
• nickname - targets using exact player nickname.
• saved - Reference to a saved player reference.

Filters under targeting:

• all - Targets every single active player.
• nearest - targets the closest player to the plate.
• farthest - targets the furthest player from the plate.
• random - targets a random active player.
• activated - targets the player who triggered the plate event.
• local - targets the client player.

Reference Syntax: player_(mode)_(selector)_(stat)

Saving references:

You can record player references into temporary script files to target them persistently regardless of physical proximity changes:

You can dynamically read or write health, physical, speed, and recovery properties on players. Modify the targeting stat key with any of the following variables:

General Metrics:

Stamina Properties:

Manipulate camera perspectives, zoom thresholds, and field-of-view limits for players. These settings use the standard player query syntax: player_(mode)_(selector)_(stat).

Variables serve as storage containers for numbers or string text. You do not need to pre-declare variables; simply assign a value to instantiate them.

Variable Types & Execution Scope:

Use the integrated random number generator to create unpredictability and dynamic mechanics. It evaluates directly on execution.

Basic Syntax: random_(Min)_(Max)

Random Integer Selection:

Random Float Selection (Decimals):

Random Step Increments (Rounding):

Conditions route execution flows based on dynamic variables, player stats, or spatial properties.

Comparison Operators:

• == (equality check), != (inequality check)
• > (greater than), < (less than)
• >= (greater than or equal), <= (less than or equal)

Logical Joining:

• && (Logical AND - true only if both statements evaluate to true).
• || (Logical OR - true if at least one statement evaluates to true).

Checks if a substring exists within a targeted block of text. The search is case-insensitive.

Syntax: if (textString contains subString) { ... }

Arrays allow storing multiple values in a single variable. In Wall Plast, custom arrays are created through string variables where values are separated by commas ,. Individual elements can be accessed by their index (position) using square brackets [index].

Creating an Array

Simply assign a string with comma-separated elements to a variable:

Reading an Element by Index

Use square brackets with the element number:

Modifying an Element by Index

You can replace any array element by specifying its index:

Counting Array Elements (_count)

Get the number of elements in an array using the _count suffix:

Using Arrays in Conditions

You can compare array elements or check their count:

Iterating an Array with foreach

You can loop through all array elements using the array name as a collection:

Indexing Built-in Lists

Square brackets work not only with custom arrays, but also with built-in lists:

Iterates through a list of objects or players, executing the enclosed code block for each element. The variable specified in the loop captures the name of the current item on each iteration.

Syntax: foreach (temp_variable in active_list) { ... }

Available Core Arrays:

• GetAllObjects - Fetches every physical object currently spawned on the map.
• GetAllPlayers - Fetches all players currently logged in the game session.
• transform_"ObjectName"_childs - List of direct children bound to "ObjectName".
• player_target_activated_childs - List of direct children bound to the active player.

Each plate tracks all players currently standing on its surface. This array is named standingplayers, and can be queried from the active plate or any external plate by its name.

Querying player quantities:

• plate_"self"_standingplayers_count - Number of players on this plate.
• plate_"OtherPlate"_standingplayers_count - Number of players on the plate named "OtherPlate".

Iterating through players standing on a plate:

Append the _count suffix to any array statement to get its total item quantity immediately without running manual iteration loops.

Counting Arrays:

Deep Child Hierarchy Searches (_true)

Standard child requests like transform_"Block"_childs only return immediate descendants. Append the _true suffix to recursively fetch all descendants (children, grandchildren, great-grandchildren, etc.).

• transform_"Block"_childs_true - List of all descendants at any nesting level.
• transform_"Block"_childs_true_count - Total count of direct and nested descendants.

Each object and player has a name property. Object names can be read and modified dynamically, while player names are read-only for security reasons.

Object Names:

Read the name of an object using transform_"Block"_name:

Player Names (Name vs Nickname):

Modifying object names during execution:

Control the scene's fog (Unity's RenderSettings) directly from a plate script - toggle it on\off, change its color, distance and density.

Reading fog parameters (for example, inside if conditions): the same parameters are available in lowercase with the fog_ prefix (without the Fog word used in assignment commands):

The map always has a single service object holding the game settings, which has a flag that syncs the scene fog between every player on the server. When enabled, the host's fog parameters are automatically applied to all players. This flag can be controlled directly from a plate script.

The current state of the flag can also be read inside a condition:

Besides the numbers 1 and 0, conditions and math expressions now also accept the words true and false - they are automatically treated as 1 and 0 respectively. Letter case doesn't matter (TRUE, False, true all behave identically).