Getiyo-Public/Getiyo-Developer-Documentation
1
0
Fork 0
Code Issues 6 Releases Wiki Activity

Merge branch 'master' of https://git.morphix.nl/Getiyo-Public/Getiyo-Developer-Documentation.wiki

Mees van der Wijk
2025-08-21 22:03:40 +02:00
parent cfcf04b8a7 e9f1d05f4f
commit 4434d0ff99
9 changed files with 399 additions and 154 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
Home.md

@@ -22,56 +22,9 @@ Modules in Getiyo are structured with a clear separation of concerns:
Most modules will rely solely on these two layers—server-side logic with secure module properties, and a user-facing interface enriched by live-updatable reference properties. Control or external pages are available for advanced use cases (custom moderation UIs or standalone module views) but are optional and should be added only when necessary. Most modules will rely solely on these two layers—server-side logic with secure module properties, and a user-facing interface enriched by live-updatable reference properties. Control or external pages are available for advanced use cases (custom moderation UIs or standalone module views) but are optional and should be added only when necessary.
## Outline ## Getting Started
- [Introduction](./Home) | **Development Environment** | **ModuleServerAPI** | **ModuleClientAPI** |
- [Prerequisites](./Prerequisites) | -------------------------------------- | --------------------------------------------- | --------------------------------------------- |
- [Setting up server](./ServerSetup) | [Module Structure](./ModuleStructure) | [Introduction](./ModuleServerAPIIntroduction) | [Introduction](./ModuleClientAPIIntroduction) |
- [Config](./Config) | [GetiyoModuleTool](./GetiyoModuleTool) | [Documentation](./ModuleServerAPI) | [Documentation](./ModuleClientAPI) |
- Module Development
- [Module Structure](./ModuleStructure)
- [Module.json](./ModuleJSON)
- [Property](./ModuleJSONProperty)
- [Trigger](./ModuleTrigger)
- [Condition](./ModuleCondition)
- [Complete Example](./module.json)
- [Development environment/Building](./ModuleEnvironment)
- [GetiyoModuleTool](./GetiyoModuleTool)
- [ModuleClientAPI](./ModuleClientAPI)
- [Important Principals](./ModuleClientAPIPrincipals)
- [User](./ModuleClientAPIUser)
- [Neighbor](./ModuleClientAPINeighbor)
- [Neighbor Results](./ModuleClientAPINeighborResults)
- [GameLib](./ModuleClientAPIGameLib)
- [Controller](./ModuleClientAPIGameLibController)
- [ModuleServerAPI](./ModuleServerAPI)
- [Important Principals](./ModuleServerAPIPrincipals)
- [Client](./ModuleServerAPIClient)
- [Property](./ModuleServerAPIProperty)
- [GameLib](./ModuleServerAPIGameLib)
- [Room](./ModuleServerAPIGameLibRoom)
- [Game](./ModuleServerAPIGameLibGame)
- [GamePlayer](./ModuleServerAPIGameLibGamePlayer)
- [Scoreboard](./ModuleServerAPIGameLibScoreboard)
- [Details](./ModuleServerAPIGameLibScoreboardDetails)
- [State](./ModuleServerAPIGameLibScoreboardState)
- [GameLib CollisionSpace](./ModuleServerAPIGameLibCollisionSpace)
- [Libs](./ModuleServerAPILibs)
- [LibWebSocket](./ModuleServerAPILibsWebSocketLib)
- [Axios](https://axios-http.com/docs/instance)
- ModuleApi Shared
- [RuntimeStorage](./ModuleApiGameLibRuntimeStorage)
- Gamelib
- [GameLib GameDetails](./ModuleApiGameLibGameDetails)
- [GameLib EndScreen](./ModuleAPIGameLibEndScreen)
- [GameLib TimeSpan](./ModuleApiGameLibTimeSpan)
- [GameLib FrameCycle](./ModuleApiGameLibFrameCycle)
- [GameLib Ratio](./ModuleAPIGameLibRatio)
- [Module Debugging](./ModuleDebugging)
- [ModuleStore](./ModuleStore)
- [Bug/Feature Reporting](./Reporting)
- [Contact Details](./ContactDetails)

16
ModuleClientAPI.md

@@ -1,6 +1,6 @@
# ModuleClientAPI # ModuleClientAPI - Documentation
Class representing the ModuleClientAPI. The ModuleClientAPI is the heart of every interactive Getiyo module's front-end experience. [Click here to view the introductions.](./ModuleClientAPIIntroduction)
## Sub Classes ## Sub Classes
@@ -56,6 +56,18 @@ api.finishClientCondition(conditionId);
## Events ## Events
### onDestroy
Register a listener for when the module is destroyed from the scene. Make sure you stop your clocks and render loops here.
```javascript
api.onDestroy(callback);
```
| Argument | Type | Description |
| -------- | -------- | ------------------------------------------------------------ |
| callback | ( ):void | Function that will be called when the module gets destroyed. |
### onPropertyUpdate ### onPropertyUpdate
Register a listener for when a property updates in a scene change. The listener will also be called on initial module creation. Register a listener for when a property updates in a scene change. The listener will also be called on initial module creation.

2
ModuleClientAPIGameLib.md

@@ -1,6 +1,6 @@
# ModuleClientApi - GameLib # ModuleClientApi - GameLib
Class representing the GameLib inside the ModuleClientAPI. The GameLib is Getiyo's game development framework that enables synchronized multiplayer experiences across all connected devices. The client-side GameLib focuses on timing calculation functions and custom controller development, while all core game logic, collision detection, state management, and business rules are handled server-side through the [ModuleServerAPI GameLib](./ModuleServerAPIGameLibIntroduction). If you want to make a game, you need to look at the [ModuleServerAPI GameLib](./ModuleServerAPIGameLibIntroduction) where all the core functionality resides.
## Controller ## Controller

124
ModuleClientAPIIntroduction.md Normal file

@@ -0,0 +1,124 @@
# ModuleClientAPI - Introduction
The **ModuleClientAPI** is the heart of every interactive Getiyo module's front-end experience. When users visit your channel and see your module in action, they're interacting with code powered by this comprehensive client-side interface. Think of it as your module's direct connection to the Getiyo ecosystem—enabling real-time communication with your server-side logic, responding instantly to property changes from the editor, and creating seamless user experiences that feel native to the platform.
## What Makes ModuleClientAPI Essential
Every Getiyo module consists of two primary components: server-side logic that handles data processing and business rules, and client-side presentation that users actually see and interact with. The ModuleClientAPI bridges these two worlds, automatically establishing a persistent connection between your module's user interface and its corresponding [`ModuleServerAPI`](./ModuleServerAPI). This connection enables the real-time interactivity that makes Getiyo modules feel alive and responsive.
When you develop a module's user page, the ModuleClientAPI is automatically available as a global `api` object. This isn't just a simple communication tool—it's a comprehensive interface that understands Getiyo's unique architecture of scenes, displays, properties, and user management. Unlike traditional web development where you might manually handle WebSocket connections or polling for updates, the ModuleClientAPI abstracts away these complexities while providing powerful features specifically designed for Getiyo's live, collaborative environment.
## Real-Time Property Updates
One of the most powerful features of the ModuleClientAPI is its ability to receive live property updates through [`api.onPropertyUpdate()`](./ModuleClientAPI#onpropertyupdate). When someone editing a scene changes a color, updates text, or modifies any reference property of your module, those changes flow instantly to all connected viewers without requiring module redeployment or page refreshes. This creates an incredibly smooth content creation workflow where editors can see their changes reflected immediately across all displays.
This real-time capability extends beyond simple property updates. The ModuleClientAPI automatically handles the complexity of managing multiple module instances, ensuring that property updates reach the correct module references even when the same module type appears multiple times in a single scene. Your code simply registers listeners for the properties it cares about, and the API handles all the routing and synchronization behind the scenes.
## Seamless Communication
Communication between your module's client and server components flows through intuitive message-passing methods. The [`api.send()`](./ModuleClientAPI#send) function allows you to transmit any data to your server-side code, while [`api.on()`](./ModuleClientAPI#on) lets you listen for responses or server-initiated messages. This bidirectional communication happens over persistent connections that the API manages automatically, including reconnection handling and message queuing during temporary network interruptions.
The communication system also supports interaction between neighboring modules through [`api.onNeighborMessage()`](./ModuleClientAPI#onneighbormessage) and [`api.getNeighbors()`](./ModuleClientAPI#getneighbors). This enables sophisticated module ecosystems where different components can coordinate their behavior, share state, or trigger cascading effects across a scene.
## User-Centric Design
Getiyo's strength lies in its understanding that every viewer is a unique user with specific capabilities, preferences, and context. The ModuleClientAPI provides deep integration with Getiyo's user management system through [`api.getUser()`](./ModuleClientAPI#getuser). Your module can access user details, check device capabilities, and adapt its interface accordingly—whether someone is viewing on a mobile device, has specific accessibility needs, or belongs to a particular organization.
The user integration goes beyond simple profile access. Methods like [`api.getUser().getName()`](./ModuleClientAPIUser#getname) can automatically prompt users to enter their name if they haven't already, creating seamless onboarding experiences. Camera and microphone access, mobile device detection, and user preference management are all handled through consistent, reliable interfaces that respect Getiyo's privacy and permission models.
## Module Scope and Safety
Traditional web development often struggles with scope management when multiple components share a page. The ModuleClientAPI solves this elegantly by providing module-scoped access to DOM elements through [`api.dom()`](./ModuleClientAPI#dom). Instead of using `document.querySelector()` which might accidentally select elements from other modules, you always query within your module's specific container. This prevents conflicts and ensures your module remains self-contained and reusable.
Similarly, instead of listening to global `window` resize events, you use [`api.onResize()`](./ModuleClientAPI#onresize) to receive notifications when your specific module changes size. This module-scoped approach extends throughout the API, ensuring that your code remains robust even in complex scenes with multiple active modules.
### CSS and Sass Development
The module scoping philosophy extends to your styling approach as well. While Getiyo provides automatic isolation between modules, you must structure your HTML and CSS properly to take advantage of this system. This means you should **never write global CSS** that targets elements like `body`, `html`, `p`, or `h1` directly.
Instead, you need to create a main container element in your module's HTML with a descriptive class name, then scope all your CSS and Sass to that container:
```html
<!-- In your module's index.html -->
<div class="my-awesome-module">
<h1>My Module Title</h1>
<div class="content-area">
<button class="action-button">Click me</button>
</div>
</div>
```
```scss
// ❌ NEVER do this - affects all modules globally
body {
font-family: Arial, sans-serif;
}
h1 {
color: red;
}
// ✅ ALWAYS scope to your module's container class
.my-awesome-module {
font-family: Arial, sans-serif;
h1 {
color: red;
font-size: 24px;
}
.content-area {
padding: 20px;
.action-button {
background: blue;
color: white;
border: none;
padding: 10px 20px;
border-radius: 4px;
}
}
}
```
This scoping approach ensures that:
- **Multiple module instances** can coexist without style conflicts
- **Different module types** won't interfere with each other's appearance
- **Global Getiyo styling** remains intact and functional
- **Module reusability** is maintained across different scenes and channels
Remember that Getiyo provides global styling for module containers including backgrounds, filters, blending modes, borders, and padding. Your module's CSS should focus on the internal layout and styling of your content within your own container class, not these container-level properties that Getiyo manages automatically.
## Timing and Synchronization
Live experiences require precise timing coordination across multiple displays and users. The ModuleClientAPI provides server-synchronized time through [`api.getTime()`](./ModuleClientAPI#gettime), ensuring that time-based animations, countdowns, and coordinated actions happen simultaneously across all viewers regardless of their local clock settings or network latency.
The API also includes sophisticated timing utilities through [`api.GameLib.Timing`](./ModuleClientAPI#gametiming), offering easing functions, animation helpers, and frame-based timing tools that integrate seamlessly with Getiyo's rendering pipeline. These tools enable smooth, professional animations that feel native to the platform while maintaining perfect synchronization across all connected displays.
## Integration with Getiyo's Ecosystem
The ModuleClientAPI doesn't exist in isolation—it's deeply integrated with Getiyo's broader ecosystem of cue lists, conditions, snapshots, and show control. Your module can participate in automated sequences by finishing client conditions with [`api.finishClientCondition()`](./ModuleClientAPI#finishclientcondition), respond to volume changes and play state updates, and maintain and recall states through the runtime storage system.
Global utilities like [`ce`](./ModuleClientAPI#ce) for quick element creation, [`Feedback`](./ModuleClientAPI#feedback) for system-consistent notifications, and [`loading`](./ModuleClientAPI#loading) indicators ensure your module feels like a natural part of the Getiyo experience rather than a separate component.
## Getting Started
Every module automatically has access to the ModuleClientAPI through the global `api` object. Your journey typically begins with setting up property listeners and communication handlers:
```javascript
// React to property changes from the editor
api.onPropertyUpdate('backgroundColor', (color) => {
api.dom().style.backgroundColor = color;
});
// Communicate with your server-side logic
api.send('userAction', { type: 'click' });
// Listen for server responses
api.on('updateDisplay', (data) => {
// Update your module's presentation
});
```
The ModuleClientAPI transforms what could be complex, error-prone web development into an intuitive, powerful experience that lets you focus on creating engaging content rather than managing infrastructure. Whether you're building simple informational displays or complex interactive experiences, the API provides the foundation for professional, reliable modules that integrate seamlessly with Getiyo's live production environment.

57
ModuleServerAPI.md

@@ -1,61 +1,6 @@
# ModuleServerAPI # ModuleServerAPI
Class representing the ModuleServerAPI. The ModuleServerAPI is the powerful server-side foundation that brings your Getiyo modules to life. Every module you create relies on this API to handle the complex orchestration between users, data, and the Getiyo platform itself. [Click here to view the introductions.](./ModuleServerAPIIntroduction)
<!--
## Overview
Libs
* [libs](./ModuleServerAPI#libs)
Communication
* [on](./ModuleServerAPI#on)
* [broadcast](./ModuleServerAPI#broadcast)
Clients
* [getClients](./ModuleServerAPI#getclients)
* [getClient](./ModuleServerAPI#getclient)
* [hasClient](./ModuleServerAPI#hasclient)
* [onNewClient](./ModuleServerAPI#onnewclient)
Events
* [onModulePropertyUpdate](./ModuleServerAPI#onmodulepropertyupdate)
* [onReferencePropertyUpdate](./ModuleServerAPI#onreferencepropertyupdate)
* [onSceneChange](./ModuleServerAPI#onscenechange)
* [onFileUpload](./ModuleServerAPI#onfileupload)
* [onTrigger](./ModuleServerAPI#ontrigger)
* [onInit](./ModuleServerAPI#oninit-deprecated) **Deprecated**
Properties
* [getReferenceProperties](./ModuleServerAPI#getreferenceproperties)
* [getReferenceProperty](./ModuleServerAPI#getreferenceproperty)
* [hasReferenceProperty](./ModuleServerAPI#hasreferenceproperty)
* [getModuleProperties](./ModuleServerAPI#getmoduleproperties)
* [getModuleProperty](./ModuleServerAPI#getmoduleproperty)
* [hasModuleProperty](./ModuleServerAPI#hasmoduleproperty)
* [getLastState](./ModuleServerAPI#setlaststate)
* [setLastState](./ModuleServerAPI#setlaststate)
Files
* [readJSON](./ModuleServerAPI#readjson)
* [writeJSON](./ModuleServerAPI#writejson)
* [writeFile](./ModuleServerAPI#writefile)
* [fileExists](./ModuleServerAPI#fileexists)
* [addHost](./ModuleServerAPI#addhost)
* [removeHost](./ModuleServerAPI#removehost)
* [hasHost](./ModuleServerAPI#hashost)
* [hostFile](./ModuleServerAPI#hostfile-deprecated) **Deprecated**
* [removeHostFile](./ModuleServerAPI#removehostfile-deprecated) **Deprecated**
* [hasHostFile](./ModuleServerAPI#hashostfile-deprecated) **Deprecated**
Conditions
* [finishServerCondition](./ModuleServerAPI#finishservercondition)
* [forceClientCondition](./ModuleServerAPI#forceclientcondition)
Environment
* [getModuleID](./ModuleServerAPI.md#getmoduleid)
* [getScenes](./ModuleServerAPI#getscenes)
* [getResolution](./ModuleServerAPI#getresolution) **Deprecated** -->
## Sub Classes ## Sub Classes

2
ModuleServerAPIGameLib.md

@@ -1,6 +1,6 @@
# ModuleClientApi - GameLib # ModuleClientApi - GameLib
Class representing the GameLib inside the ModuleServerAPI. The GameLib is Getiyo's game development framework that enables synchronized multiplayer experiences across all connected devices. [Click here to view the introductions.](./ModuleServerAPIGameLibIntroduction)
## Rooms ## Rooms

116
ModuleServerAPIGameLibIntroduction.md Normal file

@@ -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.

81
ModuleServerAPIIntroduction.md Normal file

@@ -0,0 +1,81 @@
# ModuleServerAPI - Introduction
The ModuleServerAPI is the powerful server-side foundation that brings your Getiyo modules to life. Every module you create relies on this API to handle the complex orchestration between users, data, and the Getiyo platform itself.
## What is the ModuleServerAPI?
Think of the ModuleServerAPI as your module's command center. While users interact with your module's visual interface through the [`ModuleClientAPI`](./ModuleClientAPI), the real magic happens server-side. This is where you process data, manage business logic, store sensitive information, and coordinate real-time experiences for multiple users simultaneously.
The ModuleServerAPI runs in a secure server environment, giving you access to powerful capabilities that would be impossible or unsafe to implement client-side. Whether you're building a simple display widget or a complex interactive experience, this API provides the tools to create responsive, scalable, and secure modules.
## Core Capabilities
**Real-time Communication**: Instantly send messages to all connected clients or target specific users with [`api.broadcast()`](./ModuleServerAPI#broadcast) and [`api.getClient()`](./ModuleServerAPI#getclient). Your modules can respond to user interactions in real-time, creating engaging collaborative experiences.
**Secure Property Management**: Handle module properties defined in [`module.json`](./ModuleJSON) that remain exclusively server-side — perfect for API keys, authentication tokens, sensitive configuration data, and persistent module state. Access and update these properties using [`api.getModuleProperty()`](./ModuleServerAPI#getmoduleproperty) and monitor changes with [`api.onModulePropertyUpdate()`](./ModuleServerAPI#onmodulepropertyupdate). While reference properties exist for scene-specific client-side data, your server-side logic should primarily rely on module properties for secure, persistent data management.
**Rich File Operations**: Read, write, and host files with full scope control through [`api.readJSON()`](./ModuleServerAPI#readjson), [`api.writeJSON()`](./ModuleServerAPI#writejson), and [`api.addHost()`](./ModuleServerAPI#addhost). Store module-specific data, share files across your channel, or serve static content directly to users.
**Show Control Integration**: Seamlessly integrate with Getiyo's cue list system using triggers and conditions. Register [`api.onTrigger()`](./ModuleServerAPI#ontrigger) handlers to respond to automated cues, and use [`api.finishServerCondition()`](./ModuleServerAPI#finishservercondition) to control show flow based on your module's state.
**External Service Integration**: Connect to databases, APIs, and external services using battle-tested libraries like WebSocket, Redis, and Axios through [`api.Libs`](./ModuleServerAPILibs). Build modules that bridge Getiyo with your existing infrastructure.
## How It Works
When your module loads, the ModuleServerAPI automatically connects to any [`ModuleClientAPI`](./ModuleClientAPI) instances viewing your module. This creates a persistent, bidirectional communication channel that stays synchronized across scene changes, user interactions, and show control events.
Your server-side code registers event listeners to respond to messages from clients, module property updates from the admin interface, scene transitions, and triggers from cue lists. Meanwhile, you can push updates, broadcast changes, and maintain state that persists across user sessions.
Here's a simple example that demonstrates the API's event-driven nature:
```javascript
// Respond to messages from any connected client
api.on('userAction', (client, actionData) => {
console.log(`User ${client.getClientID()} performed action:`, actionData);
// Process the action server-side
const result = processUserAction(actionData);
// Send response back to the specific user
client.send('actionResult', result);
// Broadcast the update to all other users
const otherClients = Object.values(api.getClients()).filter(
(c) => c.getClientID() !== client.getClientID()
);
otherClients.forEach((c) => {
c.send('userUpdate', {
user: client.getClientID(),
action: actionData,
});
});
});
// Handle module property changes from the admin interface
api.onModulePropertyUpdate('apiKey', (newKey) => {
console.log('API key updated, reconnecting to external service...');
// Update external service connection with new credentials
reconnectExternalService(newKey);
// Notify all clients that service is reconnecting
api.broadcast('serviceStatus', 'reconnecting');
});
// Respond to cue list triggers
api.onTrigger('startSequence', (finish, status, ...args) => {
status('Starting sequence...');
// Use module properties for configuration
const sequenceConfig = api.getModuleProperty('sequenceSettings').getValue();
// Perform the triggered action
performSequence(args, sequenceConfig).then(() => {
// Signal completion to continue the cue list
finish();
});
});
```
This introduction establishes the ModuleServerAPI's role and capabilities in a more narrative, welcoming tone while still providing concrete examples and clear

52
_Sidebar.md

@@ -1,8 +1,11 @@
### [Getting Started](./Home)
- [Introduction](./Home) - [Introduction](./Home)
- [Prerequisites](./Prerequisites) - [Prerequisites](./Prerequisites)
- [Setting up server](./ServerSetup) - [Setting up server](./ServerSetup)
- [Config](./Config) - [Config](./Config)
- Module Development
### [Module Development](./ModuleStructure)
- [Module Structure](./ModuleStructure) - [Module Structure](./ModuleStructure)
- [Module.json](./ModuleJSON) - [Module.json](./ModuleJSON)
@@ -11,19 +14,26 @@
- [Condition](./ModuleCondition) - [Condition](./ModuleCondition)
- [Complete Example](./module.json) - [Complete Example](./module.json)
- [Development environment/Building](./ModuleEnvironment) - [Development environment/Building](./ModuleEnvironment)
- [Module Debugging](./ModuleDebugging)
- [GetiyoModuleTool](./GetiyoModuleTool) - [GetiyoModuleTool](./GetiyoModuleTool)
- [ModuleClientAPI](./ModuleClientAPI) - [ModuleStore](./ModuleStore)
- [Important Principals](./ModuleClientAPIPrincipals) - [Bug/Feature Reporting](./Reporting)
- [User](./ModuleClientAPIUser) - [Contact Details](./ContactDetails)
- [Neighbor](./ModuleClientAPINeighbor)
- [Neighbor Results](./ModuleClientAPINeighborResults)
- [GameLib](./ModuleClientAPIGameLib)
- [Controller](./ModuleClientAPIGameLibController)
- [ModuleServerAPI](./ModuleServerAPI)
- [Important Principals](./ModuleServerAPIPrincipals) ### [ModuleServerAPI](./ModuleServerAPIIntroduction)
- [Introduction](./ModuleServerAPIIntroduction)
- [ModuleServerAPI](./ModuleServerAPI)
- [Client](./ModuleServerAPIClient) - [Client](./ModuleServerAPIClient)
- [Property](./ModuleServerAPIProperty) - [Property](./ModuleServerAPIProperty)
- [Important Principals](./ModuleServerAPIPrincipals)
- [Libs](./ModuleServerAPILibs)
- [LibWebSocket](./ModuleServerAPILibsWebSocketLib)
- [Axios](https://axios-http.com/docs/instance)
### [ModuleServerAPI GameLib](./ModuleServerAPIGameLibIntroduction)
- [Introduction](./ModuleServerAPIGameLibIntroduction)
- [GameLib](./ModuleServerAPIGameLib) - [GameLib](./ModuleServerAPIGameLib)
- [Room](./ModuleServerAPIGameLibRoom) - [Room](./ModuleServerAPIGameLibRoom)
- [Game](./ModuleServerAPIGameLibGame) - [Game](./ModuleServerAPIGameLibGame)
@@ -32,11 +42,20 @@
- [Details](./ModuleServerAPIGameLibScoreboardDetails) - [Details](./ModuleServerAPIGameLibScoreboardDetails)
- [State](./ModuleServerAPIGameLibScoreboardState) - [State](./ModuleServerAPIGameLibScoreboardState)
- [GameLib CollisionSpace](./ModuleServerAPIGameLibCollisionSpace) - [GameLib CollisionSpace](./ModuleServerAPIGameLibCollisionSpace)
- [Libs](./ModuleServerAPILibs)
- [LibWebSocket](./ModuleServerAPILibsWebSocketLib)
- [Axios](https://axios-http.com/docs/instance)
- ModuleApi Shared ### [ModuleClientAPI](./ModuleClientAPIIntroduction)
- [Introduction](./ModuleClientAPIIntroduction)
- [ModuleClientAPI](./ModuleClientAPI)
- [User](./ModuleClientAPIUser)
- [Neighbor](./ModuleClientAPINeighbor)
- [Neighbor Results](./ModuleClientAPINeighborResults)
- [GameLib](./ModuleClientAPIGameLib)
- [Controller](./ModuleClientAPIGameLibController)
- [Important Principals](./ModuleClientAPIPrincipals)
### ModuleApi Shared
- [RuntimeStorage](./ModuleApiGameLibRuntimeStorage) - [RuntimeStorage](./ModuleApiGameLibRuntimeStorage)
- Gamelib - Gamelib
- [GameLib GameDetails](./ModuleApiGameLibGameDetails) - [GameLib GameDetails](./ModuleApiGameLibGameDetails)
@@ -44,8 +63,3 @@
- [GameLib TimeSpan](./ModuleApiGameLibTimeSpan) - [GameLib TimeSpan](./ModuleApiGameLibTimeSpan)
- [GameLib FrameCycle](./ModuleApiGameLibFrameCycle) - [GameLib FrameCycle](./ModuleApiGameLibFrameCycle)
- [GameLib Ratio](./ModuleAPIGameLibRatio) - [GameLib Ratio](./ModuleAPIGameLibRatio)
- [Module Debugging](./ModuleDebugging)
- [ModuleStore](./ModuleStore)
- [Bug/Feature Reporting](./Reporting)
- [Contact Details](./ContactDetails)