TiMan: /* Using Delegates */

2020-08-16T10:54:11Z

Using Delegates

TiMan: /* Enums */

2020-08-16T10:51:50Z

Enums

TiMan: /* Constants */

2020-08-16T10:51:34Z

Constants

TiMan at 20:42, 15 August 2020

2020-08-15T20:42:31Z

TiMan: Created page with "{{shortPageTitle}} {{AngelScriptGuideMenu}} This is a list of features in AngelScript that are either infrequently used, can be confusing to understand, or are not as well kn..."

2020-08-15T20:41:14Z

Created page with "{{shortPageTitle}} {{AngelScriptGuideMenu}} This is a list of features in AngelScript that are either infrequently used, can be confusing to understand, or are not as well kn..."

Show changes

@@ Line 4: / Line 4: @@
 This is a list of features in AngelScript that are either infrequently used, can be confusing to understand, or are not as well known. They are not presented in any particular order, so you should treat this section as a reference rather than a contiguous series.
-== Enums ==
+==Enums==
 As an example, let's say you had an object that stored a particular state, such as a car's ignition position:
@@ Line 80: / Line 80: @@
 The integer value of <code>OneHundred</code> would be 100, as defined. Likewise, <code>Two</code> would be equal to 2. <code>Three</code> in this list would be equal to 3, because if a value is not explicitly given, the value of an enum is equal to the value of the previous one in the list plus 1.
-== Constants ==
+==Constants==
 Sometimes when you are writing a program, your code will contain what is known as "magic numbers". These are numbers that you have chosen to [https://en.wikipedia.org/wiki/Fast_inverse_square_root#Overview_of_the_code fulfill a certain purpose], but that purpose is not illustrated in the number's usage, so anyone who doesn't know what you are doing just has to trust that the number will work. Take, for example, the following code:
@@ Line 111: / Line 111: @@
   you could still manipulate the class members of a constant object, or add/remove values in a constant array.}}
-== Default Parameters ==
+==Default Parameters==
 When defining a function, you can have as many or as few parameters as you want. Sometimes, however, you're in a situation where you have several function overloads, each that just adds a single parameter to the end of the last function. As an example, see here:
@@ Line 175: / Line 175: @@
 ----
-== Passing Parameters by Reference ==
+==Passing Parameters by Reference==
 Ho boy, strap yourselves in for this one, gents. We're about to delve into a concept of programming that shockingly few people are aware of, even among professional programmers. On that note, keep in mind that the topic of this section is a bit of a difficult one to wrap your head around, so don't feel bad if it takes a few rereads, some experimentation, and perhaps even consulting other tutorials before it finally clicks.
@@ Line 181: / Line 181: @@
 Let's start by (re)defining a couple of terms - ''value'' and ''reference''.
-=== Value vs Reference ===
+===Value vs Reference===
 A value is just that - a value. It's a bit of hard data that directly represents information. An <code>int</code> value could be 5. A <code>bool</code> value could be <code>true</code>. A string value could be <code>"abcdef"</code>. It's a simple enough concept to understand, right? When you're talking about a variable's value, you are referring specifically to the information itself stored within the variable.
@@ Line 193: / Line 193: @@
 Does all that make sense? Clear as mud? Cool. A value is a thing itself, whereas a reference is an address to where that thing is. Got it.
-=== Passing Parameters By Reference ===
+===Passing Parameters By Reference===
 Let's take a look at an example function. It shouldn't be anything you haven't seen before:
@@ Line 250: / Line 250: @@
 {{note|Referring back to the sculpture example, now instead of my friend making a copy of my sculpture, he takes the sculpture itself. When he smashes that sculpture, he is now smashing ''my'' sculpture, instead of just smashing a copy. So even when my friend hands the sculpture back, I'm still left with a broken sculpture (and minus one friend).}}
-=== References and Object Types ===
+===References and Object Types===
 Assuming you understand the concept, the difference between passing a primitive type variable by value and by reference is pretty straightforward - one passes the value while the other passes a reference to the variable itself. With object types, what's happening is a little less transparent. Let's go ahead and make an example class for our purposes in this section:
@@ Line 328: / Line 328: @@
 It's stipulated that this confusion was started when the people behind Java decided to refer to instances as "references", a decision that confuses it with what other languages refer to when they use the term. Whatever the reason, don't be drawn in by this perpetuated mistake - objects in Java are passed by value, just like everything else in that language. (Also, just call them instances, for Pete's sake.)}}
-=== In and Out ===
+===In and Out===
 While many languages share the concept of passing by value and by reference, AngelScript goes a step further. In addition to the <code>&inout</code> keyword, it also supplies two additional ones - <code>&in</code> and <code>&out</code>.
@@ Line 394: / Line 394: @@
 {{note|The <code>TryX</code> technique is a popular one when dealing with situations that need to be specially handled to prevent potential errors from happening. In a situation where a string needs to be converted (aka ''parsed'') to a numeric value, for example, the string might not be a valid number (it could contain letters or something). Trying to convert such a string would result in one of two things - success or an error. If the <code>TryParse</code> approach was implemented instead, however, then the function would return a boolean value showing whether or not a parsing could be performed and, if so, the result of the parsing is handed back to the caller through an <code>&out</code> parameter.}}
-----
+==Object Handles==
 ===Inheritance===
 Imagine if you were creating an adventure game. In this game, the player could be one of several classes, such as a Warrior, an Archer, or a Mage. Each of these classes needs some basic fields and functions to make them work, and they might look something like this:
@@ Line 519: / Line 515: @@
 </syntaxhighlight>
-=== Overriding Base Classes ===
+===Overriding Base Classes===
 In addition to using stuff from a base class, a derived class can also override stuff declared in a base class. Let's take our <code>HeroClass</code> again, for example. Say we want to add a <code>DoSpecial</code> function that all derived classes could use:
@@ Line 658: / Line 654: @@
 ----
-== Interfaces ==
+==Interfaces==
 Overriding a class's functions is one way to implement polymorphism, but another way is to use blueprints that, rather than providing a collection of fields and functions, merely dictates what functions a class ''should'' have and leaves it up to the class to implement them. This is done using a construct called an ''interface''.
@@ Line 756: / Line 752: @@
 ----
-== Mixin Classes ==
+==Mixin Classes==
 Sometimes, rather than exploiting the benefits of inheritance or interfaces, you merely want to segment some code into pieces in order to maximize code reuse and efficiency. In these cases, AngelScript provides a somewhat unique feature called a ''mixin class''. Where inheritance and interfaces are intended to extend a class's capabilities or allow for flexibility in cases of variable types, a mixin class is merely intended to provide a class with a pre-defined set of fields and functions.
@@ Line 800: / Line 796: @@
 ----
-== Delegates ==
+==Delegates==
 Up until now, you've been using variables to store data of types. These types could be primitive types, such as <code>int</code> or <code>bool</code>, or they could be object types like <code>cVector3f</code> or <code>cMatrixf</code>. They could be arrays or even names of classes or interfaces that you came up with yourself. What if I told you, though, that you could also use a variable to store a ''function?''
@@ Line 806: / Line 802: @@
 A ''delegate'' is, in a nutshell, just that - a variable that stores a pointer to a function. The variable can be used to call that function just as though as you were calling it by name directly.
-=== Funcdef ===
+===Funcdef===
 Before you can learn how to use delegates, you need to understand what a Funcdef is. Funcdef is short for "function definition", and the basic explanation is that it defines a function "type". Appropriately, it is declared using the <code>funcdef</code> keyword:
@@ Line 828: / Line 824: @@
 {{note|As a general rule, Funcdefs should be declared at the global scope, although there's no rule against declaring them in the class scope.}}
-=== Using Delegates ===
+===Using Delegates===
 Now that we have a Funcdef, we can use it to declare and instantiate a delegate. When declaring a delegate, you use the Funcdef just as you would use a type for a regular variable:
@@ Line 841: / Line 837: @@
 </syntaxhighlight>
-A delegate is a pointer to a function, so it is necessary to declare it as a pointer object (see [[hpl3/community/scripting/angelscript_tutorial#object_handles|Object Handles]]). From here, you can use the function name of a function to "assign" the function to the delegate:
+A delegate is a pointer to a function, so it is necessary to declare it as a pointer object (see [[HPL3/Scripting/AngelScript Fundamentals/Chapter 9 - Miscellaneous AngelScript Features#Object Handles|Object Handles]]). From here, you can use the function name of a function to "assign" the function to the delegate:
 <syntaxhighlight lang="c++">

← Older revision		Revision as of 10:51, 16 August 2020
Line 79:		Line 79:

	The integer value of <code>OneHundred</code> would be 100, as defined. Likewise, <code>Two</code> would be equal to 2. <code>Three</code> in this list would be equal to 3, because if a value is not explicitly given, the value of an enum is equal to the value of the previous one in the list plus 1.		The integer value of <code>OneHundred</code> would be 100, as defined. Likewise, <code>Two</code> would be equal to 2. <code>Three</code> in this list would be equal to 3, because if a value is not explicitly given, the value of an enum is equal to the value of the previous one in the list plus 1.
−
−	~~----~~

	== Constants ==		== Constants ==

← Older revision		Revision as of 10:51, 16 August 2020
Line 113:		Line 113:
	you could still manipulate the class members of a constant object, or add/remove values in a constant array.}}		you could still manipulate the class members of a constant object, or add/remove values in a constant array.}}

−	~~----~~
	== Default Parameters ==		== Default Parameters ==

@@ Line 934: / Line 934: @@
-{{NavBar|HPL3/Scripting/AngelScript Fundamentals/Chapter 5 - Statements and Flow Control|Chapter 5 - Statements and Flow Control|HPL3/Scripting/AngelScript Fundamentals|AngelScript Fundamentals|HPL3/Scripting/AngelScript Fundamentals/Chapter 7 - Calling Other Scripts|Chapter 7 - Calling Other Scripts}}
+{{NavBar|HPL3/Scripting/AngelScript Fundamentals/Chapter 8 - Classes|Chapter 8 - Classes|HPL3/Scripting/AngelScript Fundamentals|AngelScript Fundamentals|HPL3/Scripting/AngelScript Fundamentals/What's Next|What's Next}}
 [[Category:HPL3 Scripting]]
 [[Category:English]]

HPL3/Scripting/AngelScript Fundamentals/Chapter 9 - Miscellaneous AngelScript Features - Revision history

TiMan: /* Using Delegates */

TiMan: /* Enums */

TiMan: /* Constants */

TiMan at 20:42, 15 August 2020

TiMan: Created page with "{{shortPageTitle}} {{AngelScriptGuideMenu}} This is a list of features in AngelScript that are either infrequently used, can be confusing to understand, or are not as well kn..."