Multiplayer Interactive-Fiction Game-Design Blog
Objects – Superclasses and subclasses
Download 8.87 Mb.
|
- Navigate this page:
- Objects – Layers
- Objects – Containership
- Objects – Timers
- String tables and resources
- Constructors and destructors
- Datatype overview
- Get() and Set() code
- Load/save objects
- Loop and stack limits
Objects – Superclasses and subclassesHow to create superclasses and subclasses. Objects can inherit methods and properties from other classes/objects. As stated previously, this is useful for the example Parrot object that can inherit methods and properties from the soon-to-be-created "Bird" class, which in turn could inherit from an "Animal" class, etc. Each class provides a way of providing common methods and properties for a group of like individuals. A "superclass" is a class (or object) with methods or properties that are inherited by other classes. A "subclass" is a class that inherits from a superclass. To create the "Bird" superclass:
That's it; you've created a bird class. (Of course, this is a very simple example so you can understand the process.) To get the Parrot object to use the Bird class:
The "Add class(es)" page will appear. It lists all of the classes in the project. If you compiled now though, the Parrot class would be unchanged because it already supports the "FlightSpeed" property and "Fly" method. Because of inheritance rules, if a sub-class (aka: the Parrot object) supports a method or property from a super-class (aka: the Bird class) then the sub-class's properties or methods have priority. Therefore, you need to remove both the "FlightSpeed" property and "Fly" method from the Parrot object (not the Bird class). Since Parrot no longer supports the properties and methods from the Bird class, they will be inherited directly. So what? That didn't really do much. Now that you have a Bird class that defined flying, here's how you can use it:
I won't lead you through all these examples step-by-step because they're all variations on a theme.
you may need to prioritize the super-classes so that any overrides (for properties or methods) are correct. Such situations will arise if two or more superclasses support the same properties or methods.
The lets you control the priority of all the object's superclasses. Earlier I said that if a class (the Parrot object) provides code for a method (the "Fly" method), any code from the superclass (the "Fly" method in the Bird class) will be ignored. I lied. This isn't always the case. Some method definitions allow the methods to coexist. You can have a call to a method first call the method in the lowest sub-class (the Parrot), then the next sub-class (the Bird class), and the next one (the Animal class), etc. You can reverse the order and call the methods from the highest super-class first, down to the lowest sub-class. You can also allow this chain to be stopped based on the returns of the methods. This creates four possibilities, in addition to the "just override inheritance" that's the default.
You might want to do this to accomplish: bird with an egg inside it to fly slower, because it weighs more, you could temporarily decrease the "FlightSpeed" property and then try and remember to increase it when the egg was laid. Alternatively, you could create a "FlightSpeedGet" method that just did the following:
This would return the bird's flying speed, and would be the "official" way of getting the value; you could even make the property private.
The variable, parameter, is automatically defined to be the list of parameters passed into the method. Since the FlightSpeedGet() call takes no parameters, the list will initially be empty. Setting paramter[0], however, changes this. Normally, this would have no effect... however: You could also create a super-class called "Pregnant". It would support the FlightSpeedGet() method too, but its code would be:
If you had the FlightSpeedGet() method call the super-class first, parameter[0] would be set to the original flight speed. Once that returned, the next class down (Pregnant) would be called; this would retrieve the value "stashed away" in parameter[0], decrease it to account for the egg's extra weight, and return that. Thus, to make a pregnant Parrot you'd include the Pregnant class as a super-class. You could also add and remove the pregnancy later using layers (discussed later). This idea could be extended further by making an "Unhealthy" super-class that likewise reduces flying speed. If a Parrot is both Pregnant and Unhealthy it will fly even slower. you could tell the method definition to call all the methods from sub-to-super-class or super-to-sub-class, repeating until one of them comes up knows how to deal with the situation. Perhaps you might need a public method, LikeFood (FoodName), that returns true if the object (aka: Parrot or Bird) likes a food item (passed in as the parameter "FoodName") or false if it doesn't. The generic bird would return true for (FoodName == "birdseed") || (FoodName == "peanut"), but false for (FoodName == "flower").
Some parrots like flowers, in addition to to birdseed. You could provide have the LikeFood() method override, cut-and-paste the code from the Bird's LikeFood() method, and then modify it. Or, you could have specify (in the method definition) that it should call from the highest priority methods (the Parrot's) to the lowest priority methods (the Bird's), trying LikeFood() for each one. If any returns a value which is not undefined, then that return is used. Otherwise, the next in line is called.
The Parrot's LikeFood() method would then be:
This makes for a very elegant solution, especially if new foods are added later on. Both the "cumulative effects" and "sometimes capture, sometimes pass on" approaches to methods are supported by MIFL. To have a method definition use either of these:
Realistically, the flying speed for every bird is different, and while a few birds will fly at the FlightSpeed (property) as initialized by the Bird superclass, most birds will fly at different speeds. To make sure that anyone creating a new type of bird will override the default FlightSpeed property for the bird, or consciously decide not to override it, you can can add a setting to the "Bird" class so that if any other class is derived from it (such as a "Robin"), an entry for the FlightSpeed property will automaically be added to the Robin class's list of public properties. To do this:
The "Recommended" page will appear, displaying the properties and methods that are automatically added to any sub-classes created from the Bird class.
Once the "FlightSpeed" property is checked, anytime the Bird class is included as a super-class of another object (or class), the "FlightSpeed" property will automatically be added to the object's list of public properties.
Describes what layers are and how to use them. MIFL includes an object concept called They allow an program to add new super-classes to an object at run-time. They also allow new methods and property get/set calls to be added at run-time. The primary use for layers is to allow objects to dynamically change their beahaviors (methods) and properties in an easy-to-program way. As an example from the last tutorial, layers could be used to add a "Pregnant" or "Unhealthy" superclass to a "Parrot" object. The layer allows all the methods associated with being Pregnant or Unhealthy to be added at run-time, and removed when the state no longer applied. To see how this works, first create a superclass that can be layered.
That's all you need to test out the concept. You'll know if the unhealthy superclass has been added to the Parrot object because calling Fly() will output different text.
To test the Unhealthy superclass:
From the debug trace you'll see that the Fly() code for the Parrot comes from the Bird class. The parrot is still healthy. The "SickLayer" parameter is a name that you given to the layer so you can later idenfity which layer it is. (After all, you might have several layers.) The "Unhealthy" parameter is the name of the class. And 1 is the priority of the class; higher numbers have higher priority over other classes. The class used to create an object always has priorty 0, and is usually the lowest priority.
The Fly() code from the Unhealthy class will be run instead. The debug trace will indicate that the parrot is too sick to fly. The 0 parameter is the index into the layer. If you used 1 instead, the "Parrot" class would be removed from the object, making it an unhealthy nothing. Under normal circumstances you'd look through all the layers in an object to find the one named "SickLayer" and then delete that one. This is just a tutorial though. There are quite a few layer methods you can call. Some of them are:
You can also add individual methods to a layer (although adding classes (aka: groups of methods) is recommended). To add an individual method:
The 0 parameter causes the method to be added to the layer at index location 0. "Speak" is the name that the new method will use. And, Trace, is the function (or method) to call when "Speak" is called. At the moment, you cannot compile code on-the-fly, so the only code you can add is that which has already been compiled, either in a function, this object, or another. (I can add the ability to code on-the-fly, if necessary.) The "Speak" parameter is the name of the method to call; it could also be "Fly", or other methods supported by the Parrot. "Polly wants a cracker." is the parameter passed into the "Speak" method, which just ends up calling Trace(). Therefore, you should see "Polly wants a cracker." appear on your debug trace. When you include a super-class in your object, it automatically inherits alls the properties from the superclass. This is a layer with a new class, the method definitions are incorporated into the object, but MIFL specifically does not add properties when a layer is added since doing so might unpredictably (for the programmer) cause hundreds of properties to suddenly change. Of course, there's an easy work around for this: Just set the properties immediately before or after the layer. Or, provide a function in the layered class that initialzes any necessary properties.
One aspect of the properties is inherited when you layer on a super-class though. Properties can include code that is called whenever the property is accessed, through a get() or set(). Some properties need to trap access calls so they can verify the value they're being changed to is acceptable. If a layered super-class includes code for get() and set() of its properties, this get() and set() code will be incorporated into the object while the layer exists. Furthermore, just as there's a way to add individual methods to a layer, there is also a way of adding get() and set() code for properties to a layer. This won't be discussed in the tutorial though.
Tutorial about how one object can contain another. MIFL objects understand containership. They can contain other objects and be contained by an object. This is an extremely useful tool for interactive fiction, which has all sorts of containers, like rooms containing objects, characters containing inventory objects, and backpacks containing objects.
To have an object initially created within another object:
That's all you need to do. You can change containership at run-time using the following methods:
Tutorial about the use of timers. In MIFL, all timer events are associated with objects. This means that to enumerate all the timers, you need to enumerate each object and discover what times it supports. It also causes times to be deleted when the object is deleted, or saved when the object is saved.
Creating a timer is easy:
The "SpeakTimer" is a name you can use to identify the timer. True indicates that the timer keeps repeating; if you passed in false it would only call itself once and then stop. 1.0 is the number of seconds before the timer goes off. Trace is the function (or method) to call, and "Polly wants a cracker." is the parameter to pass into the function (or method). In other words, this timer causes the parrot to speak, "Polly wants a cracker." over and over again.
There are three ways to stop the timer:
That's the basics. Here's a complete list of timer methods:
Tutorial about the use of timers. MIFL includes two special entities, string tables and resources. The are both extremely useful for writing an application. The a name attached to each. For example: One entry in the string table might be "Hello world!" with the name, SHelloWorld (the S prefix indicating it's a string). When you have entered a string into the string table, you can refer to the string by it's name. Therefore, calling Trace(SHelloWorld); will print out "Hello world!". The advantages of this follow:
Here's the really cool part... the string table can contain the string for both "Hello world!" and "Hola el mundo!". The version it uses depends upon the user's language. This allows your application to be written with English, Spanish, Japanese, etc. strings already translated. If someone in an English speaking country runs it, your program will use English. If they run it from Japan (or otherwise indicate they're Japanese), they get Japanese from the program. Furthermore, if MIFL is used for an online interactive fiction server, then users in the US will see English prompts, and users from Japan will see Japanese prompts, even though it's the same program running. (Their chat text won't be translated though.)
Before creating a string (in the string table), you should first identify what languages your project will be translated into:
In the "Project settings" page that appears, you'll find a section for "Languages". This lists all the languages supported by your project.
To add a string to the string table, just:
The "Modify string" page will appear. If a language's string is blank when the program is run, the first non-blank string will be used, even though it isn't for the right language.
Even if you added Japanese translation of "Hello world!", when your HelloWorld() function was called, it probably printed out "Hello world!". This is because it thinks you're in an English speaking area. (Although theoretically if you're in Japan it will automatically default to Japanese, and instead, refuse to display the English version.)
To tell MIFL what language to use:
The 1041 parameter is an ID for Japanese. English is 1033. The language IDs conform to the standard LANGID #defines in winnt.h. If you don't have this but wish to use the translations, please contact me. languages can introduce some difficult-to-find bugs. For example, look at this code:
This will write "Hello world!" to the debug trace if the language is set to English, "Hola el mundo!" for Spanish, etc. No problems here. Lets complicate matters:
This will write "Hello world! Hello world!" to the debug trace if the language is set to English, "Hola el mundo! Hola el mundo!" for Spanish, etc. No problems here. Now for the problem:
The trace output is it to be true since the exact same sequence of operations is used to produce MyGlobal as well as Compare. Why is this?
"MyGlobal = SHelloWorld + " " + SHelloWorld;" ends up converting SHelloWorld into a string. Since the current language is English, the English version of SHelloWorld will be used from the string table. MyGlobal ends up with the string "Hello world! Hello world!".
However, "LanguageSet (1034);" changes the language to Spanish. When "Compare = SHelloWorld + " " + SHelloWorld;" is called, the Spanish versions of the string are used. Compare ends up being "Hola el mundo! Hola el mundo!".
The two strings are compared (as strings). To the program they're obviously not the same.
a string and isn't code. This could include images, sounds, etc.
Unforuntately, the type of resources a MIFL project contains depends upon its context; different types of resources will be available for interactive fiction than for 3D modelling. Since this tutorial is written to be context independent, it won't be very specific about the types resources.
To create a resource:
When you click on a resource, a new page will appear, "Modify resource". It lets you change the name of the resource as well adding resources for specific languages.
If you have specified multiple languages for your project, you'll notice that the resource can contain slots for each of the languages. This lets the resource automatically adjust to the user's language, just as string tables did. If this were an audio resource with a recording of someone speaking, you could include several recordings, one for each supported language. And, just as with string tables, if you only fill in one resource entry, that one will be used, despite the user's choice of lanugages. You probably don't need localized versions of ever image, for example, although signs and other letters within the images might cause a problem. Resource usage is context dependent, so I can't show that here. As a general rule, the content (such as interactive fiction) will provide a library specific to the context. It will contain functions for using the resources the context supports.
A constructor is called when an object is created, and a destructor is called when an object is deleted (usually). Classes and objects typically use constructors to initialize variables and start timers. Destructors are usually to unravel relationships the object has with other objects. The use of a constructor and/or destructor for an object is option. To use one, the object needs to support the public method the public method It may also want to support Constructor() and Desctructor() are called under the following circumstances:
Datatype overviewDescribes the different data types. MIFL supports the following data types: A boolean can either be Both true and false are keywords built into the language.
A character is a unicode character, from 0 to 65535. Characters are specific by using single-quotes around a single character, such as The same escape sequences that strings use can appear in a character, such as
This is a reference to a function. Function names are tokens generated at compile time.
A list is an array of values (which can be any of the datatypes, including other lists). For more information on lists, see the tutorial about them.
A "List.Method" is a combination of a list and a method assocaited with that list. Although this is a dataype, programmers won't usually think of it as one since it's an intermediate step towards accessing the list's methods, such as List.ListAdd();
The null type has no values.
A number is a floating point value (in C/C++ terms it's an 8-byte double) that has 15 digits of precision and ranges from (approx) -1e300 to 1e300.
A number can be written in the following forms:
This is a reference to a method. Method names are tokens generated at compile time.
This is a reference to an object.
An "ObjectMethod" is a combination of an object and a method assocaited with that list. Although this is a dataype, programmers won't usually think of it as one since it's an intermediate step towards accessing the object's methods, such as Object.MyMethod(); It is a useful construct for timers and other callbacks since it remembers both the method to call and object to which it belongs.
A resource is a reference to a resource (in the project). Resource names are generated at compile time.
A string is a reference to memory containing a Unicode string. For more information on strings see the tutorial.
A "String.Method" is a combination of a string and a method associated with that string. Although this is a dataype, programmers won't usually think of it as one since it's an intermediate step towards accessing the string's methods, such as String.StringSlice();
A string table is a reference to a string table (in the project). String table names are generated at compile time.
The undefined type has no values.
Get() and Set() codeDescribes how to intercept get() and set() calls to global variables and properties. Typically, when a global variable or an object's property is created, the variable's contents can be accessed directly. Any function or method can change the variable (or method) to any value. You may wish to protect variables (or methods) so that only valid values can be written. Alternatively, you might need the accessing of a variable to run some code. (For example: The "weight" property of a backback might sum of the weight of its contents and its own weight.) You can do such interceptions by providing "get and set" code for the variable or property. There are two ways to do this:
Providing your own get/set code for a global variable or an object's property is easy. If you are modifying a global variable you will find a checkbox for "Use get/set code" and one button each for "Get" and "Set. If you are modifying an object's properties, you'll find a similar checkbox and buttons.
To provide your own get/set code:
Note: When you attach get/set code to a variable or method, any reads from or writes to the variable will access the get/set code. Except, from within the code for handling get and set itself; this will be able to access the variable directly.
object's property at run-time is slight more difficult. To modify a global variable's get/set code you need to call for more information. To modify an object's property's get/set code you need to call method's definition for more information. Load/save objectsDescribes how to loading/saving objects from/to disk works. MIFL lets you save one or more (or all) objects to disk, and then reload them at a later point. The exact function needed to do this depends upon the context, so I can't go into details here. However, I can explain the basic process: When one or more objects are saved, the following steps are taken for each object:
This is a very useful feature since it not only reduces the space necessary to save objects, it makes it safer for authors to save all the objects, change some properties, and then reload the previous objects (which were created with old code). Since only changed (or deleted) properties were saved, the realoded objects will contain all the properties as prescribed by the new code, except for the changes. Changing the code between a save and load isn't 100% safe though, and problems can arise. For example: If a saved object relied on the class "Unhealthy", but when it reloaded discovered that no "Unhealthy" class exists, it will ignore the "Unhealthy" class. In addition, if all the objects are saved, the following information is also saved:
wave data save is currently implimented, numbers may be rounded off to the nearest 0.00001. This is not a problem for most numbers, but might cause problems under some circumstances. If all the objects were saved, the following information is loaded:
When the saved objects are reloaded, the following steps happen for every object:
Loop and stack limitsTalks about limits to loops and stack depth. MIFL performs the following checks to prevent infinite loops:
Download 8.87 Mb. Share with your friends:
|