From 4e7ec6b089bf4a954b66ad6727eca7a2ad392dfc Mon Sep 17 00:00:00 2001 From: Mees van der Wijk Date: Thu, 14 Aug 2025 18:29:45 +0200 Subject: [PATCH] Updated sidebar --- ModuleServerAPIGameLibIntroduction.md | 116 ++++++++++++++++++++++++++ _Sidebar.md | 7 +- 2 files changed, 120 insertions(+), 3 deletions(-) create mode 100644 ModuleServerAPIGameLibIntroduction.md diff --git a/ModuleServerAPIGameLibIntroduction.md b/ModuleServerAPIGameLibIntroduction.md new file mode 100644 index 0000000..f2e6140 --- /dev/null +++ b/ModuleServerAPIGameLibIntroduction.md @@ -0,0 +1,116 @@ +# ModuleClientApi - GameLib Introduction + +The **GameLib** is Getiyo's powerful game development framework designed to create engaging, synchronized multiplayer experiences that work seamlessly across all connected devices. At its core, the GameLib follows a **server-authoritative architecture** that ensures every player sees exactly the same game state, regardless of their device or connection quality. + +## Why Server-Authoritative Architecture Matters + +Traditional client-side games can quickly become chaotic in multiplayer scenarios—players see different positions, scores vary between devices, and cheating becomes virtually impossible to prevent. GameLib solves these problems by centralizing all critical game logic on the server side. + +**The golden rule: All game logic must run on the server.** This fundamental principle ensures: + +- **Perfect Synchronization**: Every connected device displays identical game states in real-time +- **Cheat Prevention**: Players cannot manipulate game outcomes since all calculations happen server-side +- **Consistent Performance**: Game timing and physics remain stable regardless of individual device capabilities +- **Reliable Multiplayer**: Eliminates state conflicts as the server maintains the single source of truth + +## Clear Separation of Responsibilities + +GameLib enforces a clean division between server and client responsibilities: + +**Server-Side (ModuleServerAPI) handles:** + +- Game loop timing and progression +- Collision detection and physics calculations +- Player input validation and processing +- Score tracking and leaderboard management +- Win/loss condition evaluation +- All business logic and rule enforcement + +**Client-Side (ModuleClientAPI) focuses on:** + +- Visual representation and rendering +- User interface elements and feedback +- Smooth animations and visual effects +- Displaying server-provided game state + +Think of clients as "smart displays" that beautifully present the server's authoritative game state. + +## Built-in Game Infrastructure + +GameLib provides three essential infrastructure components that work seamlessly together through standardized APIs, giving you complete flexibility in how you implement your multiplayer experience. + +### **Modular Architecture** + +The beauty of GameLib lies in its modular approach. When you create a GameLib project, you're not limited to building traditional games. You can create: + +- **Game modules** that handle core gameplay mechanics +- **Controller modules** for custom input interfaces +- **Queue modules** for player management systems +- **Scoreboard modules** for displaying results and rankings + +All communication between these modules is handled automatically through the GameLib API, making it effortless to mix and match components. + +### **Ready-to-Use Default Modules** + +GameLib includes polished, production-ready modules that work out of the box: + +**Default Controller Module** + +- Standardized game controls (directional movement, action buttons) +- Cross-platform compatibility (mobile, tablet, desktop) +- Support for both binary (on/off) and analog (intensity-based) controls +- Professional styling that matches Getiyo's design language + +**Default Queue Module** + +- Real-time queue visualization for all participants +- Professional styling that matches Getiyo's design language + +**Default Scoreboard Module** + +- Multiple simultaneous scoreboards support +- Flexible formatting options (numbers, duration, custom displays) +- Automatic sorting and ranking systems +- Real-time score updates across all devices + +### **Custom Module Development** + +When the default modules don't fit your vision, you have complete freedom to build custom alternatives: + +**Custom Controllers**: Create unique input experiences—from drawing interfaces to voice controls to gesture-based interactions. Your custom controller automatically communicates with games through the standard GameLib API. + +**Custom Queues**: Build specialized waiting experiences. + +**Custom Scoreboards**: Design unique visualization systems for your specific game type—from simple leaderboards to complex statistical displays or interactive result presentations. + +### **Seamless Integration** + +The real power emerges when these modules work together. A racing game can use: + +- The default controller for steering inputs +- A custom queue module that shows car selection during waiting +- A custom scoreboard displaying lap times and race positions + +All modules communicate through GameLib's standardized API, so your custom controller will work with any GameLib game, and your game will work with any GameLib controller. This creates a rich ecosystem where components can be shared and reused across different projects. + +### **Plug-and-Play Simplicity** + +Whether you use the defaults or build custom modules, GameLib handles all the complex communication, state synchronization, and player management behind the scenes. You simply focus on creating engaging experiences while GameLib ensures everything works together flawlessly. + +## Development Advantages + +By leveraging GameLib's architecture and pre-built components, you gain: + +**Rapid Development**: Skip months of infrastructure work and focus on what makes your game unique. No more building input systems, queue management, or scoreboard functionality from scratch. + +**Proven Reliability**: Every component has been battle-tested across numerous Getiyo productions, ensuring stability and performance under real-world conditions. + +**Consistent User Experience**: Players immediately understand how to interact with your game because they recognize the familiar, polished interface elements. + +**Scalable Architecture**: As your game grows in complexity or player count, the server-authoritative design naturally scales without requiring architectural changes. + +## Getting Started + +Creating a multiplayer game with GameLib is straightforward. The server handles all game logic while clients provide beautiful, responsive interfaces. With built-in controllers, queues, and scoreboards, you can focus entirely on crafting engaging gameplay mechanics rather than wrestling with technical infrastructure. + +Whether you're building a fast-paced action game, a strategic puzzle challenge, or an interactive quiz experience, GameLib provides the foundation you need to create memorable multiplayer moments that work flawlessly across every device in your audience. diff --git a/_Sidebar.md b/_Sidebar.md index 23eab0e..ce10101 100644 --- a/_Sidebar.md +++ b/_Sidebar.md @@ -23,10 +23,11 @@ ## [ModuleServerAPI](./ModuleServerAPIIntroduction) - [Introduction](./ModuleServerAPIIntroduction) -- [ModuleServerAPI](./ModuleServerAPI) +- [ModuleServerAPI Specification](./ModuleServerAPI) - [Client](./ModuleServerAPIClient) - [Property](./ModuleServerAPIProperty) -- [GameLib](./ModuleServerAPIGameLib) +- [GameLib Introduction](./ModuleServerAPIGameLibIntroduction.md) + - [GameLib Specification](./ModuleServerAPIGameLib) - [Room](./ModuleServerAPIGameLibRoom) - [Game](./ModuleServerAPIGameLibGame) - [GamePlayer](./ModuleServerAPIGameLibGamePlayer) @@ -42,7 +43,7 @@ ## [ModuleClientAPI](./ModuleClientAPIIntroduction) - [Introduction](./ModuleClientAPIIntroduction) -- [Documentation](./ModuleClientAPI) +- [ModuleClientAPI Specification](./ModuleClientAPI) - [User](./ModuleClientAPIUser) - [Neighbor](./ModuleClientAPINeighbor) - [Neighbor Results](./ModuleClientAPINeighborResults)