How do we distribute core game play load across multiple processes in a way that supports flexible scaling and efficient allocation of computing resources?
We are developing the server for a massively multiplayer online game with a distributed architecture. The game design seeks to create an immersive play experience by enabling thousands of players to interact with each other in a shared virtual world. Continue reading Pattern: Responsibility-Oriented Game Server
Software architecture is about the big picture of development. It’s also about identifying and managing engineering risk. The development team is at the nexus of these two concepts. The team is your greatest asset, and the greatest contributor to the success of any software architecture. The big picture revolves around the development team and its ability to create the software for your game.
The team’s development environment is a cornerstone of its ability to deliver. A team with inadequate tools or support to do the work required is at least inefficient, if not ineffective. A team with an inferior development environment is a likely source of engineering risk. Continue reading Invest in your Development Environment
The Know what to Build articles discuss how to identify our multiplayer game’s server architecture early in the project. This reveals technical risks and key engineering questions before we’ve invested much development time.
In a recent post I described how to assess the impacts of our game’s key design features on the server architecture. In this post I’ll describe a way to develop a high level estimate of the amount of work our server will have to do, to help us know what to build.
The Server Loop as a Model
Developing the architecture for our game server requires making trade-offs. Knowing how to do this requires a general understanding of the operations the server will perform, and the amount of work required.
We’ll use the server loop as a conceptual model for this. The server loop is a variant of the classic game loop pattern, applied to server-side functionality. Because this is just a model, we’ll ignore implementation details such as fixed or variable step sizes. Also, for now we’ll assume our server is single-threaded and runs on a single core machine. Continue reading Know what to Build: The Server Loop
What is the game server’s deployment architecture?
We are developing the server for a multiplayer online game with a client-server architecture.
The game design seeks to create engaging game play within fixed technical and resource constraints. It trades game play features against number of concurrent players, player immersion, and size or complexity of the game world to simplify implementation, deployment, and maintenance. Continue reading Pattern: Monolithic Architecture
Simon Brown, author of Software Architecture for Developers, talks with Sven Johann about using Software Architecture Sketches to visualize, communicate and document software architecture. Continue reading [Podcast] SE Radio: Software Architecture Sketches with Simon Brown
In an earlier post I described some multiplayer game types and identified several clues about the server architecture required to build each type. Now I want to take a closer look at some of those clues to see how they can help us know what to build. Continue reading Know what to Build: Assessing Impacts