Apocalypse mirror Sourceforge mirror

			News | Info | Characters | Arenas | Screenshots | Forums | Download
	Developer:		Making of | Character-HOWTO | AI Design | Submit a Character
	Documentation:		| | | |

OpenMortal Documentation

0.7

The document you read now describes the design of OpenMortal. This page serves as a starting point. The documentation is generated with doxygen (http://doxygen.org).

OpenMortal consists of two main parts: the frontend and the backend.

• The frontend is a C++ program, responsible for multimedia (sounds, music, graphics) and general interaction with the players (menus, keyboard input), and the demo and intro screens.

• The backend is written in Perl, and is incorporated into the C++ program with Perl embedding.

1. Modules

The classes of OpenMortal are organized into the following groups (see Modules above).

• Sound and graphics - OpenMortal uses SDL (http://libsdl.org) for hardware access such as screen drawing, music, sound effect and keyboard input. For information and documentation of SDL, SDL_image, SDL_ttf and SDL_mixer, please look at the SDL homepage.
• Fighter selection
• Networking layer
• Demos and special screens
• Game logic (frontend + backend connection)

2. Main Functions

These global functions implement important parts of the program. They serve as entry points into functional parts.

• DoMenu() - Displays and runs the menu over the current screen
• GameOver() - Displays the "Final Judgeent" screen
• DoDemos() - Runs the demos in an endless loop until a game is started or the program ends.
• DoGame() - Runs the game.
• DoOnlineChat() - Connects to and runs the MortalNet.
• CPlayerSelect::DoPlayerSelect() - Runs the player selection screen.

3. Definitions

Here are the definitions of terms used in this documentation.

Player

Player refers to one of the two persons playing the game. A player chooses a fighter. The two players are referred to as "Player 1" and "Player 2", even though the C++ and perl code count arrays from 0.

Fighter

Fighter is one of the many available characters. Usually there are only two fighters loaded at any time. Fighters are static: their properties never change. Maybe Fighter should be renamed to Character?

Game

One game is the part of the program in which the players actually compete. The game consists of a number of rounds. The player selection, and gameover screen are not part of this definition.

Round

One round starts with both players at full health, and ends either with a timeout or with a ko.

Doodad

A graphical element on the game screen that is not the background or the characters. E.g. the "3x combo" text or a thrown projectile are doodads.

Tint

A tint is a methodical change in a palette. There are many ways to tint (e.g. grayscaling, darkening, green chroma, etc). Usually when two players choose the same fighter, the fighter of player 2 is tinted.

Scene

The description of a frozen moment in the course of a game. The Backend is responsible for calculating each consecutive scene. The number of scenes calculated per second is constant (except for the "hurry up mode", or if the computer is too slow).

FPS

Frames Per Second. The FPS indicator on the screen during a game indicates the number of scenes drawn, not the number of scenes calculated by the backend.

4. C++ Coding conventions

Historically two different coding conventions were mixed in OpenMortal. Hopefully most of the old conventions are eliminated by now. Here I will describe the new conventions:

• Class names: CMixedCaps.
• Struct names: SMixedCaps.
• Typedef names: CSomeTypedef (There's some traces of the old TSomeTypedef left, these should be eliminated.
• Enum names: SomeThingEnum.
• Enum values: Prefix_ENUM_VALUE
• Method names: MixedCaps.
• Variable names: <prefix>VariableName.
• Instance property names: m_<prefix>VariableName,
• Class property names (a.k.a. static class variables): mg_<prefix>VariableName.
• Method argument names: a_<prefix>VariableName. If a reference or pointer argument is "output-only: a_<prefix>OutVariableName.
• Global variable names: g_<prefix>VariableName.

The prefixes used are:

• Array of something: a<something>
• Pointer to something: p<something>
• Reference of something: r<something>
• Basic types: Integer: i; char: c; double: d; enum: en; object (class or struct): o; std::string: s;

Example:

CSomeExampleClass: public CSomeBaseClass
{
public:
    CSomeExampleClass();
    void SomeMethod( int& a_riOutSomething );
protected:
    int m_iSomething;
    char* m_pcSomethingElse;
    static enum SomeThingEnum
    {
        Ste_VALUE,
    } mg_enWhatever;
};

---