Daedalus Script Language

ZenGin engine uses its own script language called Daedalus. The language is used to define the game logic, dialogues, AI, missions, and other game-related content.

Daedalus synatx is a mix of C and C++. The script language is not case-sensitive and whitespace is ignored.

Identifiers and Keywords

Identifier are names for variables, constants, instances, prototypes, classes and functions. An identifier is a sequence of letters and ciphers. The first sign must be a letter. Thereafter, are allowed: letters, ciphers 0 to 9 and underscores. The length of identifiers is not restricted.

Keywords are:

1

var  const  if  else  class  prototype  instance  return  null  nofunc  int  float  string  void  func

Keywords are reserved and can not be used as identifiers.

Commentaries

The string /* begins a comment, which is closed by the string */.

1
2

/* This is a comment 
    which can be spread over several lines */

The string // begins a comment, which goes until the end of the line.

1

// This is a comment

Variables and Constants

Data Types

Variables

In daedalus, variable values are saved in save game files.

The declaration of a variable is initiated by the keyword var.

1
2

var int x1;
var int x2, x3, x4;

1
2
3
4
5
6

// Correct:
var int x1;
x1 = 42;

// Wrong:
var int x2 = 42;

Variable Arrays

Arrays are declared by adding square brackets with the size after the name.

1
2
3

var int x[10];

x[0] = 42;

The first element of an array has the index 0.

Constants

Constants have predefined values, that can be changed, but won't be saved in save game files and will be reset to the default value after loading a save game.

The declaration of a constant by the keyword const.

1
2
3

const int max_level = 100;

max_level = 200; // allowed but not recommended (value will be lost)

Constant Arrays

Constants can also be arrays, but all elements must be defined at the time of declaration.

1
2
3
4
5

const int values[3] = {
    1, 
    2, 
    3
};

Global, Local

Variables and constants can be declared globally or locally.

If a variable is declared outside a function, it is global, and can be accessed from anywhere in the script. If a variable is declared inside a function, it is local, and can only be accessed from within the function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

var int global;

func void test_1()
{ 
    var int local;
    global = 42;
};

func void test_2()
{
    local = 42; // Error: `local` is not defined
};

Operators

An operator "calculates" the resulting value from one or two values. The following operators are available in Daedalus:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

    Calculation: 
      +   Addition
      -   Subtraction
      *   Multiplication
      /   Division
      %   Euclidean division (Modulo)

    Comparison: 
      <   smaller than
      <=  smaller or equal to
      >   greater than
      >=  greater or equal to
      ==  Equality
      !=  Inequality

    Boolean:
      !   not
      &&  and
      ||  or


    Bitwise:
      &   and
      |   or

    Sign:
      +   positive
      -   negative

Control Flow

if statement

The if-statement is similar to C/C++.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

func void example_if_statement(var int a) 
{
    if (a < 5) 
    {
        // ..
    }
    else if (a == 5) 
    {
        // ..
    }
    else
    {
        // ..
    };
};

return statement

In functions, which return a value, a return assignment is used.

1
2
3
4

func int example_return_statement()
{
    return 42;
};

Functions

Definition

Function definitions are initiated by the keyword func, followed by the return type, the function name, and the parameter list. The function body is enclosed by curly brackets.

1
2
3
4

func type name ( var type param1, ... )
{
    // some code
};

1
2
3
4

func void foo(var int integer_parameter, var string str_parameter)
{
    // some code
};

Parameters

The length of the parameter list is unlimited, but should be kept as short as possible for memory capacity reasons.

Function calls

Functions are called as usual in C++. Also with their identifier as well as a mandatory parameter bracket.

1
2
3
4

func void bar()
{
    foo(42, "Hello World");
};

Classes

Classes usually mirror classes/structs on the engine side. They are defined by the keyword class and can contain variables;

1
2
3
4
5

class Foo {
    var int i1;
    var string s1;
    var func f1;
};

Prototypes

Prototypes are templates for classes. They can be used to create instances with predefined values. The prototype definition is initiated by the keyword prototype.

1
2
3
4
5

prototype FooProtoType (Foo)
{
    i1 = 42;
    s1 = "Hello World";
};

Instances

Instances can be created from classes or prototypes.

1
2
3
4
5

instance FooInstance (Foo)
{
    i1 = 42;
    s1 = "Hello World";
};

1
2
3
4

instance FooInstance (FooProtoType)
{
    i1 = 100;
};