MMO RPG Server Development

Expert coding rules and best practices for building high-performance MMO RPG servers using TypeScript, WebAssembly, and Node.js worker threads.

Core Philosophy

Build scalable, maintainable MMO server infrastructure that prioritizes:

Performance Architecture

1. WebAssembly for Heavy Computation

2. Worker Threads with Shared Memory

3. Thread Safety Patterns

```typescript

// Atomic operations for shared state

Atomics.store(sharedArray, index, value);

const current = Atomics.load(sharedArray, index);

Atomics.add(sharedArray, index, delta);

```

4. Performance Monitoring

TypeScript Best Practices

5. Strict Type Safety

6. Interfaces for Contracts

```typescript

// Define abstractions, not implementations

interface IPlayer {

id: string;

position: Vector3;

move(delta: Vector3): void;

}

// Implement interfaces for modularity

class Player implements IPlayer { ... }

class VIPPlayer implements IPlayer { ... }

```

7. Generic Type-Safe Components

```typescript

class Cache<T> {

private data = new Map<string, T>();

get(key: string): T | undefined { return this.data.get(key); }

set(key: string, value: T): void { this.data.set(key, value); }

}

```

SOLID Principles

8. Single Responsibility (SRP)

9. Open-Closed (OCP)

10. Liskov Substitution (LSP)

11. Interface Segregation (ISP)

12. Dependency Inversion (DIP)

```typescript

// Depend on abstractions via constructor injection

class GameServer {

constructor(private logger: ILogger, private db: IDatabase) {}

}

// Inject concrete implementations

const server = new GameServer(new ConsoleLogger(), new PostgresDB());

```

Lean Code Practices

13. Minimize Duplication

14. Efficient Algorithms & Data Structures

15. Token Optimization

Project Structure

```

project-root/

├── src/

│ ├── core/

│ │ ├── lobby/

│ │ │ ├── lobbyManager.ts # Lobby lifecycle

│ │ │ └── lobbyWorker.ts # Worker thread logic

│ │ └── game/

│ │ ├── player.ts # Player entity

│ │ └── world.ts # World state

│ ├── utils/

│ │ ├── logger.ts # Centralized logging

│ │ └── helpers.ts # Shared utilities

│ ├── config/

│ │ ├── env.ts # Environment vars

│ │ └── constants.ts # Magic numbers

│ ├── wasm/

│ │ ├── generator.cpp # C++ source

│ │ ├── generator.wasm # Compiled WASM

│ │ └── generator.ts # TS wrapper

│ ├── server/

│ │ └── server.ts # Entry point

│ └── index.ts # Bootstrap

├── tests/ # Unit tests (Jest)

├── scripts/ # Build/deploy scripts

├── docs/ # Architecture docs

├── package.json

├── tsconfig.json

└── yarn.lock # Locked dependencies

```

Naming Conventions

Error Handling & Logging

16. Centralized Error Management

```typescript

// utils/logger.ts

export class Logger {

error(msg: string, err: Error): void { /* ... */ }

warn(msg: string): void { /* ... */ }

info(msg: string): void { /* ... */ }

}

// Usage

try {

await riskyOperation();

} catch (err) {

logger.error('Operation failed', err);

throw new GameError('Player action failed', err);

}

```

17. Async Best Practices

Testing & Quality

18. Unit Testing Requirements

19. Code Quality Tools

Dependency Management

20. Mandatory Yarn Usage

Version Control

21. Git Practices

Key Implementation Notes

1. **WASM Integration**: Instantiate modules async, cache instances globally

2. **Worker Threads**: Spawn per region/shard, communicate via message passing

3. **Shared Memory Layout**: Document buffer structure (offsets, types) in comments

4. **Scalability Path**: Start with workers, scale to multi-process + Redis if needed

5. **Stability**: Use Node.js LTS, well-tested WASM toolchains, avoid experimental features

Documentation Requirements