Overview¶
Colyseus currently have clients for the platforms:
- HTML5 (colyseus/colyseus.js)
- Unity3D (colyseus/colyseus-unity3d)
- Defold (colyseus/colyseus-defold)
- Haxe (colyseus/colyseus-hx)
- Cocos2d-X (colyseus/colyseus-cocos2d-x)
- Construct3 (colyseus/colyseus-construct3)
Need a client for another platform? Share your interest on the discussion board!
Instantiate the Colyseus client¶
The client is used to perform matchmaking calls, and later connect to one or many rooms.
There is no actual server-side connection at this point.
import Colyseus from "colyseus.js";
// ...
let client = new Colyseus.Client("ws://localhost:2567");
using Colyseus;
// ...
Client client = new Client("ws://localhost:2567");
local ColyseusClient = require("colyseus.client")
// ...
local client = ColyseusClient.new("ws://localhost:2567");
import io.colyseus.Client;
// ...
var client = new Client("ws://localhost:2567");
Methods¶
joinOrCreate (roomName: string, options: any)
¶
Join an existing room or create a new one, by provided roomName
and options
.
Locked or private rooms are ignored by this method.
try {
const room = await client.joinOrCreate("battle", {/* options */});
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.joinOrCreate("battle", {/* options */}).then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.JoinOrCreate<YourStateClass>("battle"/* , Dictionary of options */);
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:join_or_create("battle", {--[[options]]}, function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.joinOrCreate("battle", [/* options */], YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->joinOrCreate<YourStateClass>("battle", {/* options */}, [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});
create (roomName: string, options: any)
¶
Creates a new room by provided roomName
and options
.
try {
const room = await client.create("battle", {/* options */});
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.create("battle", {/* options */}).then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.Create<YourStateClass>("battle", /* Dictionary of options */);
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:create("battle", {--[[options]]}, function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.create("battle", [/* options */], YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->create<YourStateClass>("battle", {/* options */}, [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});
join (roomName: string, options: any)
¶
Joins an existing room by provided roomName
and options
.
Locked or private rooms are ignored by this method.
try {
const room = await client.join("battle", {/* options */});
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.join("battle", {/* options */}).then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.Join<YourStateClass>("battle", /* Dictionary of options */);
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:join("battle", {--[[options]]}, function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.join("battle", [/* options */], YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->join<YourStateClass>("battle", {/* options */}, [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});
joinById (roomId: string, options: any)
¶
Joins an existing room by its roomId
. Private rooms can be joined by id.
try {
const room = await client.joinById("KRYAKzRo2", {/* options */});
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.joinById("KRYAKzRo2", {/* options */}).then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.JoinById<YourStateClass>("battle", /* Dictionary of options */);
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:join_by_id("battle", {--[[options]]}, function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.joinById("battle", [/* options */], YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->joinById<YourStateClass>("battle", {/* options */}, [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});
Tip
Use getAvailableRooms()
to retrieve a list of roomId
's available for joining.
reconnect (roomId: string, sessionId: string)
¶
Reconnects the client into a room he was previously connected with.
Must be used along with allowReconnection()
in the server-side.
try {
const room = await client.reconnect("wNHTX5qik", "SkNaHTazQ");
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.reconnect("wNHTX5qik", "SkNaHTazQ").then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.Reconnect<YourStateClass>("wNHTX5qik", "SkNaHTazQ");
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:reconnect("wNHTX5qik", "SkNaHTazQ", function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.reconnect("wNHTX5qik", "SkNaHTazQ", YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->reconnect<YourStateClass>("wNHTX5qik", "SkNaHTazQ", [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});
getAvailableRooms (roomName?: string)
¶
List all available rooms to connect. Locked and private rooms won't be listed. roomName
is optional.
client.getAvailableRooms("battle").then(rooms => {
rooms.forEach((room) => {
console.log(room.roomId);
console.log(room.clients);
console.log(room.maxClients);
console.log(room.metadata);
});
}).catch(e => {
console.error(e);
});
try {
var rooms = await client.GetAvailableRooms("battle");
for (int i = 0; i < rooms.Length; i++) {
Debug.Log(rooms[i].roomId);
Debug.Log(rooms[i].clients);
Debug.Log(rooms[i].maxClients);
Debug.Log(rooms[i].metadata);
}
} catch (ex) {
Debug.Log(ex.Message)
}
/**
* Retrieving custom metadata
*/
[Serializable]
class Metadata
{
public string mode;
public string name;
}
[Serializable]
class CustomRoomAvailable : RoomAvailable
{
public Metadata metadata;
}
var rooms = await client.GetAvailableRooms<CustomRoomAvailable>("battle");
Debug.Log(rooms[0].metadata.mode);
client:get_available_rooms("battle", function(err, rooms)
if (err) then
console.error(err);
return
end
for i, rooms in pairs(rooms) do
print(rooms[i].roomId)
print(rooms[i].clients)
print(rooms[i].maxClients)
print(rooms[i].metadata)
end
end);
client.getAvailableRooms("battle", function(err, rooms) {
if (err != null) {
trace(err);
return;
}
for (room in rooms) {
trace(room.roomId);
trace(room.clients);
trace(room.maxClients);
trace(room.metadata);
}
});
client.getAvailableRooms("battle", [=](std::string err, nlohmann::json rooms) {
if (err != "") {
std::cout << "error: " << err << std::endl;
return;
}
// rooms
});
consumeSeatReservation (reservation)
¶
Join a room by consuming a seat reservation.
Advanced usage
See Match-maker API to see how to retrieve the seat reservation data.
try {
const room = await client.consumeSeatReservation(reservation);
console.log("joined successfully", room);
} catch (e) {
console.error("join error", e);
}
client.consumeSeatReservation(reservation).then(room => {
console.log("joined successfully", room);
}).catch(e => {
console.error("join error", e);
});
try {
Room<YourStateClass> room = await client.ConsumeSeatReservation<YourStateClass>(reservation);
Debug.Log("joined successfully");
} catch (ex) {
Debug.Log("join error");
Debug.Log(ex.Message);
}
client:consume_seat_reservation(reservation, function(err, room)
if (err ~= nil) then
print("join error: " .. err)
return
end
print("joined successfully")
end)
client.consumeSeatReservation(reservation, YourStateClass, function(err, room) {
if (err != null) {
trace("join error: " + err);
return;
}
trace("joined successfully");
});
client->consumeSeatReservation<YourStateClass>(reservation, [=](std::string err, Room<State>* room) {
if (err != "") {
std::cout << "join error: " << err << std::endl;
return;
}
std::cout << "joined successfully" << std::endl;
});