Classes

A class is a group of commands applied to the in-game entities: player, peds, objects, etc. For example, the Player class groups the commands performed over the player character.

General Syntax

Syntax: <Class name>.<Class member>(parameters)

Class name - the name of a group of commands defined in the classes.db file for this edit mode Class member - one of the commands included in the class Parameters - 0 or more comma-delimited parameters

Player.SetMinWantedLevel($PLAYER_CHAR, 2)

Player - class name SetMinWantedLevel - class member $PLAYER_CHAR, 2 - two parameters for SetMinWantedLevel

There are three types of class members:

  • conditions

  • methods

  • properties

Conditions

The list that appears when you press Ctrl+Space marks conditional commands with the word Check. They are used in conditional expressions:

if
Player.Defined($PLAYER_CHAR)
jf @anywhere

Methods

Methods are regular commands used to complete a single in-game action, e.g. moving an object, destroying a vehicle, etc.:

Object.PutAt($crate, 10.0, -25.5, 12.2)
Car.Destroy($car)

They are marked with the work proc in the list of class members.

A special kind of methods is a constructor. A constructor creates a new instance of a class and stores its handle to a variable.

In Sanny Builder the constructor can be written in two equivalent ways:

Player.Create($PLAYER_CHAR, #NULL, 2488.5601, -1666.84, 13.38)
$PLAYER_CHAR = Player.Create(#NULL, 2488.5601, -1666.84, 13.38)

Properties

Property allows you to access class attributes and/or modify them.

For example, the .Money property of the Player class allows to operate with the amount of money of the player:

Player($PLAYER_CHAR).Money += 1000000 // add more money
Player($PLAYER_CHAR).Money > 461@ // check the amount
4@ = Player($PLAYER_CHAR).Money // read the amount and store in variable

In the current version the compiler ignores whitespace characters in string literals used in property parameters:

0@ = File.Open("file name","wb")

will be compiled as:

0@ = File.Open("filename","wb")

Class Instances

Almost all class members take a variable as the first parameter. This variable holds a handle of the class instance which is a concrete in-game entity the command is applied to:

Player.Build($PLAYER_CHAR)

$PLAYER_CHAR - the class instance.

For some in-game entities there is only one instance to exist. An example of that would be the camera that controls what the player can see. The members of classes for such entities do not require a variable with the class instance:

Camera.SetBehindPlayer()

Declaring a class instance

Variables can be declared using a class name as the type:

var
$PLAYER_CHAR: Player
end

It instructs the compiler that $PLAYER_CHAR holds an instance of the class Player. This variable can serve as an alias to the class name:

if
$PLAYER_CHAR.Defined
jf @anywhere

If a variable substitutes a class name, the compiler also makes it the first parameter, hence no need to use it again in the list of parameters:

$PLAYER_CHAR.SetClothes("PLAYER_FACE", "HEAD", Head)

is equivalent to:

Player.SetClothes($PLAYER_CHAR, "PLAYER_FACE", "HEAD", Head)

Variables declared as instances of a class can be redeclared with another type.

The Model Class

Model names are always instances of the Model class:

#AK47.Load
:loop
wait 0
if
#AK47.Available
jf @loop

It is equivalent to:

Model.Load(#AK47)
:loop
wait 0
if
Model.Available(#AK47)
jf @loop

Class constants

Some class members have pre-defined constants for some parameter values. It makes the source code more readable:

Player.SetClothes($PLAYER_CHAR, "VEST", "VEST", Torso)

The last parameter (Torso) is a class constant substituted with 0 during compilation. Class constants are defined in the classes.db file.

The special Extended type is reserved for parameters having a list of constants. You can see the Extended type in the list of class members and in a hint appearing as you type class member parameters.