Creation/Dev/GScript/GScript for Dummies - Revision history

Cbk1994: moved Creation/Dev/GScript/New Engine GScript for Dummies to Creation/Dev/GScript/GScript for Dummies

2011-06-21T20:34:14Z

moved Creation/Dev/GScript/New Engine GScript for Dummies to Creation/Dev/GScript/GScript for Dummies

← Older revision

Revision as of 16:34, 21 June 2011

Pooper200000 at 06:55, 12 September 2009

2009-09-12T06:55:13Z

← Older revision		Revision as of 02:55, 12 September 2009
Line 1:		Line 1:
			[[Category:Scripting Tutorials]]
	<span style='float: right;'>[[Image:s_dummies.png]]</span>		<span style='float: right;'>[[Image:s_dummies.png]]</span>
	= Preface =		= Preface =

Napo p2p: Added text under all headings.

2009-03-09T11:41:48Z

Added text under all headings.

← Older revision		Revision as of 07:41, 9 March 2009
Line 24:		Line 24:

	= Using GScript =		= Using GScript =
			So, hopefully by now you have a general idea of what GScript is. Now, it's time to fill you in on how to use GScript. With the help of this guide, hopefully you'll be creating scripts of your own in no time!

	== Basic concepts ==		== Basic concepts ==
	It is important to remember a couple of very basic, but very important concepts when using GScript.		It is important to remember a couple of very basic, but very important concepts when using GScript.
Line 174:		Line 176:

	== Manipulating data ==		== Manipulating data ==
	~~=== Explanation ===~~
	Data can be manipulated in various ways. For example, you can modify parts of a string. You can apply math functions to a number. This section explains those sorts of functions.		Data can be manipulated in various ways. For example, you can modify parts of a string. You can apply math functions to a number. This section explains those sorts of functions.

Napo p2p: attempting to explain objects

2009-03-09T05:57:57Z

attempting to explain objects

← Older revision		Revision as of 01:57, 9 March 2009
Line 252:		Line 252:
	<pre>3 == 2</pre>		<pre>3 == 2</pre>
	... produces false, because 3 doesn't equal 2.		... produces false, because 3 doesn't equal 2.

			== Understanding Objects ==
			No one can call them self a true Graal scripter until they have a firm grasp on the concept of objects. Basically, in GSCript, all items of a given type - players, NPCs, levels, Gui Controls, etc - act in the same way. Objects of the same type give you the same kinds of data, and can even be controlled in the same way.

			Let's say you wanted to access some kind of data from the Control-NPC. It turns out that the Control-NPC itself is an object. All you have to do is create an object which represents the Control-NPC. After the object is created, you can use variables from it, or execute commands as if it were that NPC. For example:
			<pre>temp.controlnpc = findnpc("Control-NPC"); //Creates an object references the Control-NPC
			this.player_data = temp.controlnpc.player_data; //Copies data from the Control-NPC to the current NPC.
			temp.controlnpc.onCreated(); //Executes the onCreated function through the Control-NPC</pre>
			You can even use the object directly:
			<pre>this.where_is_waldo = findnpc("Waldo").level.name;</pre>
			Here, the 'Waldo' npc is being called directly. As you can see, the NPC's level is also an object! Finding Waldo has never been so easy.

			Players work the same way (they are also objects):
			<pre>temp.p = findplayerbycommunityname("Stefan");
			temp.p.chat = "Hi! I'm playing Graal!";</pre>
			This script would find the player with the community name 'Stefan' and set his chat to 'Hi! I'm playing Graal!'. Also, no matter how you got the player object, everything works the same way:
			<pre>findplayer("napo_p2p").say2("EAAAGLE!");
			allplayers[3].chat = "How appropriate. You fight like a cow.";
			players[i].setlevel2("jail.nw", 30, 30);</pre>

			In fact, most everything within GScript is some type of object! That weapon you're using to wreak havoc on your enemies? Why, that's a TServerWeapon. Those bullets hitting your foes? TProjectile. That level you've been jailed in one too many times? TServerLevel. You can access all of these objects with GScript. If you decide to be more ambitious, you can even create your own.

Napo p2p at 05:25, 9 March 2009

2009-03-09T05:25:52Z

@@ Line 61: / Line 61: @@
 <pre>myFunction();</pre>
 Suddenly, the player's chat will be set to "Hello!". By calling the function, you've told the engine to run the code inside of that function - in this case, setting the player's chat.
 == Variables ==
@@ Line 229: / Line 252: @@
 <pre>3 == 2</pre>
 ... produces false, because 3 doesn't equal 2.

Stefan: Reverted edits by Anti-up (Talk); changed back to last version by Skyld

2007-07-01T13:38:10Z

Reverted edits by Anti-up (Talk); changed back to last version by Skyld

Show changes

Anti-up at 05:41, 1 July 2007

2007-07-01T05:41:14Z

Show changes

Skyld: /* Using GScript */

2006-11-19T14:29:56Z

Using GScript

← Older revision		Revision as of 10:29, 19 November 2006
Line 217:		Line 217:
	... is the same as doing:		... is the same as doing:
	<pre>this.var = this.var - 1;</pre>		<pre>this.var = this.var - 1;</pre>

			== Understanding booleans ==

			Booleans are, plainly and simply, true or false values. They don't do anything else.
			<pre>this.value = true;
			this.value = false;</pre>

			Technically, true is the same as 1, and false is the same as 0, but the keywords are here to tidy things up a bit. Booleans are very useful because they help to control how your script operates. Now, as you know, a conditional check will produce a true or false result. For example:
			<pre>3 == 3</pre>
			... produces true, because 3 equals three.
			<pre>3 == 2</pre>
			... produces false, because 3 doesn't equal 2.

			== Functions continued ==

			There are many features about functions that can greatly improve the usefulness of your script, for example, function parameters and return values.

			=== Return values ===
			A function execution can return a value to where the function was called. This is how a lot of Graal's built-in functions work: by returning the value.

			Take the following example, which will return the value of timevar2 (a built-in variable which counts how many seconds it has been since 1st January 1970):
			<pre>function getTime()
			{
			return timevar2;
			}</pre>

			When you call the function, like so:
			<pre>this.time = getTime();</pre>
			... then this.time will be set to the value of timevar2.

			It is very important to remember that the return function immediately ends the function's execution. Therefore:
			<pre>function foo()
			{
			player.chat = "Foo";
			return;
			player.chat = "Bar";
			}</pre>

			player.chat = "Bar"; won't be executed because of return; being used.

Skyld at 12:03, 17 August 2006

2006-08-17T12:03:48Z

← Older revision		Revision as of 08:03, 17 August 2006
Line 134:		Line 134:

	An if () statement by itself will only check if something is true. If not, it'll ignore it. If you put an else in, like in the above example, that code will be run in the case of a failure.		An if () statement by itself will only check if something is true. If not, it'll ignore it. If you put an else in, like in the above example, that code will be run in the case of a failure.

			=== Storing the result of a conditional check ===
			Now, as previously mentioned, a comparison (==) will only produce either true or false. If you want to store the value of a conditional check for use later, then you can assign the result to a variable, instead of using it in an if () check now.
			<pre>this.variable = (myVariable == "excellent");</pre>
			... saves the result of the check into this.variable. So later, you can do:
			<pre>if (this.variable)
			{
			// code
			}</pre>
			... to see if the check was successful. Similarly, you can do:
			<pre>if (!this.variable)
			{
			// code
			}</pre>
			... to see if the check failed.

			== Manipulating data ==
			=== Explanation ===
			Data can be manipulated in various ways. For example, you can modify parts of a string. You can apply math functions to a number. This section explains those sorts of functions.

			=== Basic math ===
			GScript allows you to perform basic operations like add, subtract, multiply, divide, etc. However, GScript does not use functions for this. Instead, it has a set of "operators".

			Examine the following examples:
			<pre>this.result = 3 + 4; // addition (sets this.result to 7 in this case)
			this.result = 3 - 4; // subtraction (sets this.result to -1 in this case)
			this.result = 3 * 4; // multiplication (sets this.result to 12 in this case)
			this.result = 3 / 4; // division (sets this.result to 0.75 in this case)</pre>

			Note how the operators are between two values: the value to start with, and then the value to operate with. The use of an operator returns a value in the same way as other comparisons, so let's take this example:
			<pre>if ((3 - 4) == -1)
			{
			// code
			}</pre>

			This statement evaluates to be true, because 3 - 4 does, in fact, equal -1.

			=== Priority order ===
			If you're doing complex operations, it is important to ensure that your priority order is correct. In it's most basic mathematic form, the default order of operations is the following:
			* B - Brackets
			* O - Order
			* D - Division
			* M - Multiplication
			* A - Addition
			* S - Subtraction
			That means that in a complex expression, multiplication takes priority order over addition, and that a part of the expression surrounded by brackets will always be calculated first.

			Brackets are very useful because it allows you to specify the order of operations. Consider this example:
			<pre>this.result = (3 * 4) / (2 * 3);</pre>
			... is calculated in this order:
			* First, 3 is multiplied by 4:
			<pre>this.result = 12 / (2 * 3);</pre>
			* Second, 2 is multiplied by 3:
			<pre>this.result = 12 / 6;</pre>
			* Finally, 12 is divided by 6:
			<pre>this.result == 2</pre>

			=== Slightly more complex operators ===
			There are another set of operators which allow for basic math manipulation on a variable. These allow you to add and subtract to a number variable, without having to perform the expression yourself. For example:
			<pre>this.result += 3;</pre>
			... is the same as doing:
			<pre>this.result = this.result + 3;</pre>

			Similarly:
			<pre>this.result -= 3;</pre>
			... is the same as doing:
			<pre>this.result = this.result - 3;</pre>

			The increment and decrement operators are as follows:
			* += - add to
			* -= - subtract to
			* *= - multiply by
			* /= - divide by

			Occasionally it is useful to just add or subtract one to a variable. There are operators to do this, too.

			<pre>this.var ++;</pre>
			... is the same as doing:
			<pre>this.var = this.var + 1;</pre>
			Also:
			<pre>this.var --;</pre>
			... is the same as doing:
			<pre>this.var = this.var - 1;</pre>

Skyld: /* Working with if () checks */

2006-06-26T20:21:03Z

Working with if () checks

← Older revision		Revision as of 16:21, 26 June 2006
Line 113:		Line 113:

	=== Working with if () checks ===		=== Working with if () checks ===
	Now, conditional checks alone are no good to you in a complex script. You'll need to actually use the conditional checks to make a difference in what happens.		Now, conditional checks alone are no good to you in a complex script. You'll need to actually use the result of your conditional checks to make a difference in what happens during the execution of the script.

	To do this, you use an 'if' ~~check'~~. 'if' is a very simple operator (it doesn't get complicated yet!) that simply runs one thing if the statement you give it is true, and optionally runs another thing if it isn't.		To do this, you use an 'if' statement. 'if' is a very simple operator (it doesn't get complicated yet!) that simply runs one thing if the statement you give it is true, and optionally runs another thing if it isn't.

	Since using examples so far has been the common way, let's see one here. We'll even include a bit of what you've learned already:		Since using examples so far has been the common way, let's see one here. We'll even include a bit of what you've learned already: