API Reference

​

Table of Contents

• Core Classes
  • CORP
  • GameObject
  • Component
  • Behavior
• Networking Classes
  • NetworkObject
  • NetworkBehavior
  • NetworkedVariable
  • NetworkedList
  • NetworkedMap
  • NetworkedSet
  • RPC
• Scene Management
  • SceneManager
  • Scene
• Utilities
  • Signal
  • Collector

​

Core Classes

​

CORP

​

Methods

CORP.start(configuration: Configurations.GameConfiguration): void

CORP.start({
    startingScene: MyScene
});

• configuration.startingScene - Scene description or path to scene

CORP.startFromWorkspace(): void

CORP.startFromWorkspace();

​

GameObject

​

Constructor

new GameObject(name: string)

• name - Name of the GameObject

​

Properties

​

Methods

addComponent<T>(clazz: Constructable<T>, config?: ComponentConfig<T>): T

const health = player.addComponent(HealthSystem, {
    maxHealth: 100
});

• clazz - Component class to add
• config - Optional configuration object

getComponent<T>(clazz: Constructable<T> | string): T | undefined

const health = player.getComponent(HealthSystem);

• clazz - Component class or path string

hasComponent<T>(clazz: Constructable<T>): boolean

if (player.hasComponent(HealthSystem)) {
    // Has health component
}

• clazz - Component class to check

removeComponent<T>(clazz: Constructable<T>): void

player.removeComponent(HealthSystem);

• clazz - Component class to remove

destroy(): void

enemy.destroy();

setParent(parent: GameObject | Scene | undefined): void

child.setParent(parent);

• parent - New parent GameObject, Scene, or undefined

getParent(): GameObject | Scene | undefined

const parent = child.getParent();

getChildren(): GameObject[]

const children = parent.getChildren();

getDescendants(): GameObject[]

const all = root.getDescendants();

getTransform(): CFrame

const transform = player.getTransform();

setTransform(transform: CFrame): void

player.setTransform(new CFrame(0, 10, 0));

• transform - New CFrame transform

getPosition(): Vector3

const pos = player.getPosition();

getName(): string

const name = player.getName();

getInstance(): Actor

const instance = player.getInstance();

​

Static Methods

GameObject.fromInstance(instance: Actor, name: string): GameObject

const actor = new Instance("Actor");
const gameObject = GameObject.fromInstance(actor, "MyObject");

• instance - Roblox Actor instance
• name - Name for the GameObject

GameObject.importGameObject(description: GameObjectDescription, parent: GameObject | Scene, isClient: boolean): GameObject

​

Component

​

Constructor

public constructor(gameObject: GameObject, initOnCreated?: boolean)

• gameObject - GameObject this component is attached to
• initOnCreated - Whether to initialize immediately (default: true)

​

Properties

​

Methods

abstract onStart(): void

public onStart(): void {
    // Initialization logic
}

abstract willRemove(): void

public willRemove(): void {
    // Cleanup logic
}

abstract getSourceScript(): LuaSourceContainer

protected getSourceScript(): ModuleScript {
    return script as ModuleScript;
}

willStart(): void

public willStart(): void {
    // Pre-initialization logic
}

onPropertiesApplied(): void

public onPropertiesApplied(): void {
    // React to configured properties
}

initialize(): void

remove(): void

component.remove();

getGameObject(): GameObject

const gameObject = this.getGameObject();

Component Shortcuts

this.getTransform()           // GameObject.getTransform()
this.setTransform(cframe)     // GameObject.setTransform()
this.getPosition()            // GameObject.getPosition()
this.getName()                // GameObject.getName()
this.getInstance()            // GameObject.getInstance()
this.getComponent(clazz)      // GameObject.getComponent()
this.destroy()                // GameObject.destroy()

​

Behavior

​

All Component Methods

​

Methods

serializeState(): Partial<Behavior>

const state = this.serializeState();

​

Properties

​

Networking Classes

​

NetworkObject

​

Constructor

public constructor(gameObject: GameObject)

​

Properties

​

Methods

spawn(): void

if (RunService.IsServer()) {
    netObj.spawn();
}

changeOwnership(owner: Player | undefined): void (Server Only)

netObj.changeOwnership(player); // Give to player
netObj.changeOwnership(undefined); // Give to server

• owner - New owner Player, or undefined for server

getOwner(): Player | undefined

const owner = netObj.getOwner();

getId(): string

const id = netObj.getId();

​

NetworkBehavior

​

Constructor

public constructor(gameObject: GameObject, initOnCreated?: boolean)

​

All Behavior Methods

​

Methods

getNetworkObject(): NetworkObject

const netObj = this.getNetworkObject();

getId(): string

const id = this.getId();

​

NetworkedVariable

​

Constructor

new NetworkedVariable<T>(initialValue?: T, config?: NetworkVariableConfig)

• initialValue - Initial value
• config - Configuration options

interface NetworkVariableConfig {
    replicationBehavior?: NetworkVariableReplicationBehavior; // BATCHED or INSTANTANEOUS
}

​

Properties

​

Methods

getValue(): T

const value = myVar.getValue();

setValue(value: T): void (Server Only)

if (RunService.IsServer()) {
    myVar.setValue(100);
}

• value - New value

​

NetworkedList

​

Constructor

new NetworkedList<T>(config?: NetworkVariableConfig)

​

Properties

​

Methods

push(item: T): void (Server Only)

list.push("item");

remove(index: number): T | undefined (Server Only)

const removed = list.remove(0);

get(index: number): T | undefined

const item = list.get(0);

set(index: number, value: T): void (Server Only)

list.set(0, "newValue");

size(): number

const size = list.size();

​

NetworkedMap

​

Constructor

new NetworkedMap<K, V>(config?: NetworkVariableConfig)

​

Properties

​

Methods

set(key: K, value: V): void (Server Only)

map.set("key", "value");

get(key: K): V | undefined

const value = map.get("key");

delete(key: K): boolean (Server Only)

map.delete("key");

has(key: K): boolean

if (map.has("key")) {
    // Key exists
}

​

NetworkedSet

​

Constructor

new NetworkedSet<T>(config?: NetworkVariableConfig)

​

Properties

​

Methods

add(item: T): void (Server Only)

set.add("item");

delete(item: T): boolean (Server Only)

set.delete("item");

has(item: T): boolean

if (set.has("item")) {
    // Item exists
}

​

RPC

​

Decorator

@RPC.Method(config: RPC.Config)

@RPC.Method({
    endpoints: [RPC.Endpoint.CLIENT_TO_SERVER],
    accessPolicy: RPC.AccessPolicy.OWNER
})
public myRPC(): void {}

​

Configuration

interface RPC.Config {
    endpoints: RPC.Endpoint[];
    accessPolicy?: RPC.AccessPolicy;
    returnMode?: RPC.ReturnMode;
    reliability?: RPC.Reliability;
}

​

Enums

RPC.Endpoint

• CLIENT_TO_SERVER - Client calls server
• SERVER_TO_CLIENT - Server calls client
• CLIENT_TO_CLIENT - Client calls client (not yet implemented)
• CLIENT_LOCALLY - Client calls locally
• SERVER_LOCALLY - Server calls locally

RPC.AccessPolicy

• NONE / ANYONE - Anyone can call
• OWNER - Only owner can call
• NOT_OWNER - Only non-owners can call

RPC.ReturnMode

• DOES_NOT_RETURN / VOID - No return value
• RETURNS - Returns a value

RPC.Reliability

• RELIABLE - Guaranteed delivery
• UNRELIABLE - Fast but may be dropped

​

Scene Management

​

SceneManager

​

Properties

​

Methods

static loadScene(scene: SceneSerialization.SceneDescription): Scene

SceneManager.loadScene(MyScene);

• scene - Scene description

static unloadScene(): void

SceneManager.unloadScene();

static changeScene(scene: SceneSerialization.SceneDescription): void

SceneManager.changeScene(NewScene);

• scene - Scene description

static importScene(scene: SceneSerialization.SceneDescription): Scene

const scene = SceneManager.importScene(MyScene);

​

Scene

​

Properties

​

Methods

startFromWorkspace(): void

scene.startFromWorkspace();

​

Utilities

​

Signal

​

Constructor

new Signal<T extends unknown[]>(name?: string)

• name - Optional name for debugging

​

Methods

connect(callback: (...args: T) => void): Connection<T>

const conn = signal.connect((value) => {
    print(value);
});

• callback - Function to call when signal fires

fire(...args: T): void

signal.fire(42, "hello");

• ...args - Arguments to pass to callbacks

destroy(): void

signal.destroy();

​

Collector

​

Methods

add(item: RBXScriptConnection | Instance | (() => void) | { destroy(): void }): void

collector.add(connection);
collector.add(instance);
collector.add(() => print("cleanup"));

• item - Connection, Instance, function, or object with destroy method

teardown(): void

collector.teardown();

​

Type Definitions

​

SceneSerialization.SceneDescription

interface SceneDescription {
    children: GameObjectDescription[];
}

​

SceneSerialization.GameObjectDescription

interface GameObjectDescription {
    name: string;
    transform?: SerializedTransform;
    components: ComponentDescription[];
    children: GameObjectDescription[];
}

​

SceneSerialization.ComponentDescription

interface ComponentDescription {
    path: ExportPathString; // ["folder", "file", "export"]
    data: Record<string, any>;
}

​

Configurations.GameConfiguration

interface GameConfiguration {
    startingScene: SceneSerialization.SceneDescription | string;
}

​

Next Steps

• Getting Started: Learn the basics
• Examples: See practical implementations
• Core Concepts: Understand the architecture