WARNING: This framework is still in pre-alpha and is subject to a high rate of churn.
I am anticipating an alpha release in or around November of 2010. Until then I can't support this for anything but my own development!
The AESOP project is a framework for storytellers. In particular, it is designed for creating multiplayer networked 3D games. It has these objectives:
- Cooperative: a primary goal is to make it easy for storytellers to allow multiple people to experience the story together. This includes multiple people participating on the same client (e.g, shared or split-screen).
- Open: this is an open source project and uses open (well, public) protocols.
- Story-driven: AESOP is intended for storytellers. This means the data model is designed around providing story elements, not just physical rendering. AESOP is not a deathmatch engine! It is built for non-linear plot evolution.
- Extendible: A purpose of the project is to provide a simple but easily extendable framework so storytellers can create immersive experiences. The existing framework is a game engine on its own, but new capabilities can be swapped in or added.
AESOP as a framework is built to be highly extendible. In fact, most of the engineering involves incorporating as many already-available libraries as possible, while keeping coupling between components to zero. See AESOP Requirements and Features.
For instance, all of these should be trivial to swap out or extend:
- 3D models including animation
- physics engine
- rendering system
- artificial intelligence
The core AESOP package includes default implementations of all of the above, so it is immediately usable. The defaults use Bullet (http://www.continuousphysics.com/) for physics, there are a combination of 3D model formats supported, OpenGL and glut are used for rendering.
The basic, non-swappable pieces of AESOP are the core client/server communications framework. These are client and server libraries which establish the basic communication protocols, deal with discovery and lag, and provide easy means for client game code to talk to the server. This is built to be as general as possible, so that games needing custom communication with the server can add it easily.
In addition to tools and utilities, there are two key binaries that the framework supports, intended for distribution with the final game:
- server: This is designed to be run on hosts without any graphics capability. So the core data models and decoupling help ensure that server code does not pick up any dependencies on rendering libraries. Physics is run authoritatively on the server. All AI runs on the server.
- client: This is the code that runs on a player's machine, including full graphics and sound. The client also runs the physics engine in a predictive mode to accommodate network lag.
This is the main intended use case for players:
- A group of people decide they'd like to play a game.
- The group finds the gzip'd package containing the executables and data files for the game they want to play.
- One of them installs the server on an accessible host.
- Everyone installs the client on their local machines. Some players could share the same client (play in split screen or a shared screen, depending on the story).
- The person running the server starts the server, and lets everyone know the server address and port.
- All players start their local client, and connect to the server.
- Everyone plays the game!
This is the main intended use case for storytellers:
- The storyteller thinks of a story to tell.
- The story is fully specified in a directory structure. In AESOP, you can think of the story as a large rich database that contains everything the client and server need to present the story. This includes things such as:
- 3D models and textures for display (only used by client)
- events and triggers
- story state (objectives accomplished, triggers hit, etc.)
- The storyteller picks or builds the appropriate server and client binaries to run.
- The storyteller tests out their story.
- When ready, the storyteller gzip's their story directory tree (including the media and executable binaries) and makes it publicly available for playing.
Massively-multiplayer mode (such as MMOPRGs, see http://en.wikipedia.org/wiki/MMORPG) is not supported. AESOP aims to support around 16 players at once. The primary use case is a shared experience with a small group immersed in a story-driven world. If you are looking for a MMORPG experience, try WorldForge (http://www.worldforge.org/).
AESOP is probably best for LAN play, although the wire protocol is kept as spartan as possible to allow WAN play. AESOP uses standard but simple techniques to accommodate some network lag.
AESOP is released freely to the community under the BSD license (see http://en.wikipedia.org/BSD_licenses). Some portions of the code are from other authors and those areas may be subject to other licenses. Those exceptions are called out clearly.