Wavedash

https://docs.wavedash.com
Admin
Wavedash is a browser-based game platform providing developers with tools for publishing,...
Tokens:71,052
Snippets:847
Trust Score:7.3
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Heaps.io Library

Source: https://docs.wavedash.com/engines/heaps

Install the Heaps.io library using haxelib. This is a one-time setup step.

```bash
# brew install haxe / apt install haxe / etc.
haxelib install heaps

```

--------------------------------

### Start Local Development Server

Source: https://docs.wavedash.com/cli/commands

Starts a local HTTPS server to serve files from upload_dir and injects the Wavedash SDK into the sandbox. It automatically opens the Wavedash sandbox in the browser. A self-signed certificate is installed on the first run.

```bash
wavedash dev

```

--------------------------------

### Install Swift WebAssembly SDK

Source: https://docs.wavedash.com/engines/swift

Install the Swift WebAssembly SDK. This command downloads and installs the SDK artifact, ensuring compatibility for WebAssembly compilation.

```bash
swift sdk install https://download.swift.org/swift-6.3-release/wasm-sdk/swift-6.3-RELEASE/swift-6.3-RELEASE_wasm.artifactbundle.tar.gz \
  --checksum 9fa4016ee632c7e9e906608ec3b55cf13dfc4dff44e47574c5af58064dc33fd9
```

--------------------------------

### Minimal Wavedash Integration Example

Source: https://docs.wavedash.com/engines/custom

This example demonstrates the essential calls to `WavedashJS.updateLoadProgressZeroToOne` and `WavedashJS.init` within an asynchronous function. Ensure `startYourGame` is defined elsewhere.

```javascript
(async function () {
  // Set up your game however you need to
  const canvas = document.createElement("canvas");
  canvas.style.width = "100%";
  canvas.style.height = "100%";
  document.body.appendChild(canvas);

  WavedashJS.updateLoadProgressZeroToOne(0.5);
  await startYourGame(canvas);
  WavedashJS.init({ debug: false });
})();

```

--------------------------------

### Install Wavedash Unity SDK

Source: https://docs.wavedash.com/engines/unity

Install the Wavedash Unity package by providing the Git URL in the Package Manager.

```git
https://github.com/wvdsh/sdk-unity.git
```

--------------------------------

### Build and Run Commands for Wavedash Game

Source: https://docs.wavedash.com/engines/typescript

Commands to install dependencies, build the TypeScript game using npm, and start the development server with Wavedash.

```bash
npm install
npm run build
wavedash dev


```

--------------------------------

### Full Cloud Save System Example - Godot

Source: https://docs.wavedash.com/sdk/cloud-saves

A comprehensive example demonstrating how to implement a full cloud save system, including versioning, timestamping, and file operations.

```gdscript
const SAVE_VERSION = 2
var save_root: String

func _ready():
    save_root = OS.get_user_data_dir() + "/saves/"

func cloud_save(slot: int, game_state: Dictionary) -> void:
    var payload = {"version": SAVE_VERSION, "timestamp": Time.get_unix_time_from_system(), "state": game_state}
    var path = save_root + "slot" + str(slot) + ".json"
    DirAccess.make_dir_recursive_absolute(save_root)
    var file = FileAccess.open(path, FileAccess.WRITE)
    file.store_string(JSON.stringify(payload))
    file.close()
    WavedashSDK.upload_remote_file(path)

func cloud_load(slot: int) -> void:
    var path = save_root + "slot" + str(slot) + ".json"
    WavedashSDK.download_remote_file(path)
```

--------------------------------

### Install Swift Toolchain

Source: https://docs.wavedash.com/engines/swift

Install a standalone Swift 6.3+ toolchain using swiftly. This is required as Apple's bundled toolchain does not include a wasm-capable clang.

```bash
swiftly install 6.3.0
```

--------------------------------

### Install .NET WASM Tools

Source: https://docs.wavedash.com/engines/csharp

Installs the necessary .NET workload for WebAssembly development.

```bash
dotnet workload install wasm-tools-net9

```

--------------------------------

### Install Wavedash CLI on Windows CMD

Source: https://docs.wavedash.com/cli/installation

Run this command in the Windows Command Prompt (CMD) to install the Wavedash CLI. This method uses PowerShell internally.

```cmd
powershell -ExecutionPolicy Bypass -c "irm https://wavedash.com/cli/install.ps1 | iex"

```

--------------------------------

### Excalibur.js Game Initialization with WavedashJS SDK

Source: https://docs.wavedash.com/engines/excalibur

This JavaScript code initializes an Excalibur.js game, reporting loading progress via the WavedashJS SDK and starting the game after assets are loaded. Import necessary Excalibur modules and await the WavedashJS object before game setup.

```javascript
import { Engine, Loader, DisplayMode } from "https://esm.sh/excalibur@0.30.3";

const WavedashJS = await window.WavedashJS;
WavedashJS.updateLoadProgressZeroToOne(0.3);

const game = new Engine({
  canvasElementId: "game",
  displayMode: DisplayMode.FitScreen,
  width: 1600,
  height: 900,
});

// ...register scenes and actors...

await game.start(new Loader([/* assets */]));

WavedashJS.init({ debug: false });

```

--------------------------------

### Initialize Wavedash SDK

Source: https://docs.wavedash.com/sdk/functions

Use `setupWavedashSDK` to get the SDK instance. Call `init` once with configuration to initialize the SDK. `readyForEvents` flushes the deferred event queue if `deferEvents` was true.

```javascript
function setupWavedashSDK(): Promise<WavedashSDK>;

function init(config?: WavedashConfig): boolean;

function readyForEvents(): void;
```

--------------------------------

### Verify Wavedash CLI Installation

Source: https://docs.wavedash.com/cli/installation

After installation, run this command to confirm the Wavedash CLI is installed and accessible on your system's PATH.

```shell
wavedash --version

```

--------------------------------

### Get Game Launch Parameters

Source: https://docs.wavedash.com/sdk/functions

Use `getLaunchParams` to retrieve URL parameters prefixed with `wvdsh_` that were passed when the game was launched.

```javascript
function getLaunchParams(): GameLaunchParams;
```

--------------------------------

### Initialize Wavedash SDK and Get Launch Parameters

Source: https://docs.wavedash.com/sdk/setup

Initialize the SDK with default or custom options. Retrieve launch parameters, such as lobby IDs from invite links, after initialization.

```javascript
WavedashSDK.init({})
```

```javascript
var params = WavedashSDK.get_launch_params()
```

```javascript
if params.has("lobby"):
    WavedashSDK.join_lobby(params["lobby"])
```

--------------------------------

### Install wasm-tools Workload

Source: https://docs.wavedash.com/engines/monogame

Install the wasm-tools workload for .NET to enable AOT compilation for Blazor WebAssembly projects.

```bash
dotnet workload install wasm-tools

```

--------------------------------

### Install WASM Target

Source: https://docs.wavedash.com/engines/rust

Install the `wasm32-unknown-unknown` target for Rust compilation to WebAssembly.

```bash
rustup target add wasm32-unknown-unknown

```

--------------------------------

### Listening for Events

Source: https://docs.wavedash.com/sdk/events

Example of how to connect to various Wavedash SDK events in JavaScript.

```APIDOC
## Listening for Events

### Description
This section shows how to connect to different Wavedash SDK events using JavaScript.

### Code Example (JavaScript)
```javascript
WavedashSDK.lobby_joined.connect(_on_lobby_joined)
WavedashSDK.lobby_message.connect(_on_lobby_message)
WavedashSDK.p2p_connection_established.connect(_on_peer_connected)
WavedashSDK.backend_connected.connect(_on_backend_connected)
```

### Event Data
In JavaScript, event data is accessed via `e.detail`. In Godot and Unity, it's passed directly as a Dictionary.
```

--------------------------------

### Install Wavedash CLI on macOS, Linux, WSL

Source: https://docs.wavedash.com/cli/installation

Use this command to install the Wavedash CLI on macOS, Linux, and Windows Subsystem for Linux (WSL).

```shell
curl -fsSL https://wavedash.com/cli/install.sh | sh

```

--------------------------------

### Install Wavedash CLI on Windows PowerShell

Source: https://docs.wavedash.com/cli/installation

Execute this command in PowerShell to install the Wavedash CLI on Windows. Ensure your execution policy allows script execution.

```powershell
Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass; irm https://wavedash.com/cli/install.ps1 | iex

```

--------------------------------

### Kill Tracking Example - Godot

Source: https://docs.wavedash.com/sdk/achievements

An example demonstrating how to track kills, update the 'total_kills' stat, and unlock the 'first_blood' achievement when the first kill occurs. Stats are updated immediately.

```gdscript
var session_kills: int = 0

func on_enemy_killed() -> void:
    var kills = WavedashSDK.get_stat_int("total_kills") + 1
    WavedashSDK.set_stat_int("total_kills", kills, true)
    session_kills += 1
    if kills == 1:
        WavedashSDK.set_achievement("first_blood")

```

--------------------------------

### Integrate WavedashJS SDK in Heaps.io

Source: https://docs.wavedash.com/engines/heaps

Example of calling WavedashJS functions from Haxe using `js.Syntax.code`. Use this to update load progress or initialize the SDK.

```haxe
override function init() {
    js.Syntax.code("WavedashJS.updateLoadProgressZeroToOne(1.0)");
    js.Syntax.code("WavedashJS.init({ debug: false })");
    // ...rest of your game setup
}

```

--------------------------------

### JavaScript Host Implementation

Source: https://docs.wavedash.com/engines/rust

Provide JavaScript implementations for Wavedash SDK functions. This example shows how to import the SDK, define imports for `wavedash_init` and `wavedash_update_progress`, and instantiate the WebAssembly module.

```javascript
const sdk = await window.WavedashJS;

const imports = {
  env: {
    wavedash_init() { sdk.init({ debug: true }); },
    wavedash_update_progress(p) { sdk.updateLoadProgressZeroToOne(p); },
    // ...your other imports (draw primitives, score updates, etc.)...
  }
};

const response = await fetch("./game.wasm");
const bytes = await response.arrayBuffer();
const result = await WebAssembly.instantiate(bytes, imports);

```

--------------------------------

### Example: Handle WavedashResponse

Source: https://docs.wavedash.com/sdk/types

Demonstrates how to handle the WavedashResponse wrapper for async operations, checking for success and accessing data or error messages.

```typescript
const user = WavedashJS.getUser(); // sync getter

const response = await WavedashJS.getLeaderboard("high-scores");

if (response.success) {
  const leaderboard: Leaderboard = response.data;
  // Use leaderboard...
} else {
  console.error(response.message);
}
```

--------------------------------

### Three.js Game Entry Point with Wavedash Integration

Source: https://docs.wavedash.com/engines/threejs

This script sets up a canvas, appends it to the body, updates Wavedash load progress, starts the game, and then initializes Wavedash. Call `WavedashJS.updateLoadProgressZeroToOne` during asset loading and `WavedashJS.init` when the game is ready.

```javascript
(async function () {
  const canvas = document.createElement("canvas");
  canvas.style.width = "100%";
  canvas.style.height = "100%";
  document.body.appendChild(canvas);

  WavedashJS.updateLoadProgressZeroToOne(0.4);
  await startGame(canvas);
  WavedashJS.updateLoadProgressZeroToOne(1.0);
  WavedashJS.init({ debug: false });
})();

```

--------------------------------

### Initialize Wavedash SDK with P2P Configuration

Source: https://docs.wavedash.com/multiplayer/networking

Initializes the Wavedash JavaScript SDK with custom P2P configurations. This example sets the maximum number of peers, message size, and maximum incoming messages per channel.

```javascript
WavedashJS.init({
  debug: false,
  p2p: {
    maxPeers: 4,
    messageSize: 4096,
    maxIncomingMessages: 512
  }
});

```

--------------------------------

### Wavedash SDK Integration with melonJS

Source: https://docs.wavedash.com/engines/melonjs

Integrate the Wavedash SDK by awaiting `window.WavedashJS`, reporting loading progress, and initializing the game. This example demonstrates setting up a basic play scene with input bindings and drawing a rectangle.

```javascript
import { Application, Stage, input } from "https://unpkg.com/melonjs@19/build/index.js";

const WavedashJS = await window.WavedashJS;
WavedashJS.updateLoadProgressZeroToOne(0.3);

class PlayScene extends Stage {
    onResetEvent() {
        input.bindKey(input.KEY.UP, "up");
        input.bindKey(input.KEY.DOWN, "down");
    }
    update(dt) {
        // per-frame logic — return true if something needs redrawing
        return true;
    }
    draw(renderer) {
        renderer.setColor("#fff");
        renderer.fillRect(40, 40, 20, 80);
    }
}

const app = new Application(1600, 900, { parent: "screen", scale: "auto" });
app.state.set(app.state.PLAY, new PlayScene());
app.state.change(app.state.PLAY);

WavedashJS.init({ debug: false });

```

--------------------------------

### Call Wavedash SDK from Swift

Source: https://docs.wavedash.com/engines/swift

Call Wavedash SDK methods from Swift using JavaScriptKit. This example shows how to update load progress and initialize the SDK with options.

```swift
import JavaScriptKit

let window = JSObject.global

// Set up canvas, input, game loop with requestAnimationFrame...

if let sdk = window.WavedashJS.object {
  _ = sdk.updateLoadProgressZeroToOne!(1.0)

  let opts = JSObject.global.Object.function!.new()
  opts.debug = .boolean(true)
  _ = sdk.`init`!(opts)
}
```

--------------------------------

### Initialize and Update Wavedash SDK from C++

Source: https://docs.wavedash.com/engines/cpp

Define C++ functions using EM_JS to interact with the WavedashJS object in the browser. Call `wavedash_init` after setup and `wavedash_progress` during asset loading.

```cpp
#include <emscripten.h>

EM_JS(void, wavedash_init, (), {
  WavedashJS.init({ debug: true });
});

EM_JS(void, wavedash_progress, (double p), {
  WavedashJS.updateLoadProgressZeroToOne(p);
});

int main() {
    // ... setup ...

    wavedash_progress(1.0);
    wavedash_init();

    // ... start game loop ...
    emscripten_set_main_loop(tick, 0, 1);
    return 0;
}

```

--------------------------------

### Setup Typed WavedashJS in JavaScript/TypeScript

Source: https://docs.wavedash.com/sdk/setup

Use this helper to get a typed reference to WavedashJS for editor autocomplete and type-checking. Install `@wvdsh/sdk-js` as a dev dependency.

```javascript
import { setupWavedashSDK } from "@wvdsh/sdk-js";

const WavedashJS = await setupWavedashSDK();
WavedashJS.init({ debug: true });

```

--------------------------------

### Initialize Babylon.js Engine and Scene

Source: https://docs.wavedash.com/engines/babylonjs

This JavaScript code initializes the Babylon.js engine and creates a scene. It assumes `window.WavedashJS` is available and uses top-level await for asynchronous operations. Call `WavedashJS.init()` last after all setup is complete.

```javascript
const WavedashJS = await window.WavedashJS;

const canvas = document.getElementById("renderCanvas");
const engine = new BABYLON.Engine(canvas, true);
const scene = new BABYLON.Scene(engine);

// ... camera, lights, meshes ...

WavedashJS.updateLoadProgressZeroToOne(1);
WavedashJS.init({ debug: true });

engine.runRenderLoop(() => scene.render());
window.addEventListener("resize", () => engine.resize());

```

--------------------------------

### Build Ren'Py Project for Web from Command Line

Source: https://docs.wavedash.com/engines/renpy

Use this command to build your Ren'Py project for web deployment from the command line. Ensure the Ren'Py SDK path and project directory are correctly specified.

```bash
"$RENPY_SDK/renpy.sh" launcher web_build ./my-project --destination ./build
```

--------------------------------

### Initialize Wavedash SDK in Cocos Creator

Source: https://docs.wavedash.com/engines/cocos

Call WavedashJS functions from your Cocos component's start() lifecycle hook. Ensure the WavedashJS object is available before calling its methods. This example initializes the SDK and updates load progress.

```typescript
import { _decorator, Component } from 'cc';
const { ccclass } = _decorator;

declare global {
  interface Window {
    WavedashJS: any;
  }
}

@ccclass('Game')
export class Game extends Component {
  start() {
    (async () => {
      try {
        const WavedashJS = await window.WavedashJS;
        if (WavedashJS) {
          WavedashJS.updateLoadProgressZeroToOne(1.0);
          WavedashJS.init({ debug: true });
        }
      } catch (e) {
        console.warn('[wavedash] init failed:', e);
      }
    })();
  }
}
```

--------------------------------

### Generate wavedash.toml with `wavedash init`

Source: https://docs.wavedash.com/cli/configuration

Run this command in your game repo's root to create a wavedash.toml file. It detects your engine and prompts for project details.

```bash
wavedash init

```

--------------------------------

### SDK Initialization

Source: https://docs.wavedash.com/sdk/functions

Functions for setting up the SDK and managing the connection lifecycle. Safe to call from multiple modules.

```APIDOC
## SDK Initialization Functions

### `setupWavedashSDK()`

**Description**: Exported helper from `@wvdsh/sdk-js`. Resolves once the platform has injected the SDK and returns a typed `WavedashSDK` singleton.

**Signature**: `function setupWavedashSDK(): Promise<WavedashSDK>;`

### `init(config?)`

**Description**: Initializes the SDK, applies configuration options, and signals load-complete. Returns `true` on first call, `false` if already initialized. Call once before using any other SDK method.

**Signature**: `function init(config?: WavedashConfig): boolean;`

### `readyForEvents()`

**Description**: Flushes the deferred event queue. Call after your game finishes loading if you passed `deferEvents: true` to `init()`. Otherwise `init()` calls this automatically.

**Signature**: `function readyForEvents(): void;`

### `updateLoadProgressZeroToOne(progress)`

**Description**: Reports load progress (0.0 – 1.0) to the Wavedash shell so it can render a loading bar. Call repeatedly while assets download or the runtime boots.

**Signature**: `function updateLoadProgressZeroToOne(progress: number): void;`

### `loadComplete()`

**Description**: Signals that the game is ready for the player to interact with. Idempotent. `init()` calls this internally, so you only need to call it directly if you want to signal load-complete before running `init()`.

**Signature**: `function loadComplete(): void;`

### `loadScript(src)`

**Description**: Convenience wrapper that appends a `<script>` tag to the page and resolves once it loads. Useful when you need to lazy-load a third-party library.

**Signature**: `function loadScript(src: string): Promise<void>;`

### Getters

- **`initialized`**: `true` once `init()` has been called.
- **`eventsReady`**: `true` once the deferred event queue has been flushed.
- **`gameLoaded`**: `true` once `loadComplete()` has fired.

```

--------------------------------

### Initialize Wavedash SDK in GDScript

Source: https://docs.wavedash.com/engines/godot

Connect to backend events and initialize the SDK. Ensure the WavedashSDK Autoload is set up correctly in Project Settings.

```gdscript
func _ready():
    WavedashSDK.backend_connected.connect(_on_connected)
    WavedashSDK.init({"debug": true})
    WavedashSDK.ready_for_events()

func _on_connected(_payload):
    print("Playing as: ", WavedashSDK.get_username())

```

--------------------------------

### Join Lobby from Launch Parameters

Source: https://docs.wavedash.com/multiplayer/lobbies

Check launch parameters for a 'lobby' key on game startup. If present, automatically join the specified lobby.

```gdscript
var params = WavedashSDK.get_launch_params()
if params.has("lobby"):
    WavedashSDK.join_lobby(params["lobby"])

```

--------------------------------

### Build Swift Package for Web

Source: https://docs.wavedash.com/engines/swift

Build your Swift package for the web using the `PackageToJS` plugin. This command compiles your Swift code to WebAssembly and prepares it for deployment.

```bash
swift package --swift-sdk swift-6.3-RELEASE_wasm js -c release
cp -R .build/plugins/PackageToJS/outputs/Package/. dist/
cp Public/index.html dist/
```

--------------------------------

### Configuration

Source: https://docs.wavedash.com/multiplayer/networking

How to configure the P2P networking runtime.

```APIDOC
## Configuration

Pass a `p2p` field on your `WavedashJS.init(config)` call to tune the P2P runtime. All fields are optional — the defaults below are used if you omit the block entirely.

Field| Default| Description  
---|---|---
`maxPeers`| `8`| Maximum number of simultaneous peer connections.  
`enableReliableChannel`| `true`| Allocate the reliable (ordered, guaranteed) channel.  
`enableUnreliableChannel`| `true`| Allocate the unreliable (best-effort) channel.  
`messageSize`| `2048`| Max bytes per message slot. Must be `> 44` and is capped at `65536`.  
`maxIncomingMessages`| `1024`| Max queued incoming messages per channel.  

```javascript
WavedashJS.init({
  debug: false,
  p2p: {
    maxPeers: 4,
    messageSize: 4096,
    maxIncomingMessages: 512
  }
});
```
```

--------------------------------

### Build Bevy Game with Trunk

Source: https://docs.wavedash.com/engines/bevy

Use Trunk for building Bevy games to WebAssembly. The output is placed in the `dist/` folder.

```bash
trunk build --release

```

--------------------------------

### Get User Avatar URL

Source: https://docs.wavedash.com/sdk/functions

Use `getUserAvatarUrl` to get an avatar URL for a given user ID and size. Supported sizes are 0 (small), 1 (medium), and 2 (large).

```javascript
function getUserAvatarUrl(
  userId: string,
  size: 0 | 1 | 2
): string | null;
```

--------------------------------

### Check SDK Ready State in JavaScript

Source: https://docs.wavedash.com/sdk/setup

Use these boolean getters to ensure the SDK is initialized, ready for events, and the game is loaded before proceeding.

```javascript
if (!WavedashJS.initialized) WavedashJS.init();
if (WavedashJS.eventsReady && WavedashJS.gameLoaded) {
  // SDK is fully booted and serving events
}

```

--------------------------------

### Receiving Messages

Source: https://docs.wavedash.com/multiplayer/networking

Example of how to drain and process incoming P2P messages.

```APIDOC
## Receiving Messages

```gdscript
func _process(_delta):
    var messages = WavedashSDK.drain_p2p_channel(0)
    for msg in messages:
        var from_user = msg["identity"]
        var payload: PackedByteArray = msg["payload"]
```
```

--------------------------------

### Advanced: Batch Reading

Source: https://docs.wavedash.com/multiplayer/networking

Example of batch reading messages into a buffer for efficiency.

```APIDOC
## Advanced: batch reading

For game engines, `drainP2PChannelToBuffer` reads all queued messages into a tightly packed binary buffer:

```javascript
const packed = WavedashJS.drainP2PChannelToBuffer(0);
const view = new DataView(packed.buffer);
let offset = 0;
while (offset < packed.byteLength) {
  const size = view.getUint32(offset, true);
  offset += 4;
  const message = packed.subarray(offset, offset + size);
  offset += size;
}
```
```

--------------------------------

### Initialize Kaplay with WavedashJS SDK

Source: https://docs.wavedash.com/engines/kaplay

Integrate the WavedashJS SDK by awaiting it, reporting load progress, and initializing Kaplay. Call `WavedashJS.init()` when your game is ready to signal load completion and hand over focus.

```javascript
import kaplay from "https://unpkg.com/kaplay@3001.0.19/dist/kaplay.mjs";

const WavedashJS = await window.WavedashJS;
WavedashJS.updateLoadProgressZeroToOne(0.3);

const canvas = document.getElementById("wavedash-target");
const k = kaplay({ canvas, width: 1600, height: 900, letterbox: true });

// ...load sprites, define scenes, etc...

WavedashJS.init({ debug: false });

```

--------------------------------

### Publish Blazor Project

Source: https://docs.wavedash.com/engines/monogame

Publish your KNI Blazor project for release. The output will be in the wwwroot directory.

```bash
dotnet publish -c Release

```

--------------------------------

### Sending Messages

Source: https://docs.wavedash.com/multiplayer/networking

Examples for broadcasting messages to all peers or sending to a specific peer.

```APIDOC
## Sending Messages

### Broadcast to all peers

```gdscript
func broadcast_to_all(data: PackedByteArray, reliable: bool = true):
    WavedashSDK.send_p2p_message("", data, 0, reliable)
```

### Send to a specific peer

```gdscript
func send_to_peer(user_id: String, data: PackedByteArray):
    WavedashSDK.send_p2p_message(user_id, data, 0, true)
```

### Parameters

Parameter| Type| Required| Description  
---|---|---|---
`userId`| string| For unicast| Target peer's user ID (omit or `undefined` to broadcast)
`channel`| number| Yes| Channel number (0-7)
`payload`| Uint8Array| Yes| Binary data to send
`reliable`| boolean| No| Use reliable channel (default: true)
`payloadSize`| number| No| Bytes to send from payload (default: `payload.length`)
```

--------------------------------

### Get Number of Lobby Users Function

Source: https://docs.wavedash.com/sdk/functions

Returns the count of users currently in a specified lobby.

```typescript
function getNumLobbyUsers(
  lobbyId: string
): number;
```

--------------------------------

### Bundle Defold HTML5 Game via bob.jar

Source: https://docs.wavedash.com/engines/defold

Use the `bob.jar` command-line tool to bundle your Defold game for the js-web platform with wasm architecture.

```bash
java -jar bob.jar \
  --platform js-web \
  --architectures wasm-web \
  --archive \
  --bundle-output bundle \
  resolve build bundle

```

--------------------------------

### Get Lobby Users Function

Source: https://docs.wavedash.com/sdk/functions

Retrieves a list of users currently present in a specified lobby.

```typescript
function getLobbyUsers(
  lobbyId: string
): LobbyUser[];
```

--------------------------------

### Configure Wavedash Upload Directory

Source: https://docs.wavedash.com/engines/defold

Configure `wavedash.toml` by setting `upload_dir` to the folder containing your Defold HTML5 build. Omit `entrypoint` as Defold's bundle includes `index.html` at the root. Use a directory name other than `build/` for your upload directory.

```toml
game_id = "YOUR_GAME_ID_HERE"
upload_dir = "./dist"

```

--------------------------------

### Initialize PixiJS App with Wavedash SDK

Source: https://docs.wavedash.com/engines/pixi

Initialize the PixiJS application and integrate with the Wavedash SDK. Use top-level await for asynchronous operations and call WavedashJS.init() last after updating load progress.

```javascript
const WavedashJS = await window.WavedashJS;

const container = document.getElementById("pixiCanvas");
const app = new PIXI.Application();
await app.init({ background: 0x111111, resizeTo: container, antialias: true });
container.appendChild(app.canvas);

// ... game objects on app.stage ...

WavedashJS.updateLoadProgressZeroToOne(1);
WavedashJS.init({ debug: true });

app.ticker.add((ticker) => {
  // ... game logic ...
});

```

--------------------------------

### Get P2P Max Payload Size Function

Source: https://docs.wavedash.com/sdk/functions

Returns the maximum payload size in bytes for a single P2P message.

```typescript
function getP2PMaxPayloadSize(): number;
```

--------------------------------

### Initialize Wavedash SDK in JavaScript

Source: https://docs.wavedash.com/getting-started/introduction

Set up the Wavedash SDK in your JavaScript game. This function connects your game to Wavedash services and returns an instance of the SDK. It is automatically provided in production environments and simulated during local development with `wavedash dev`.

```javascript
const wavedash = await setupWavedashSDK()
// WavedashJS is also available on window.WavedashJS
```

--------------------------------

### Get Lobby Data Function

Source: https://docs.wavedash.com/sdk/functions

Reads a metadata key from the lobby. Returns the value associated with the key, or null if not found.

```typescript
function getLobbyData(
  lobbyId: string,
  key: string
): string | number | boolean | null;
```

--------------------------------

### Get User JWT for Authentication

Source: https://docs.wavedash.com/sdk/functions

Call `getUserJwt` to obtain a short-lived signed JWT that can be forwarded to your backend for player authentication.

```javascript
function getUserJwt(): Promise<WavedashResponse<string>>;
```

--------------------------------

### Initialize Wavedash SDK in Godot

Source: https://docs.wavedash.com/sdk/setup

Connect to backend events and initialize the SDK with configuration. This should be called once before other SDK methods.

```gdscript
func _ready():
    WavedashSDK.backend_connected.connect(_on_connected)
    WavedashSDK.init({"debug": true, "deferEvents": true})
    WavedashSDK.ready_for_events()

func _on_connected(payload):
    print("SDK is ready!")
    var username = WavedashSDK.get_username()
    print("Playing as: ", username)

```

--------------------------------

### Wavedash TOML Configuration

Source: https://docs.wavedash.com/engines/custom

Configure your game's ID, upload directory, and entrypoint file using this `wavedash.toml` structure. The `entrypoint` should typically be your main HTML file.

```toml
game_id = "YOUR_GAME_ID_HERE"
upload_dir = "./build/web"
entrypoint = "index.html"


```

--------------------------------

### Get Lobby Invite Link Function

Source: https://docs.wavedash.com/sdk/functions

Generates a shareable invite link for the current lobby. Optionally copies the link to the clipboard.

```typescript
function getLobbyInviteLink(
  copyToClipboard?: boolean
): Promise<WavedashResponse<string>>;
```

--------------------------------

### Launch Parameters

Source: https://docs.wavedash.com/sdk/functions

Read URL parameters that were passed when the game was launched.

```APIDOC
## Launch Parameters

### `getLaunchParams()`

**Description**: Returns the key-value mapping of `wvdsh_`-prefixed URL query params that were present when the game launched.

**Signature**: `function getLaunchParams(): GameLaunchParams;`

```

--------------------------------

### Connect to Wavedash Backend Events

Source: https://docs.wavedash.com/sdk/setup

Connect to Wavedash backend events in your _ready function to monitor connection status. Payload is not used in these examples.

```gdscript
func _ready():
    WavedashSDK.backend_connected.connect(_on_connected)
    WavedashSDK.backend_disconnected.connect(_on_disconnected)
    WavedashSDK.backend_reconnecting.connect(_on_reconnecting)
```

```gdscript
func _on_connected(payload):
    print("Connected to Wavedash!")
```

```gdscript
func _on_disconnected(payload):
    print("Disconnected from Wavedash")
```

```gdscript
func _on_reconnecting(payload):
    print("Reconnecting to Wavedash...")
```

--------------------------------

### Get P2P Max Incoming Messages Function

Source: https://docs.wavedash.com/sdk/functions

Returns the configured maximum number of incoming messages allowed per channel queue.

```typescript
function getP2PMaxIncomingMessages(): number;
```

--------------------------------

### Get or Create Leaderboard

Source: https://docs.wavedash.com/sdk/leaderboards

Call this once per leaderboard to obtain its ID. Reuse the ID for subsequent leaderboard operations. Handles both creation and retrieval.

```gdscript
func setup_leaderboard():
    var leaderboard = await WavedashSDK.get_or_create_leaderboard(
        "speedrun-times",
        WavedashConstants.LEADERBOARD_SORT_ASCENDING,
        WavedashConstants.LEADERBOARD_DISPLAY_TYPE_TIME_MILLISECONDS
    )
    var leaderboard_id = leaderboard.data.id if leaderboard.success else ""
    print("Leaderboard ID: ", leaderboard_id)

```

--------------------------------

### Get Lobby User Information

Source: https://docs.wavedash.com/multiplayer/lobbies

Retrieve a list of users in a lobby, the ID of the lobby host, and the total number of users currently in the lobby.

```gdscript
var users = WavedashSDK.get_lobby_users(lobby_id)
var host_id = WavedashSDK.get_lobby_host_id(lobby_id)
var count = WavedashSDK.get_num_lobby_users(lobby_id)

```

--------------------------------

### Initialize Wavedash SDK in Construct Script

Source: https://docs.wavedash.com/engines/construct

Use this script in Construct's main.js to wait for WavedashJS to be available and then initialize it. Ensure the script file has 'Main' purpose in Construct's IDE.

```javascript
// scripts/main.js
async function waitForWavedash() {
  while (!globalThis.WavedashJS) {
    await new Promise((r) => setTimeout(r, 50));
  }
  return globalThis.WavedashJS;
}

runOnStartup(async (runtime) => {
  runtime.addEventListener("beforeprojectstart", async () => {
    const sdk = await waitForWavedash();

    // Your game logic here...

    sdk.updateLoadProgressZeroToOne(1);
    sdk.init({ debug: true });
  });
});

```

--------------------------------

### JavaScript Bridge for Wavedash

Source: https://docs.wavedash.com/engines/csharp

Defines global JavaScript functions that C# can call via JSImport. This example shows how to bridge Wavedash SDK calls.

```javascript
const sdk = await window.WavedashJS;

globalThis.wavedashInit = function () {
  sdk.init({ debug: true });
};

globalThis.wavedashProgress = function (p) {
  sdk.updateLoadProgressZeroToOne(p);
};

import { dotnet } from "./_framework/dotnet.js";

const { getAssemblyExports } = await dotnet.create();
const exports = await getAssemblyExports("Pong.dll");

exports.Interop.WdInit(width, height);

```

--------------------------------

### Define GameLaunchParams for URL Parameters

Source: https://docs.wavedash.com/sdk/types

Interface for key-value mapping of URL query parameters present at game launch. Includes lobby ID and any other wvdsh_-prefixed parameters.

```typescript
interface GameLaunchParams {
  lobby?: string;              // Lobby ID if the player followed an invite link
  [key: string]: string | undefined; // Any other wvdsh_-prefixed params
}
```

--------------------------------

### Wavedash Configuration File

Source: https://docs.wavedash.com/engines/gamemaker

Configure your game's Wavedash integration using the `wavedash.toml` file. Set your unique game ID, the directory containing the uploaded build files, and the entry point HTML file.

```toml
game_id = "YOUR_GAME_ID_HERE"
upload_dir = "./build"
entrypoint = "index.html"
```

--------------------------------

### Get Lobby Host ID Function

Source: https://docs.wavedash.com/sdk/functions

Returns the user ID of the host for a given lobby. Returns null if the host is not found or the lobby does not exist.

```typescript
function getLobbyHostId(
  lobbyId: string
): string | null;
```

--------------------------------

### Get Player Information

Source: https://docs.wavedash.com/sdk/functions

Use `getUser`, `getUserId`, and `getUsername` to retrieve the signed-in player's profile, stable ID, and display name respectively.

```javascript
function getUser(): User;

function getUserId(): string;

function getUsername(): string;
```

--------------------------------

### Lobby Creation

Source: https://docs.wavedash.com/multiplayer/lobbies

Create and manage multiplayer game lobbies. Lobbies support real-time messaging, metadata storage, and automatic P2P connection setup.

```APIDOC
## Creating a lobby

### Description
Creates a new multiplayer lobby. You can specify the lobby type (public, friends-only, private) and the maximum number of players.

### Method
`create_lobby`

### Parameters
- **lobby_type** (Constant) - Required - The visibility type of the lobby. Use constants like `WavedashConstants.LOBBY_TYPE_PUBLIC`, `WavedashConstants.LOBBY_TYPE_FRIENDS_ONLY`, `WavedashConstants.LOBBY_TYPE_PRIVATE`.
- **max_players** (Integer) - Required - The maximum number of players allowed in the lobby.

### Visibility Options
- `0` (`PUBLIC`): Anyone can find and join.
- `1` (`FRIENDS_ONLY`): Only friends can see and join.
- `2` (`PRIVATE`): Only joinable with the lobby ID.

### Response Example
```json
{
  "success": true,
  "data": "lobby_id_string"
}
```
```

--------------------------------

### Build Go Game for WebAssembly

Source: https://docs.wavedash.com/engines/go

Compile your Go game to a WASM binary and copy the necessary JavaScript shim. Ensure the `GOOS` and `GOARCH` environment variables are set correctly.

```shell
GOOS=js GOARCH=wasm go build -o build/web/game.wasm ./src
cp "$(go env GOROOT)/misc/wasm/wasm_exec.js" build/web/
```

--------------------------------

### Wavedash Configuration File

Source: https://docs.wavedash.com/engines/construct

Configure your game ID and upload directory for Wavedash using the wavedash.toml file.

```toml
game_id = "YOUR_GAME_ID_HERE"
upload_dir = "./build"

```

--------------------------------

### Report Custom Event from Ren'Py to Wavedash SDK

Source: https://docs.wavedash.com/engines/renpy

Emit a custom event from Ren'Py by printing a prefixed string. This example shows how to report a 'first_chapter' event.

```python
$ print("%sreportEvent:first_chapter" % PREFIX)
```
Tokens:
Raw