Hpl2:Tutorials:script:localandglobalvariables - Revision history

Darkfire: Structuring

2020-07-14T17:49:03Z

Structuring

Darkfire: Blurb test

2020-07-14T14:18:01Z

Blurb test

Darkfire at 13:48, 14 July 2020

2020-07-14T13:48:42Z

Darkfire: A merithoric rewrite, and formatting

2020-07-14T13:41:48Z

A merithoric rewrite, and formatting

Show changes

Maintenance script: Upload from wiki

2020-07-09T13:48:52Z

Upload from wiki

New page

= Variables =

A variable is letter or word used to represent a value that can be altered. The main types of variables are bool, string, int, and float. Bool is when the variable can be true or false. String is a letter, word, or phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number).

Examples:

int x = 1; int k = 73; float r = 5; float pi = 3.1415; bool tf = false; bool w = true; string h = "h"; string aa = "lava"; 

== Local and Global Variables ==

Local and global variables are variables that have a certain scope compared to the script in which it is located in. There are certain levels of scope to a script, there is the function's scope, then there is the local scope, then there is the global scope. A function's scope consists of everything within its braces ({ }). Normal variables as shown above will only work in a function unless carried over to another function.

A local variable's scope is the whole entire script, so if you made a local variable, then you wouldn't have to worry about having to carry it over from function to function. The downside to it is that you can't use the value of the local variable in commands. It is mostly used to check and see if the player has done multiple things within the map to make something greater happen. This is also the case with global variables, but it can be used over many levels in your custom story. Currently, I don't yet know how to properly use global variables, for I never had the need to use it. Here is an example of a local variable integer:

 

<syntaxhighlight lang="cpp">void OnStart()
{
SetLocalVarInt("Var01", 0);
AddEntityCollideCallback("Player", "ScriptArea_1", "Func01", true, 1);
SetEntityPlayerInteractCallback("Object_1", "Func02", true, 1);
}
void Func01(string &in asParent, string &in asChild, int alState)
{
AddLocalVarInt("Var01", 1);
Func03();
}
void Func02(string &in asEntity)
{
AddLocalVarInt("Var01", 1);
Func03();
}
void Func03()
{
if (GetLocalVarInt("Var01") == 2)
{
AddDebugMessage("Run!", false);
}
}
</syntaxhighlight>

This is what it says in the Script Functions page about what GetLocalVarInt, AddLocalVarInt, and SetLocalVarInt are and also how there can be a GetLocalVarFloat, AddLocalVarFloat, and SetLocalVarFloat. There are also GetLocalVarString, AddLocalVarString, and SetLocalVarString.

==== Local ====

Local variables can be used throughout the same script file.

<syntaxhighlight lang="c++">void SetLocalVarInt(string& asName, int alVal);
void AddLocalVarInt(string& asName, int alVal);
int GetLocalVarInt(string& asName);
</syntaxhighlight>

<syntaxhighlight lang="c++">void SetLocalVarFloat(string& asName, float afVal);
void AddLocalVarFloat(string& asName, float afVal);
float GetLocalVarFloat(string& asName);
</syntaxhighlight>

<syntaxhighlight lang="c++">void SetLocalVarString(string& asName, const string& asVal);
void AddLocalVarString(string& asName, string& asVal);
string& GetLocalVarString(string& asName);
</syntaxhighlight>

==== Global ====

Global variables can be used throughout several maps and can be accessed by several script files.

<syntaxhighlight lang="c++">void SetGlobalVarInt(string& asName, int alVal);
void AddGlobalVarInt(string& asName, int alVal);
int GetGlobalVarInt(string& asName);
</syntaxhighlight>

<syntaxhighlight lang="c++">void SetGlobalVarFloat(string& asName, float afVal);
void AddGlobalVarFloat(string& asName, float afVal);
float GetGlobalVarFloat(string& asName);
</syntaxhighlight>

<syntaxhighlight lang="c++">void SetGlobalVarString(string& asName, const string& asVal);
void AddGlobalVarString(string& asName, string& asVal);
string& GetGlobalVarString(string& asName);
</syntaxhighlight>

The Set-Var- is used to set the variable's value. The Add-Var- is used to add the given number or letter(s) to the value of the existing variable. The GetVaris used when checking the value of the variable.

'''This wiki entry has been made by Kyle S. If you have any comments or need help with this, send me a private message on the Frictional Games Forum. (My name on there is Kyle)'''

@@ Line 1: / Line 1: @@
 A variable is letter or word used to represent a value that can be altered in code. Variables are used in script to represent a certain value (e.g. a number) so that it can be changed by the game, instead of putting a set value in the script. An example of a variable would be a counter for collected items, which increases each time an item is picked up.
-=Variables=
+==Data types==
-The main types of variables are bool, string, int, and float. Bool (boolean) is when the variable can only be true or false. A string is a group of signs, so it can be a letter, a word, or a phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number). Examples:<syntaxhighlight lang="cpp">
+The main types of variables are bool, string, int, and float. These data types are also referred to as "primitives".
 int x = 1;
 int k = 73;
@@ Line 14: / Line 21: @@
 </syntaxhighlight>
-==Local and Global Variables==
+===Local and global - variable scope===
 Local and global variables are variables that have a certain scope compared to the script in which it is located in.
@@ Line 47: / Line 54: @@
     //global variables can be used in any function
+}
-</syntaxhighlight><blockquote>
+</syntaxhighlight>
-'''WARNING:''' ''The regular variables (as described above) are '''not''' saved by the game. Using them in important parts of yor script will break it upon loading a game save. In HPL, those variables should only be used for disposable counters, like spawning objects in a "for" loop. For variables which need to be saved, use the following:''</blockquote>
-HPL also has wrappers for all those types (except the boolean; instead, the devs just used an integer). Those are the LocalVar- and GlobalVar- types. Their scope is different than the traditional scope used in programming (described above). Their values are also saved in the game progress save files.
+=== Usage ===
-A LocalVar's scope is the entire script, so if you made a LocalVar, then you wouldn't have to worry about having to carry it over from function to function. A GlobalVar can be used in a similar manner in many maps.
+A LocalVar's scope is the entire script, so if you made a LocalVar, then you wouldn't have to worry about having to carry it over from function to function. A GlobalVar can be used in a similar manner in many maps, rather than a single one.
 Here is an excerpt from the [[Hpl2:Amnesia:script functions|Script Functions]] page about the variable wrappers:
@@ Line 97: / Line 108: @@
 </syntaxhighlight>
-The Set-Var- is used to set the variable's value. The Add-Var- is used to add the given number or letter(s) to the value of the existing variable. The GetVar is used when checking the value of the variable.
+The Set functions are used to set the variable's value. The Add functions are used to add the given number or letter(s) to the value of the existing variable. The Get functions are used when checking the value of the variable.
 The variable wrappers are mostly used to check if the player has done certain things within the map or the entire game. Such things are often:
@@ Line 131: / Line 143: @@
 </syntaxhighlight>
-GlobalVars are used in a similar manner, but, as mentioned earlier, will work in several map scripts.
+GlobalVars are used in a similar manner, but, as mentioned earlier, will save its value between several map scripts.
 '''This wiki entry has been made by Kyle S. If you have any comments or need help with this, send me a private message on the Frictional Games Forum (My name on there is Kyle). Redux by Darkfire'''

@@ Line 1: / Line 1: @@
 =Variables=
-A variable is letter or word used to represent a value that can be altered. The main types of variables are bool, string, int, and float. Bool is when the variable can be true or false. String is a letter, word, or phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number). Examples:<syntaxhighlight lang="cpp">
+The main types of variables are bool, string, int, and float. Bool (boolean) is when the variable can only be true or false. A string is a group of signs, so it can be a letter, a word, or a phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number). Examples:<syntaxhighlight lang="cpp">
 int x = 1;
 int k = 73;

@@ Line 1: / Line 1: @@
 =Variables=
-A variable is letter or word used to represent a value that can be altered. The main types of variables are bool, string, int, and float. Bool is when the variable can be true or false. String is a letter, word, or phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number).Examples:<syntaxhighlight lang="cpp">
+A variable is letter or word used to represent a value that can be altered. The main types of variables are bool, string, int, and float. Bool is when the variable can be true or false. String is a letter, word, or phrase. Int is an integer (whole number). Float is a number with a decimal (can also be a whole number). Examples:<syntaxhighlight lang="cpp">
 int x = 1;
 int k = 73;
@@ Line 35: / Line 35: @@
+}
-void MyFunc()
+void MyFuncA()
+{
     local = local + 3; //Local was declared in a different scope, so this is invalid
+}
-void MyFunc(int argument)
+void MyFuncB(int argument)
+{
     global = argument + 3; //The value of local was passed as the argument, so it can be accessed
@@ Line 99: / Line 99: @@
 The variable wrappers are mostly used to check if the player has done certain things within the map or the entire game. Such things are often:
-* Collecting a set number of objects
+*Collecting a set number of objects
-* Doing a certain action a set number of times
+*Doing a certain action a set number of times
-* Done some particular thing
+*Done some particular thing
 Here is an example usage of a LocalVar integer (LocalVarInt):