Scripting #2: Variables tutorial - Call of Duty 4: Modern Warfare

Like in every programming language, we must use variables to store values, which we want to use in the future in GSC too. All of them can be identified with their unique names. Don't forget, these should always be named with English letters and numbers, and you can't start it with a number (the engine does not make difference between small and capitalized letters). Every variable can only be used in the block (between the opening and closing curly bracket pairs), in which it has been created, it is called the scope of a variable. There are some exceptions, like the level variable, which can be reached from everywhere. You can set value with an equal sign like this (assignment declares the variable automatically):

In this case, the value of something is set to 5. The semicolon in important at the end, because it will close every statement. You can also set a variable as the value of an other variable:

After executing this, both first and second variables will have the value 4. We are also able to overwrite the current value of a variable, in this case the old value will be lost. You are able to remove a variable in the following way:

Variables can have many types: Integer, float, string, boolean, array, vector, pointer, and structure. So let's check what do these do, and how do we use them.

We are using integers in most cases, since we can store many things with these, and it is easy to calculate with them. We have also used it in the examples above.

I don't want to write more details about this, you will be able to check the counting in the operators tutorial.

It is much rarer, because we don't have to store number with high precision usually (and it is also really inaccurate). In this language, the decimal point is a dot:

When needed, we can convert it to integer with the int() function (with floor rounding), we will talk about it later.

Storing character string is also rare, since these are usually in language-specific files, or we are printing the text directly. These must be written between two quotation marks.

When needed, we can get the length of this by using the size parameter:

The mentioned language-specific files can be found in the str files, and we can link to them by writing an [at] symbol before the first quotation mark, and we set the needed file and string name:

In the example above, we are referring to the SCORE_LIMIT_REACHED text in the localizedstrings/mp.str file. You can find it this way inside the file:

The structure of an str file looks like this:

The first 3 rows must be always in the beginning of the file, don't even edit them, they are not changing anything in the display. The ENDMARKER at the end signs the game, that it reached the end of the file, it shouldn't check it for more strings, so that's why you shouldn't put anything after this. If you want to create a new localized string, then all you have to do is, to make a new REFERENCE - LANG_ENGLISH pair between the start and the end part, for example:

An array is like multiple variables in one, which have strong connection between them. You can declare it this way:

After this, an array, named player will be created, in which you can put any elements, with any types. As default, an array is indexed from zero, these are called indexed arrays. So for instance, if we want to store player names, then we instead of this:

We can use this:

Maybe it doesn't look easier, but let's check why is it better:
1) We can access a given index of an array. For example, if we want to check the name of the second player, we can't do it with more variables, but we are able to do it with arrays easily:

2) We can query the element number of an array. So if we want to know, how many players are stored, it would require one more variable with independent variables, but with arrays, we can get it simply with the size parameter (just like at strings):

It is an important property to be able to add a new element. With variables, we don't know which is the next, which with arrays:

We can use it this way, because if we currently have two elements in the array, then according to the meaning players.size will return two, which means, that we have a zeroth and a first elem, but not a second one; so the second will be the next one, in which we can write.
Arrays have a second type too, the associative array. The only change in it is, that we can access it with string index, instead of a number:

If you are putting elements in an array instantly when you create it, you can leave the declaration part, for example in this case, you can remove the first line:

Booleans can have two values: true, and false. We can store in it, if a player owns a given thing, the bomb is planted, or anything else, for which you can answer with yes and no. It is much more optimal, than storing 0 and 1 with numbers, since it is allocating much less memory.

It can store a coordinate in the format of (X, Y, Z). It should always be between brackets, and it must contain three, comma separated numbers.

With this, you can set the origin or angles of any entity. You can handle these as array too, so based on the example above origin[0] = 14, origin[1] = -533, origin[2] = 31.196202.

These are special variables, which are referring to a given entity (effect, player, model, etc):

or to a function:

For being able to use it, you will have to understand the usage of functions, so I won't explain it deeply now.

It is very similar to the associative arrays, it does the same with a different syntax. You can declare it this way (it must be defined always before using it):

After this, you can set endless keys for it, and just like array elements, these can have any type too: