Mammoth is a massively multiplayer game research framework. It's goal is to provide an environment for experimentation in an academic setting in areas such as distributed systems, fault tolerance, databases, modeling and simulation, artificial intelligence and aspect-orientation..
The world of Mammoth is viewed from a 3D perspective. The world contains a fixed number of game characters, some of which can be controlled by humans. A player can move around in the game, examine objects, pick them up, and drop them again. Player can also talk to other players in private, or engage in multiplayer conversations. The picture shown above is a screenshot from our McGill Campus world map.
The distribution middleware of Mammoth is based on replicated objects, and therefore allows developers to run classic client-server, hybrid, or Peer-2-Peer configurations of the game. At run-time, Mammoth supports remote monitoring of nodes participating in a Mammoth game, as well as logging of game events to a central database for offline analysis. Mammoth also offers a modular and flexible infrastructure for the definition of non-player characters with behavior controlled by complex artificial intelligence algorithms or statechart-based models. The Mammoth code is organized in a modular architecture where different components, such as the network engine, the replication engine, or interest management, can easily be replaced.
A centralized server MMOG architecture has difficulty scaling to a large number of players. Mammoth builds on replicated object technology to provide a flexible distribution middleware to the game developer. Game state is encapsulated in replicated objects. One Mammoth node is assigned the master copy of a replica, and only this node is allowed to perform state updates. Other Mammoth nodes that need to be aware of the state encapsulated in the object receive copies of the replicated object, and update notifications when the state of the master copy changes. The replication is, however, transparent to the game layer, which simply calls read or write operations on replicated objects, ignoring whether the current node currently holds a master or a replica.
Broadcasting all state changes to every player of a massively multiplayer game is not a viable solution. To successfully overcome the challenge of scale, massively multiplayer games have to employ sophisticated interest management techniques that only send relevant state changes to each player. Mammoth implements a reachability-based interest management algorithm that takes into consideration the occlusion created by obstacles in the world to further filter state changes. The algorithm uses a triangulation of the world space as its base structure in order to achieve good scalability.
Mammoth integrates a dynamic load balancing mechanism that considers both the load associated with performing game actions (i.e. holding master copies and broadcasting state updates to replicas) as well as the load incurred through interest management (i.e. figuring out which Mammoth nodes need to receive replicas of game objects). The interest management duties are typically assigned to reliable nodes (which we call servers for that reason). An obstacle-aware partitioning of the Mammoth world into small triangles makes it possible to split the Mammoth world into interest management regions (which we call cells), and assign those to the servers.
As players join the game, their nodes can take on load due to game actions and update notifications. When players flock to some part of the world, our system is able to dynamically redistribute the imbalanced interest management load among servers by modifying the size and geometry of their associated cells.
Fault Tolerance and Cheat Detection
The distribution middleware of Mammoth also provides basic fault tolerance support. Mammoth can currently tolerate client node failures, as well as server failures, provided that no two servers fail simultaneously. When run in Peer-2-Peer mode, where game calculations are off-loaded to client nodes, Mammoth also provides a simple auditing mechanism that allows trusted nodes to verify the correct behavior of client nodes.
In modern games, describing the behaviors of NPCs requires specifying observation-action rules in scripts which are then interpretered during gameplay. In practice, NPC behaviour scripts tend to be become complex and hard to manage leading to a significant overhead in implementation. Instead, we propose to construct the behavior of NPCs in an abstract and intuitive way using well-known modeling formalisms. Behaviors are designed by modeling the relationships between the observed environment and the NPC's actions using statecharts and an underlying abstract event system. Modeled behaviors are automatically converted to code that fits into Mammoth's NPC framework. The removal of dependence on domain-specific knowledge (ie. a particular scripting language) allows modelers to build and reason about re-usable NPC behavior components.
The content editor is multi-purpose tool that allows the creation of new content for Mammoth using an intuitive visual interface. Tightly integrated with the item hierarchy system, the content editor allows a user to create new types of world objects and instantiate them when creating a map. Great care is taken into designing tools to simplify tedious and repetitive tasks. One such example is the wall drawing tool. New features added to Mammoth are easy to integrate into the content editor since both tool share the same core code.
Path-finding consumes a significant amount of resources, especially in movement-intensive games such as (massively) multiplayer games. Mammoth uses a map-conforming, hierarchical path-finding strategy, based on the classic A* algorithm, in combination with caching optimizations. Compared to other simpler path finding algorithm, this technique greatly reduces performance cost. The quality of the path-finding will be further increased (and performance cost reduced) once we integrate our path-finding strategy with the interest management system.
Given the increasing complexity of items in games, a system was devised for Mammoth to allow the creation of items through a hierachy. This hierarchy allows for similar items to share the attributes they have in common and save space while saving the world in a XML file. It was further extended to encompase the static background objects in the world to allow for the customized creation and extension of anything in the game world.
Need help? Click here!