Architecture Overview

High-level architecture of Minecraft Community Edition client and server components

Minecraft Community Edition is built on a client-server architecture with clear separation between the Minecraft.Client and Minecraft.World modules. The codebase is designed for cross-platform console deployment with platform-specific abstractions.

Core Components

The architecture consists of two primary Visual Studio projects:

Minecraft.Client

The client-side rendering and user interface layer. Key responsibilities:

• Rendering Pipeline: Level rendering, entity rendering, GUI rendering
• Network Client: Connection management via ClientConnection
• Input Handling: Controller/keyboard/mouse input processing
• Platform Abstraction: Platform-specific implementations for Xbox, PlayStation, Windows

Main Class: Minecraft (Minecraft.h:47)

class Minecraft
{
public:
    MultiPlayerGameMode *gameMode;
    MultiPlayerLevel *level;
    LevelRenderer *levelRenderer;
    shared_ptr<MultiplayerLocalPlayer> player;
    GameRenderer *gameRenderer;
    Textures *textures;
    SoundEngine *soundEngine;
    
    // Split-screen support
    shared_ptr<MultiplayerLocalPlayer> localplayers[XUSER_MAX_COUNT];
    MultiPlayerGameMode *localgameModes[XUSER_MAX_COUNT];
};

Minecraft.World

The core game logic and world simulation layer:

• Level System: World generation, chunk management, tile entities
• Entity System: Mobs, players, projectiles, items
• Game Logic: Block interactions, crafting, AI, pathfinding
• Network Protocol: Packet definitions and serialization
• Save/Load: Level persistence and NBT data

Main Class: Level (Level.h:45)

class Level : public LevelSource
{
public:
    static const int maxBuildHeight = 256;
    static const int minBuildHeight = 0;
    
    vector<shared_ptr<Entity>> entities;
    vector<shared_ptr<Player>> players;
    vector<shared_ptr<TileEntity>> tileEntityList;
    
    ChunkSource *chunkSource;
    Dimension *dimension;
    Random *random;
};

Solution Structure

The main Visual Studio solution is MinecraftConsoles.sln which contains:

Minecraft.Client

Platform-specific rendering and UI code:

• Xbox/ - Xbox 360 platform code
• Durango/ - Xbox One platform code
• PS3/ - PlayStation 3 platform code (includes SPU tasks)
• PSVita/ - PlayStation Vita platform code
• Orbis/ - PlayStation 4 platform code
• Windows64/ - Windows PC platform code
• Common/ - Shared platform code

Minecraft.World

Platform-agnostic game logic:

• Entity and tile definitions
• World generation (biomes, structures)
• AI and pathfinding
• Inventory and crafting
• Network packet definitions
• NBT serialization

Platform Abstraction Layer

The codebase uses several abstraction mechanisms for cross-platform support:

Thread Management

// C4JThread.h provides platform-agnostic threading
C4JThread* levelTickEventQueue;
C4JThread::Event* m_hWakeReadThread;
CRITICAL_SECTION m_setLevelCS;

Rendering Abstraction

• C4JRender: Platform-specific rendering interface
• Texture Format: Dynamic texture format selection based on platform
• SPU Tasks: PlayStation 3 uses SPU (Synergistic Processing Unit) tasks for parallel rendering

Network Abstraction

• Socket: Platform-agnostic socket wrapper
• P2PConnectionManager: Platform-specific P2P implementations (Windows, Xbox, PlayStation)

Memory Architecture

The codebase is optimized for console memory constraints with careful buffer management and streaming systems.

Key Constants

// LevelRenderer.h - Platform-specific command buffer sizes
#if defined _XBOX_ONE
static const int MAX_COMMANDBUFFER_ALLOCATIONS = 512 * 1024 * 1024;
#elif defined __ORBIS__  // PS4
static const int MAX_COMMANDBUFFER_ALLOCATIONS = 448 * 1024 * 1024;
#elif defined __PS3__
static const int MAX_COMMANDBUFFER_ALLOCATIONS = 110 * 1024 * 1024;
#endif

Multithreading Model

Main Threads

1. Game Loop Thread: Main tick, entity updates, world simulation
2. Render Thread: Chunk rebuilding, texture updates
3. Network Thread: Packet sending/receiving (read/write threads)
4. Post-Processing Thread: Chunk post-processing during level creation

Thread Safety

Critical sections protect shared data:

• m_entitiesCS: Entity list modifications
• m_tileEntityListCS: Tile entity updates
• m_csRenderableTileEntities: Renderable tile entity tracking
• m_setLevelCS: Level switching

Split-Screen Architecture

Minecraft CE supports up to 4 local players simultaneously:

// Per-player instances
shared_ptr<MultiplayerLocalPlayer> localplayers[XUSER_MAX_COUNT];
MultiPlayerGameMode *localgameModes[XUSER_MAX_COUNT];
ItemInHandRenderer *localitemInHandRenderers[XUSER_MAX_COUNT];
ClientConnection *m_pendingLocalConnections[XUSER_MAX_COUNT];

// Per-player rendering
TileRenderer *tileRenderer[4];
MultiPlayerLevel *level[4];

Each local player maintains their own:

• Connection to the server (even in local play)
• Viewport and camera
• Inventory and game mode
• Statistics and achievements

Next Steps

Client-Server

Learn about client-server separation and connection management

Networking

Explore the network protocol and packet system

Rendering

Understand the rendering pipeline and platform optimizations

API Reference

Browse the complete API documentation