# Types

ManiaScript is a strongly typed language which means that every value has to be of a certain type and a value of different type will not be accepted in it's place.

## Primitive Types

There are 9 different types in ManiaScript: `Void`, `Integer`, `Real`, `Boolean`, `Text`, `Vec2`, `Vec3`,`Int3` and `Ident`.

| Type    | Description                                                                                                                                        |
| ------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
| Void    | `Void` is a type that means empty. You cannot create variables of that type, it is used to declare functions that returns nothing.                 |
| Integer | An `Integer` variable is an integer number ($$\mathbb{Z}$$ in mathematics) between $$-2147483648$$ ($$-2^{31}$$) and $$2147483647$$($$2^{31}-1$$). |
| Real    | A `Real` variable is a real number ($$\mathbb{R}$$ in mathematics). It can represent values much higher than Integer.                              |
| Boolean | A `Boolean` variable can be either `True` or `False`.                                                                                              |
| Text    | `Text` represents a string of characters.                                                                                                          |
| Vec2    | `Vec2` is a two dimensional vector ($$\mathbb{R^2}$$ in mathematics). The two values can be accessed with `X` and `Y` respectively.                |
| Vec3    | `Vec3` is a three dimensional vector ($$\mathbb{R^3}$$ in mathematics). The third value can be accessed with the `Z` property.                     |
| Int3    | `Int3` is a three dimensional vector ($$\mathbb{Z^3}$$ in mathematics).                                                                            |
| Ident   | `Ident` is the type of an Id. Every class in ManiaScript has a unique `Id` property that can be used to identify it.                               |

## Lists and Arrays

### List

A List is a type that can store multiple values. You can declare list by adding two square brackets after a type.

```
declare Integer[] MyList;
```

There are several basic functions to manipulate them, and you can access one element by its index. The indexes start at 0, so the first index is `0` and the last one is `MyList.count-1`. Accessing an invalid index will result in an `Out of bounds` error.

```
// Access an element
declare FirstElement = MyList[0];

// Basic functions
declare Size = MyList.count;
declare SortedList = MyList.sort();
declare ReversedList = MyList.sortreverse();
declare SortKeys = MyArray.sortkey();
declare ReversedKeys = MyArray.sortkeyreverse();


MyList.add(42);  // adds to last element
MyList.addfirst() // adds to first element
MyList.removekey(0); // Remove the element at the index 0
MyList.remove(38);

declare DoesExist1 = MyList.existskey(58); // equivalent to 0 <= 58 < MyList.count
declare DoesExist2 = MyList.exists(12);
declare Index = MyList.keyof(28); // such as List[Index] == 28

MyList.containsonly();
MyList.containsoneof();
MyList.slice();

Declare Text json = MyList.tojson();
MyList.fromjson("{ "propery": "value"});

MyList.clear();
```

### Array

An array is similar to a list, except that you can specify a type for the index.

```
declare Text[Integer] MyArray;
```

The array above is not a list! There is no `add` function for arrays, instead you directly assign a value for the given key.

```
MyArray[1] = "One";
```

You can even nest them!

```
declare Text[Text][] UsersData;
UsersData = [
    [ "login" => "me",
      "name" => "still me"
    ],
    [ "login" => "you",
      "name" => "still you"
    ]
];
log(UsersData[0]["login"]); // prints "me"
```

### API Arrays

access by Integer or Ident

### Structs

```
#Struct MyStruct {
//      {Type} {propertyname};
    Integer MyMember;
    Text MyTextMember;
}

main() {
    declare MyStruct MyVar;
    // declare MyStruct MyVar = MyStruct{MyMember = 1, MyTextMember = "Example"};
    log(MyVar.MyMember); //Output : 0

    MyVar.MyMember = 1;
    log(MyVar.MyMember); //Output : 1

    declare MyStruct MyCopy = MyVar;
    log(MyCopy.MyMember); //Output : 1

    MyVar.MyMember = MyVar.MyMember + 1;

    log(MyVar.MyMember); //Output : 2
    log(MyCopy.MyMember); //Output : 1
}
```

## Vectors

Vectors are declared with pointing angles: `declare Vec2 V = <1.0, 2.0>`.\
Vector-elements can be accessed either with `X`, `Y` and `Z` (as `V.Y`) or like an array with the indices `0` to `2` (like `V[1]`) (depending on the vector having 2 or 3 elements). Vectors are initialized with the initial value for `Integer` or `Real` respectively, e.g. `declare Vec3 V; log(V);` will log as `<0., 0., 0.>`.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://maniaplanet-community.gitbook.io/maniascript/getting-started/types.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.