This design is associated with ISIS project.
I've put my design version in ben-design instead of editing it here.
We don't want our adventure game to be a parser game because parsers don't translate well to multiple languages. Better to create something with translatable text (this is detailed in Action section).
Our adventure game is a multiple choice system with some hooks for some alternative interface styles.
Our game will be entirely editable by populating various files using a simple editor
The game will support primarily text with icons, but may include images, sounds, and possibly video or music as additional assets.
The basic entities in the game system are:
- Objects -- rooms, creatures, things
- Verbs -- the fundamental verbs of the system; operations like move, pick up, fight, turn on, etc.
- Actions -- these are sequences of verbs and objects that make up the choices given to the player
Everything in the game has a basic object structure that underlies each specific object type
- General object structure
- Name of object
- Basic description of object
- Icon for object
- Type of Object
- Objects might have images, sounds, video, music attached to it (probably not every object -- maybe only rooms)
- Objects may be flagged for display upon some specific triggers or they appear in a list that the user can choose from to trigger it
Types of objects
- Specific places in the gameworld
- Specific objects in the gameworld
- Specific living things in the gameworld
Designers edit these object types with simple dialogs and can choose from pre-populated objects from a clip list
Each object has a unique icon
Simple hierarchical lists make it easy to identify rooms that hold things or creatures and to re-sort the lists of things for quick editing
Verbs are the fundamental things that can happen in the game. They're at a smaller level of granularity than Actions. The set of verbs available to the player is fixed; programming an adventure game consists of grouping verbs together into actions.
Actions are basically choices the player may take in the system. Actions are collections of verbs and the objects they operate on. Actions can also include conditionals to decide when they are available as options
- Universal Actions are always available. Default UAs are: walk (only for rooms), look (any object), use (only for things) and talk (only for creatures which are verbose). Also, creatures have a receive method that can receive an object by a give action from another creature (maybe this can be the same of use action). That means, for example, every room will have a "walk" method that is callable by a creature. A thing can't talk or go to anywhere and you cannot use an item from your backpack with a room, except if these are assigned manually to them from developer.
- Local Actions are tied to particular objects. For example, a local action tied to a room is only available if the player is in that room. A local action tied to an object is only available if the object is in the player's inventory. These actions can be extended (or use) universal actions, or implement a new operation.
Details in python implementation: ** removed this temporarily **
Action scripts are simply a sequence of verbs (possibly including objects). They also have an optional conditional system that can be tested. Possible conditions include the presence of certain objects in the room or in the inventory. Conditions can be combined with AND and OR.
If the condition evaluates to true, the action is displayed to the user as a choice.
The plan is to allow these scripts to be composed simply with drag and drop.
Note: I think that variables are just another object type, but we'll think about it some more. - Roberto: I think variables aren't objects as they are only stored data about the game and they can't call an action.
The system will have several variables that the game can keep state over. These game and player variables can be tested for by an overall game-script (a simple overall conditional script) and when met invoke a game over occurance, room, etc.
The variables I've thought of so far include: score, time, currency, life, ability points, offense, defense, user 1, user 2.
These variables as simple as they are let us offer some rudimentary RPGness to the system that could have kids accumulating wealth, casting spells, fighting creatures, etc. I've tried to choose variables that are basic - we should allow the designer to create two unnamed variables.
These can then be referred to in the scripts as well.
The player can create conversations with characters. We will need a specific conversation design - I have one but need to refine it before posting it.
(Should probably be a hierarchical tree with cross-references to allow for looping.)
Editing should be based on putting things on a map with iconography and a click and edit framework with various dialogue boxes. A hierarchal chart along the side makes it easy to manage objects in the system as well.
The camera being active is a good tool for recording pictures and video. Black & White mode should also get some attention.
Being able to integrate artwork easily into the game is important. We will have to think about what we can do to allow people to create various collages in the engine as well as provide some artwork library for people to use but we can't recreate an entire in-game drawing program.
Sounds could also chosen from a menu or recorded using the mic. Same with video. We should beware though of memory limits - perhaps limiting the overall size of such things to ensure small-enough game files.
We need to figure out how all text edited into the system could ideally be easily edited including simple search and replace, bold, italics, etc. Perhaps simple <HTML> markup for simple stuff (then kids learn HTML?) or a wiki style markup? Would also be good for there to be an easy means to integrate a spell checker too. Roberto: why we don't integrate with sugar text editor (ABI word modified)?