Functions and procedures
Let's assume that you are writing a script which needs some instructions, conditional tests, etc ... to be executed several times. (For instance, a script which tests the pixel's colors several time and acts differently depending on the obtained results. )
Copying the same lines several time in a George Script can quickly become fastidious. It doesn't make the things easier when you need to check or modify your script.
That's the reason why writing procedures and functions is very convenient :
* A function is a set of instructions and commands which allows you to execute a precise task inside a George Script. The functions are independent from the remainder of the George Script and are located at the end of the script.
The part of a George Script which distinguish itself from the function(s) will be called “main part of the script”. All the functions are available at any moment in order to be used by the Main part of the script. A function can receive parameters and always returns a result.
* A procedure is a function which does not return results.
Here is an example of a script using a function :
(Of course, using functions is really useful when you have to create bigger and more sophisticated scripts )
Parse result command abscissa ordinate button
// Main part of the script ▲
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// Function ▼
Local r g b alpha sum
tv_getpixel x y
Parse result r g b alpha
Return "the pixel's color is black"
Return "the pixel's color is NOT black"
Return " the pixel is transparent "
The line : tv_warn TestBlackColor(abscissa,ordinate)
Can be replaced by the two following lines :
Here is the syntax of the instructions relative to the procedures and functions :
Function NameOfTheFunction (Variable1, Variable2, Variable3, etc ... )
This instruction declares the existence of a function or a procedure in a George Script. (there is no instruction called "procedure")
This instruction is followed by the procedure or function name, and then by the name of the variables (from the main part) that are needed.
Functions and procedures must always be located after the main part of your script. Calling a function or a procedure in the main part of your script can be done by writing its name and the needed variables between parenthesis, separated by comas.
Local LocalVariable1, LocalVariable2, LocalVariable3, etc ...
This instruction allows you to specify the variables which will be used solely inside your function or procedure.
This instruction allows you to specify the result of your function and to make it available in the main part of the script. It could be a character string, a numerical value, a boolean value, etc ...
In the main part of your script, it is possible to save it into a variable, and after to re-use it.
This instruction is optional. If you don't use it, you have created a procedure instead of a function.
This instruction is needed to finish your function or procedure.
The functions and procedures written in George language can be recursive. In other words, a function can call itself. It allows you to create more sophisticated scripts.
For instance, drawing a fractal curve can be done thanks to a recursive script (see below)