Broadsock

Broadsock is a TCP socket broadcast server and client for the Defold game engine. The primary purpose of the server is to synchronize the positions of game objects in a Defold game and create and delete game object instances as they are created and deleted on remote clients. The Broadsock server will listen for client connections, maintain a list of currently connected clients and broadcast any received data to all connected clients but the sender.

The Broadsock server and client communicates using a message format that handles raw bytes, strings and numbers.

Message format

A Broadsock message has the following format:

+------------+-~~~~~~~~~~~~-+-~~~~~~~~~~~~~~~-+-~~~~~~~~-+
| LENGTH [4] | UID [string] | MSG_ID [string] | DATA [*] |
+------------+-~~~~~~~~~~~~-+-~~~~~~~~~~~~~~~-+-~~~~~~~~-+

• LENGTH = Length of the message in bytes
• UID = Unique ID of the player that sent the message (only when broadcast from server)
• MSG_ID = Message id
• DATA = Message data

Message ids

Broadsock has a number of reserved message ids:

• CONNECT_OTHER - Sent to other connected clients when a new client connects. Contains the unique user id of the connected client, as well as IP and port.
• CONNET_SELF - Sent from the server to the connecting client. Contains a unique user id for the connected client.
• DISCONNECT - Broadcast from the server when a client disconnects
• GO - Sent from a client every update. Contains a list of transform updates for registered game objects. Will be broadcast to the other clients.
• GOD - Sent from a client when a game object is unregistered. Will be broadcast to the other clients.

Installation

You can use the Broadsock client in your own project by adding this project as a Defold library dependency. Open your game.project file and in the dependencies field under project add:

https://github.com/britzl/broadsock/archive/master.zip

Or point to the ZIP file of a specific release.

Usage

Client integration

The easiest way to get started with Broadsock is to add the broadsock/client/broadsock.go instance to a collection in your game and then use message passing to connect and register game objects:

local BROADSOCK = msg.url("example:/broadsock#script")
function init(self)
    -- Tell broadsock to connect to a Broadsock server instance
    msg.post(BROADSOCK, "connect", { ip = "127.0.0.1", port = 5000 })
end
function on_message(self, message_id, message, sender)
    if message_id == hash("connected") and sender == BROADSOCK then
        -- Register a bullet factory
        msg.post(BROADSOCK, "register_factory", { url = "/factory#bullet", type = "bullet" })
    end
end
function on_input(self, action_id, action)
    if action_id == hash("fire") and action.released then
        -- Register a bullet game object
        -- This game object will automatically sync it's position with other broadsock connected clients
        -- The receiving clients will automatically create game objects on their end
        self.bullet_id = factory.create("/factory#bullet")
        msg.post(BROADSOCK, "register_gameobject", { id = self.bullet_id, type = "bullet" })
    end
end
function update(self, dt)
    ... move bullet
    -- Unregister a game object
    -- This game object will no longer sync it's position with other broadsock connected clients
    -- The fact that the game object was unregistered will be sent to the other clients and their
    -- remote counter parts will automatically be deleted
    go.delete(self.bullet_id)
    msg.post(BROADSOCK, "unregister_gameobject", { id = self.bullet_id })
end

Server

The Broadsock server is also written for Defold. It is recommended to run the server using a headless version of Defold but this is no requirement. The easiest way to get started is to add the broadsock/server/broadsock.go instance to a collection and bundle and run.

Once the server is running it will listen for Broadsock client connections. The server will broadcast any received message to connected clients.