ROBLOX Integration

Overview

The SkyTeam ROBLOX module allows alliance member airlines to integrate the SkyTeam system directly into their ROBLOX games. The module handles API communication, player authentication, and real-time UI updates.

Module Architecture

The module is built in TypeScript using roblox-ts:

apps/models/src/module/index.ts

export interface Settings {
  /**
   * @interface Settings
   * @description This interface is used to define the settings for the SkyTeam module.
   *
   * @property {string} TOKEN - The token for the module.
   * @property {string[]} Flags - The flags for the module.
   */

  TOKEN: string;
  Flags: string[];
}

export default class {
  private Settings: Settings;
  public API: string = "http://localhost:4000";
  public RemoteEvent: RemoteEvent = new Instance("RemoteEvent");
  public Slocked: boolean = false;
  public InitalizationError: string | undefined;

  constructor(Settings: Settings) {
    script.Parent = ReplicatedStorage;
    this.Settings = Settings;
  }
}

Server-Side Module

The module runs on the server and manages client-server communication via RemoteEvents.

Initialization

The module initializes when the game starts:

apps/models/src/module/index.ts

public Initialize(): void {
  this.RemoteEvent.Name = ".SKYTEAM_CLIENT_RUNTIME";
  this.RemoteEvent.Parent = ReplicatedStorage;

  for (const Player of Players.GetPlayers()) {
    const ClientScript = script.WaitForChild("client").Clone();
    ClientScript.Parent = Player.WaitForChild("PlayerGui");
  }

  Players.PlayerAdded.Connect((Player) => {
    const ClientScript = script.WaitForChild("client").Clone();
    ClientScript.Parent = Player.WaitForChild("PlayerGui");

    if (this.InitalizationError) {
      this.PublicError("SERVER_INIT_ERROR", {
        Body: this.InitalizationError,
      });
    }
  });

  this.TestServices().catch((err) => {
    warn(err);
    this.InitalizationError = err;
    this.PublicError("SERVER_INIT_ERROR", {
      Body: `SkyTeam module failed to initialize. Please contact a developer. Error: ${err}`,
    });
  });
}

Create RemoteEvent

Sets up communication channel between server and clients

Deploy Client Scripts

Clones client script to each player’s PlayerGui

Handle New Players

Automatically sets up module for players who join mid-game

Test Services

Validates that HttpService is enabled and working

Service Validation

The module tests if required services are available:

apps/models/src/module/index.ts

private async TestServices(): Promise<any> {
  return new Promise(async (resolve, reject) => {
    const [success, result] = pcall(() => {
      HttpService.GetAsync("https://example.com/");
    });

    if (!success) {
      reject(result);
      return;
    }

    resolve(result);
  });
}

HttpService Required

The module requires HttpService to be enabled in game settings for API communication.

Error Handling

The module broadcasts errors to all clients:

apps/models/src/module/index.ts

private async PublicError<T extends EventTypeKeys>(
  WhichEvent: T,
  args: EventTypes[T],
) {
  this.RemoteEvent.FireAllClients(WhichEvent, args);
}

Clients receive error notifications and can display them to players:

apps/models/src/module/client/ErrorMessage.tsx

import React from "@rbxts/react";

export default function ErrorMessage() {
  return (
    <textlabel
      Text="An error occurred"
      TextColor3={Color3.fromRGB(255, 0, 0)}
      Size={new UDim2(1, 0, 0, 50)}
    />
  );
}

Client Integration

The client-side code connects to the RemoteEvent:

apps/models/src/module/client/index.client.tsx

import { ReplicatedStorage } from "@rbxts/services";

const remoteEvent = ReplicatedStorage.WaitForChild(
  ".SKYTEAM_CLIENT_RUNTIME",
) as RemoteEvent;

remoteEvent.OnClientEvent.Connect((eventType, data) => {
  // Handle events from server
  if (eventType === "SERVER_INIT_ERROR") {
    // Display error to player
  }
});

Communication Types

The module uses typed events for communication:

apps/models/src/module/shared/CommunicationTypes.d.ts

export type EventTypes = {
  SERVER_INIT_ERROR: {
    Body: string;
  };
  // Add more event types as needed
};

export type EventTypeKeys = keyof EventTypes;

Type Safety

TypeScript ensures type-safe communication between server and clients.

Example Implementation

Here’s how to use the module in your game:

apps/models/src/loader/main.server.ts

import SkyTeamModule from "module";

const SkyTeam = new SkyTeamModule({
  TOKEN: "YAY",
  Flags: ["flag1", "flag2"],
}).Initialize();

Configuration

TOKEN

Your airline’s API authentication token

Flags

Optional feature flags for the module

API Communication

The module communicates with the SkyTeam API:

public API: string = "http://localhost:4000";

Production API

In production, this should point to https://api.skyteam.dev

Module Structure

apps/models/
├── src/
│   ├── loader/
│   │   └── main.server.ts       # Example implementation
│   └── module/
│       ├── index.ts              # Main module class
│       ├── client/
│       │   ├── index.client.tsx  # Client-side handler
│       │   └── ErrorMessage.tsx  # Error UI component
│       └── shared/
│           └── CommunicationTypes.d.ts  # Type definitions

Features

Auto-Setup

Automatically initializes for all players, including mid-game joins

Error Reporting

Clear error messages when initialization fails

Type Safety

TypeScript ensures correct usage at compile-time

Client-Server Sync

RemoteEvents keep clients in sync with server state

Requirements

Enable HttpService

Go to Game Settings → Security → Enable HTTP Requests

Get API Token

Obtain your airline’s authentication token from the admin panel

Install Module

Add the SkyTeam module to your game’s ServerScriptService

Configure Settings

Set your TOKEN and any desired Flags

Initialize

Call .Initialize() to start the module

Best Practices

Secure Tokens

Keep your API token secure and never expose it in client-side code

Handle Errors

Always check for initialization errors and display them to players

Test Locally

Use the local API endpoint during development

Monitor Players

Track player joins and ensure they receive the client script

Troubleshooting

HttpService Not Enabled

If you see “HttpService is not allowed” errors:

Go to Game Settings in ROBLOX Studio
Navigate to Security
Enable “Allow HTTP Requests”
Restart your game

Client Script Not Loading

If players don’t see the UI:

Check that the client script exists in the module
Verify it’s being cloned to PlayerGui
Look for errors in the Output window

API Connection Failed

If the module can’t connect to the API:

Verify your API token is correct
Check that the API endpoint is accessible
Ensure HttpService is enabled

Next Steps

API Authentication

Learn how to authenticate API requests from your ROBLOX game

Get Started

Setup & Deployment

Core Features

Applications

Overview

Module Architecture

Server-Side Module

Initialization

Service Validation

HttpService Required

Error Handling

Client Integration

Communication Types

Type Safety

Example Implementation

Configuration

TOKEN

Flags

API Communication

Production API

Module Structure

Features

Auto-Setup

Error Reporting

Type Safety

Client-Server Sync

Requirements

Best Practices

Secure Tokens

Handle Errors

Test Locally

Monitor Players

Troubleshooting

HttpService Not Enabled

Client Script Not Loading

API Connection Failed

Next Steps

API Authentication

Build docs developers (and LLMs) love

Get Started

Setup & Deployment

Core Features

Applications

​Overview

​Module Architecture

Server-Side Module

​Initialization

​Service Validation

HttpService Required

​Error Handling

​Client Integration

​Communication Types

Type Safety

​Example Implementation

​Configuration

TOKEN

Flags

​API Communication

Production API

​Module Structure

​Features

Auto-Setup

Error Reporting

Type Safety

Client-Server Sync

​Requirements

​Best Practices

Secure Tokens

Handle Errors

Test Locally

Monitor Players

​Troubleshooting

​HttpService Not Enabled

​Client Script Not Loading

​API Connection Failed

​Next Steps

API Authentication

Build docs developers (and LLMs) love

Overview

Module Architecture

Initialization

Service Validation

Error Handling

Client Integration

Communication Types

Example Implementation

Configuration

API Communication

Module Structure

Features

Requirements

Best Practices

Troubleshooting

HttpService Not Enabled

Client Script Not Loading

API Connection Failed

Next Steps