[Rpg-maker-design] Initial design discussion

[Jon E. <je...@mi...>]

Alright, so now that we've got the main developers on this list, I'm 
going to put up what I've come up with. If you're not one of the 
programmers, you can ignore the following, and rejoin us in the 
following paragraph.

My initial concept is to have this be a modular design. We have a core 
interpreter engine that'll be used at all times, but then there are 
other modules for use as needed by the individual authors. For instance, 
there will be several interface designs (well, at least two, as you'll 
see below) and several graphic modules, and several sound modules, 
and... that's pretty much it. This will not only ensure that a game can 
be customized to even the most minute details, but also make it 
potentially cross-compatible.

Now, for each of the component areas, we have several goals. These are 
ones I came up with from the top of my head late at night, so I'm sure I 
missed something. It's best to get any feature requests in at the 
earliest stage possible, so if you have an idea for something that 
should be implemented, talk about it with this list.

For the purposes of simplicity, I've grouped everything into 6 
components that can be worked on, for the most part,  independently. 
I'll go through each one with a brief description and list of features 
I've come up with.

1) Interpreter
This is where scripts get turned into games. Basically, there is only 
one goal here, and that's to design a simple language that scriptwriters 
can use to create powerful, full-featured games. Depending on how we go 
about this, it may be on-the-fly or a compiler.

2) Engine
The Engine is where we run the game itself once it's interpreted. Most 
feature ideas will be right here, including any gameplay features we 
want to be able to support. For instance:
-Characters
-Group combat
-Single combat
-Map movement
-Areas
-Random monsters
-NPCs
-Stat modification (levels)
-Cutscenes

3) Interface
The Interface is how the player interacts with the game itself. While 
intrinsically tied with graphics, this is not where graphical features 
will be worked on. Instead, the interface is more things like controls, 
how one loads a new script, choosing options, etc. In order to test our 
engine before getting a full graphical interface going, we're going to 
need to design a command-line program that can be used to run all 
features we support in the Engine.

4) Display
This is where things start to look nice. Once we get the engine working 
properly, we can start supporting things like... full-color maps. And 
animation. And all that cool stuff. Things we need to consider here:
-Supported image types
-Top-down 2D view
-Slightly-behind 3D view
-Wipes

5) Sound
A game's not a real game nowadays without some sound. Personally, I'm 
not going to worry about this one for a while, until we get through the 
other 4 components.
-Sound FX
-Music
-MP3 / Midi / OGG

6) Scripts
The engine can't run games without scripts. Once we get an interpreter 
working, we should be working on designing scripts that show off our 
features and demonstrate how to do certain things. Once we have an 
official release, we're also going to need a full script so there's a 
reason for people to download it.

And that's it for components. Which brings us to the final topic: Our 
short-term goals and milestones. Here's my plan, based only on the ideas 
above. This may change, obviously, with more discussion. Each alpha 
release will add more features and show them working. Essentially, each 
stage is a proof-of-concept.

Alpha 0.1: Command-line interface to character movement on 
partially-obstructed map
Alpha 0.2: Add other objects to grid with speech possible (3 statements)
Alpha 0.3: Add defined combat with one character vs 1 NPC (simple 
fight/run command)
Alpha 0.4: Add random monsters on different map types (add different map 
types!)
Alpha 0.5: Add team-based combat (simple turn-based)
Alpha 0.6: Add more options to combat (magic/powers/heal)
Alpha 0.7: Add areas (dungeons/towns/etc)
Alpha 0.8: Let characters level based on experience (levels only - not 
each stat)
Alpha 0.9: Modify party
Alpha Release 1.0: Text-based, multi-area game with random monsters and 
XP. MUD, essentially.