Nakama JavaScript客户端指南 #

1
2

yarn add "@heroiclabs/nakama-js"
yarn install

1

import {Client} from "@heroiclabs/nakama-js"

1

await client.authenticateDevice("<deviceId>");

1
2
3
4
5
6

try {
    await client.authenticateDevice("<deviceId>");
}
catch (err) {
    console.log("Error authenticating device: %o:%o", err.statusCode, err.message);
}

1

var client = new nakamajs.Client("defaultkey", "127.0.0.1", 7350);

1

client.timeout = 10000;

1
2
3
4

const socket = client.createSocket();

var appearOnline = true;
await socket.connect(session, appearOnline);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// This import is only required with React Native
var deviceInfo = require('react-native-device-info');

var deviceId = null;
// If the user's device ID is already stored, grab that - alternatively get the System's unique device identifier.
try {
  const value = await AsyncStorage.getItem('@MyApp:deviceKey');
  if (value !== null){
    deviceId = value
  } else {
    deviceId = deviceInfo.getUniqueID();
    // Save the user's device ID so it can be retrieved during a later play session for re-authenticating.
    AsyncStorage.setItem('@MyApp:deviceKey', deviceId).catch(function(error) {
      console.log("An error occurred: %o", error);
    });
  }
} catch (error) {
  console.log("An error occurred: %o", error);
}

// Authenticate with the Nakama server using Device Authentication.
var create = true;
const session = await client.authenticateDevice(deviceId, create, "mycustomusername");
console.info("Successfully authenticated:", session);

1
2
3
4
5
6
7
8
9

const oauthToken = "<token>";
const importFriends = true;
try {
    const session = await client.authenticateFacebook(oauthToken, true, "mycustomusername", importFriends);
    console.log("Successfully authenticated:", session);
}
catch(err) {
    console.log("Error authenticating with Facebook: %o", err.message);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// Acquiring the unique device ID has been shortened for brevity, see previous example.
var deviceId = "<uniqueDeviceId>";

// Link Device Authentication to existing player account.
try {
    await client.linkDevice(session, deviceId);
    console.log("Successfully linked Device ID authentication to existing player account");
}
catch(err) {
    console.log("Error linking Device ID: %o", err.message);
}

1
2
3
4
5
6
7
8
9

const oauthToken = "<token>";
const import = true;
try {
    const session = await client.linkFacebook(session, oauthToken, true, import);
    console.log("Successfully linked Facebook authentication to existing player account");
}
catch(err) {
    console.log("Error authenticating with Facebook: %o", err.message);
}

1
2
3
4
5
6
7
8

const vars = {
  deviceId = localStorage.getItem("deviceId"),
  deviceOs = localStorage.getItem("deviceOs"),
  inviteUserId = "<someUserId>",
  // ...
}

const session = await client.authenticateDevice(deviceId, null, true, vars);

1

var deviceOs = session.vars["deviceOs"];

1
2

var authToken = session.token;
var refreshToken = session.refresh_token;

1

session = session.restore(authToken, refreshToken);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// Check whether a session has expired or is close to expiry.
if (session.isexpired || session.isexpired(Date.now + 1) {
    try {
        // Attempt to refresh the existing session.
        session = await client.sessionRefresh(session);
    } catch (error) {
        // Couldn't refresh the session so reauthenticate.
        session = await client.authenticateDevice(deviceId);
        var refreshToken = session.refresh_token;
    }

    var authToken = session.token;
}

1

await client.sessionLogout(session);

1
2
3
4
5

const account = await client.getAccount(session);
const user = account.user;
var username = user.username;
var avatarUrl = user.avatarUrl;
var userId = user.id;

1
2
3
4
5
6
7

var newUsername = "NotTheImp0ster";
var newDisplayName = "Innocent Dave";
var newAvatarUrl = "https://example.com/imposter.png";
var newLangTag = "en";
var newLocation = "Edinburgh";
var newTimezone = "BST";
await client.updateAccount(session, newUsername, newDisplayName, newAvatarUrl, newLangTag, newLocation, newTimezone);

1

var users = await client.getUsers(session, ["<AnotherUserId>"]);

1
2
3
4
5
6
7
8
9

// Get the updated account object.
var account = await client.getAccount(session);

// Parse the account user metadata.
var metadata = JSON.parse(account.user.metadata);

console.log("Title: %o", metadata.title);
console.log("Hat: %o", metadata.hat);
console.log("Skin: %o", metadata.skin);

1
2
3
4
5
6
7

var account = await client.getAccount(session);
var wallet = JSON.parse(account.wallet);
var keys = wallet.keys;

keys.forEach(function(currency) {
    console.log("%o: %o", currency, wallet[currency].toString())
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var readObjectId = new storageObjectId {
    collection = "Unlocks",
    key = "Hats",
    userId = session.user.id
};

var result = await client.readStorageObjects(session, readObjectId);

if (result.objects.any())
{
    var storageObject = result.objects.first();
    var unlockedHats = JSON.parse(storageObject.value);
    console.log("Unlocked hats: %o", string.join(",", unlockedHats.Hats));
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var favoriteHats = new {
    hats = ["cowboy", "alien"]
};

var writeObject = new WriteStorageObject {
    collection = "favorites",
    ley = "Hats",
    value = JSON.stringify(favoriteHats),
    permissionRead = 1, // Only the server and owner can read
    permissionWrite = 1 // The server and owner can write
};

await client.writeStorageObjects(session, writeObject);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var writeObjects = {
    new WriteStorageObject {
        //...
    },
    new WriteStorageObject
    {
        // ...
    }
};

await client.writeStorageObjects(session, writeObjects);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// Assuming we already have a storage object (storageObject)
var writeObject = new WriteStorageObject {
    collection = storageObject.collection,
    key = storageObject.key,
    value = "<NewJSONValue>",
    permissionWrite = 0,
    permissionRead = 1,
    version = storageObject.version
};

try {
    await client.writeStorageObjects(session, writeObjects);
}
catch (error) {
    console.log(error.message);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

var limit = 3;
var cursor = null;
var unlocksObjectList = await client.listStorageObjects(session, "Unlocks", limit, cursor);

unlocksObjectList.objects.forEach(function(unlockStorageObject) {
    switch(unlockStorageObject.key) {
        case "Titles":
            var unlockedTitles = JSON.parse<TitlesStorageObject>(unlockStorageObject.value);
            // Display the unlocked titles
            break;
        case "Hats":
            var unlockedHats = JSON.parse<HatsStorageObject>(unlockStorageObject.value);
            // Display the unlocked hats
            break;
        case "Skins":
            var unlockedSkins = JSON.parse<SkinsStorageObject>(unlockStorageObject.value);
            // Display the unlocked skins
            break;
    }
});

1

objectList = await client.listStorageObjects(session, "<CollectionName>", limit, objectList.cursor);

1
2
3
4
5
6
7
8

try {
    var payload = { "item": "cowboy"};
    var response = await client.rpc(session, "EquipHat", payload);
    console.log("New hat equipped successfully", response);
}
catch (error) {
    console.log("Error: %o", error.message);
}

1

var response = await socket.rpc("<rpcId>", "<payloadString>");

1
2
3
4
5
6
7

// Add friends by Username.
var usernames = ["AlwaysTheImposter21", "SneakyBoi"];
await client.addFriends(session, usernames);

// Add friends by User ID.
var ids = ["<SomeUserId>", "<AnotherUserId>"];
await client.addFriends(session, ids);

1
2
3
4
5
6
7

var limit = 20; // Limit is capped at 1000
var friendshipState = 0;
var result = await client.listFriends(session, friendshipState, limit, cursor: null);

result.forEach((friend) => {
    console.log("ID: %o", friend.user.id);
});

1
2
3
4
5
6

var limit = 1000;
var result = await client.listFriends(session, 2, limit, cursor: null);

result.forEach((friend) => {
    await client.addFriends(session, friend.user.id);
});

1
2
3
4
5
6
7

// Delete friends by User ID.
var ids = ["<SomeUserId>", "<AnotherUserId>"];
await client.deleteFriends(session, ids});

// Delete friends by Username.
var usernames = ["AlwaysTheImposter21", "SneakyBoi"];
await client.deleteFriends(session, null, usernames});

1
2
3
4
5
6
7

// Block friends by User ID.
var ids = ["<SomeUserId>", "<AnotherUserId>"];
await client.blockFriends(session, ids);

// Block friends by Username.
var usernames = ["AlwaysTheImposter21", "SneakyBoi"];
await client.blockFriends(session, usernames);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Subscribe to the Status event.
socket.onstatuspresence = (e) => {
    e.joins.forEach(function(presence){
        console.log("%o is online with status: %o", presence.username, presence.status);
    })
    e.leaves.forEach(function(presence){
        console.log("%o went offline", presence.username);
    })
};

// Follow mutual friends and get the initial Status of any that are currently online.
var friendsResult = await client.listFriends(session, 0);
var friendIds = [];
friendsResult.friends.forEach(function(friend) {
    friendIds.push(friend.user.id);
});
var result = await socket.followUsers(friendIds);

result.presences.forEach(function(presence){
    console.log("%o is online with status: %o", presence.username, presence.status);
});

1

await socket.unfollowUsers(["<UserId>"]);

1

await socket.updateStatus("Viewing the Main Menu");

1
2
3
4
5
6
7
8
9

const groupName = "Imposters R Us";
const description = "A group for people who love playing the imposter.";

const group = await client.createGroup(session {
    name: groupName,
    description: description,
    open: true, // public group
    maxSize = 100
});

1
2
3
4

const groupId = "<groupId>";
await client.updateGroup(session, groupId, {
    open: false
});

1
2
3
4
5
6
7
8
9

var limit = 20;
var result = await client.ListGroupsAsync(session, "imposter%", limit);

result.groups.forEach(function(group){
    console.log("%o group is %o", group.name, group.open);
});

// Get the next page of results.
var nextResults = await client.listGroups(session, name: "imposter%", limit, result.cursor);

1
2

const groupId = "<groupId>";
await client.deleteGroup(session, groupId);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

const payload = new {
    groupId = "<GroupId>",
    interests = ["Deception", "Sabotage", "Cute Furry Bunnies"],
    activeTimes = ["9am-2pm Weekdays", "9am-10pm Weekends"],
    languages = ["English", "German"]
};

try {
    var result = await client.rpc(session, "UpdateGroupMetadata", JSON.stringify(payload));
    console.log("Successfully updated group metadata");
}
catch (error) {
    console.log("Error: %o", error.message);
}

1
2

const group_id = "<group id>";
await client.joinGroup(session, group_id);

1
2
3
4
5

const userId = "<user id>";
const groups = await client.listUserGroups(session, userId);
groups.user_groups.forEach(function(userGroup){
  console.log("Group: name '%o' State: '%o'.", userGroup.group.name, userGroup.state);
});

1
2
3
4
5

const groupId = "<group id>";
const groups = await client.listUserGroups(session, groupId);
groups.group_users.forEach(function(groupUser){
  console.log("User: ID '%o' State: '%o'.", groupUser.user.id, groupUser.state);
});

1
2
3
4
5

const groupId = "<group id>";
const result = await client.listGroupUsers(session, groupId);
groups.group_users.forEach(function(groupUser){
    await client.addGroupUsers(session, groupId, [groupUser.user.id]);
});

1
2
3

const groupId = "<group id>";
const userId = "<user id>";
await client.promoteGroupUsers(session, groupId, [userId]);

1
2
3

const groupId = "<group id>";
const userId = "<user id>";
await client.demoteGroupUsers(session, groupId, [userId]);

1
2
3

const groupId = "<group id>";
const userId = "<user id>";
await client.kickGroupUsers(session, groupId, [userId]);

1
2
3

const groupId = "<group id>";
const userId = "<user id>";
await client.banGroupUsers(session, groupId, [userId]);

1
2

const groupId = "<group id>";
await client.leaveGroup(session, groupId);

1
2
3
4
5
6
7

const roomName = "<match id>";
const persistence = false;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const channel = await socket.joinChat(roomName, 1, persistence, hidden);

console.log("Connected to dynamic room channel: %o", channel.id);

1
2
3
4
5
6
7

const groupId = "<group id>";
const persistence = true;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const channel = await socket.joinChat(3, groupId, persistence, hidden);

console.log("Connected to group channel: %o", channel.id);

1
2
3
4
5
6
7

const userId = "<user id>";
const persistence = true;
const hidden = false;
// 1 = Room, 2 = Direct Message, 3 = Group
const channel = await socket.joinChat(2, userId, persistence, hidden);

console.log("Connected to direct message channel: %o", channel.id);

1
2
3
4
5
6
7
8
9

var channelId = "<channel id>";
var data = { "message": "I think Red is the imposter!" };
const messageAck = await socket.writeChatMessage(channelId, data);

var emoteData = {
    "emote": "point",
    "emoteTarget": "<redPlayerUserId>"
}
const emoteMessageAck = await socket.writeChatMessage(channelId, emoteData);

1
2
3
4
5
6
7
8

const groupId = "<group id>";
const limit = 100;
const forward = true;

const result = await client.listChannelMessages(session, groupId, limit, forward, cursor: null);
result.messages.forEach((message) => {
  console.log("%o: %o", message.username, message.data);
});

1
2

const cursor = result.cacheable_cursor;
const nextResults = await client.listChannelMessages(session, groupId, limit, forward, cursor);

1
2
3

var channelId = "<ChannelId>";
var messageData = {"message": "I think Red is the imposter!" };
const messageSendAck = await socket.writeChatMessage(channelId, messageData);

1
2

var newMessageData = {"message": "I think BLUE is the imposter!" };
const messageUpdateAck = await socket.updateChatMessage(channelId, messageSendAck.message.id, newMessageData));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

var match = await socket.createMatch();
var friendsList = await client.listFriends(session);
var onlineFriends = [];
friendsList.friends.forEach((friend){
    if (friend.user.online){
        onlineFriends.push(friend.user);
    }
});

onlineFriends.friend.forEach(function(friend){
    var messageData = {"message": "Hey %o, join me for a match!", friends.username},
    var matchId = match.id,
    const channel = await socket.joinChat(2, friend.id),
    const messageAck = await socket.writeChatMessage(channel, messageData)
});

1
2

var matchId = "<MatchId>";
var match = await socket.joinMatch(matchId);

1
2
3
4
5
6
7
8
9

socket.onmatchmakermatched = async (matchmakerMatched) => {
    var match = await socket.joinMatch(matchmakerMatched);
};

var minPlayers = 2;
var maxPlayers = 10;
var query = "";

var matchmakingTicket = await socket.addMatchmaker(query, minPlayers, maxPlayers);

1
2
3
4
5
6

var status = {
    "Status": "Playing a match",
    "MatchId": "<MatchId>"
};

await socket.updateStatus(JSON.stringify(status));

1
2
3
4
5
6
7
8
9

socket.onstatuspresence = async (e) => {
    // Join the first match found in a friend's status
    e.joins.forEach(function(presence){
        var status = JSON.parse(presence.status),
        if (status.hasOwnProperty("MatchId")) {
            await socket.joinMatch(status["MatchId"]);
            break;
        }
    });

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var minPlayers = 2;
var maxPlayers = 10;
var limit = 10;
var authoritative = true;
var label = "";
var query = "";
const result = await client.listMatches(session, minPlayers, maxPlayers, limit, authoritative, label, query);

result.matches.forEach(function(match){
    console.log("%o: %o/10 players", match.id, match.size);
});

1

var label = "AnExactMatchLabel";

1

var query = "+label.skill:>100 label.mode:sabotage";

1
2
3
4
5
6
7
8

var match = await socket.joinMatch(matchId);

var players = {};

match.presences.forEach(function(presence){
    var go = spawnPlayer(); // Instantiate player object
    players.push(presence.session.id, go);
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

socket.onmatchpresence = (matchPresenceEvent) => {
    // For each player that has joined in this event...
    matchPresenceEvent.joins.forEach(function(presence){
        // Spawn a player for this presence and store it in a dictionary by session id.
        var go = // Instantiate player object;
        players.push(presence.session.id, go);
    })

    // For each player that has left in this event...
    matchPresenceEvent.leaves.forEach(function(presence){
        // Remove the player from the game if they've been spawned
        if (players.hasOwnProperty("SessionId"){
            const index = players.session.id;
            if (index > -1) {
                players.splice(index, 1);
            }
        })
    })
};

1
2
3
4
5

class PositionState {
    static X;
    static Y;
    static Z;
}

1
2
3
4
5
6
7
8
9

var state = new PositionState {
    x = transform.position.x,
    y = transform.position.y,
    z = transform.position.z
};

var opCode = 1;

await socket.sendMatchState(match.Id, opCode, JSON.stringify(state));

1
2
3
4
5
6

class OpCodes {
    static position = 1;
    static vote = 2;
}

await socket.sendMatchState(match.Id, OpCodes.position, JSON.stringify(state));

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

socket.onmatchdata = (matchState) => {
    switch (matchState.opCode) {
        case opCodes.position:
            // Get the updated position data
            var stateJson = matchState.state;
            var positionState = JSON.parse(stateJson);

            // Update the GameObject associated with that player
            if (players.hasOwnProperty(matchState.user_presence.session.id)) {
                // Here we would normally do something like smoothly interpolate to the new position, but for this example let's just set the position directly.
                players[matchState.user_presence.session.id].transform.position = new Vector3(positionState.s, positionState.y, positionState.z);
            }
            break;
        default:
            console.log("Unsupported op code");
            break;
    }
};

1
2
3
4
5
6

var minPlayers = 2;
var maxPlayers = 10;
var query = "+skill:>100 mode:sabotage";
var stringProperties = { "mode": "sabotage"};
var numericProperties = { "skill": 125};
var matchmakerTicket = await socket.addMatchmaker(query, minPlayers, maxPlayers, stringProperties, numericProperties);

1
2
3
4

socket.onmatchmakermatched = (matched) => {
  const matchId = null;
  socket.joinMatch(matchId, matched.token);
};

1
2
3

var open = false;
var maxPlayers = 4;
const party = await socket.createParty(open, maxPlayers);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

var friendsList = await client.listFriends(session);
var onlineFriends = [];
friendsList.friends.forEach((friend){
    if (friend.user.online){
        onlineFriends.push(friend.user);
    }
});

onlineFriends.friend.forEach(function(friend){
    var messageData = {"message": "Hey %o, wanna join the party?", friends.username};
    var partyId = party.id;
    const channel = await socket.joinChat(2, friend.id);
    const messageAck = await socket.writeChatMessage(channel, messageData);
});

1
2
3
4
5
6

socket.onchannelmessage = async (m) => {
    var content = JSON.parse(m.content);
    if (content.hasOwnProperty("partyId")) {
        await socket.joinParty(content["partyId"]);
    }
};

1
2

var newLeader = "<user id>";
await socket.promotePartyMember(party.Id, newLeader);

1

await socket.leaveParty(party.Id);

1
2
3

socket.onmatchmakermatched = async (matchmakerMatched) => {
    await socket.joinMatch(matchmakerMatched.match.id);
};

1
2
3
4
5

var partyId = "<party id>";
var minPlayers = 2;
var maxPlayers = 10;
var query = "";
var matchmakerTicket = await socket.addMatchmakerParty(partyId, query, minPlayers, maxPlayers);

1
2
3
4

var score = 1;
var subscore = 0;
var metadata = { "map": "space_station"};
await client.writeLeaderboardRecord(session, "weekly_imposter_wins", score, subscore, JSON.stringify(metadata));

1
2
3
4
5
6
7

var limit = 20;
var leaderboardName = "weekly_imposter_wins";
const result = await client.listLeaderboardRecords(session, leaderboardName, ownerIds: null, expiry: null, limit, cursor: null);

result.records.forEach(fuction(record){
    console.log("%o:%o", record.owner.id, record.score);
});

1
2
3
4
5
6
7
8

var userId = session.user.id;
var limit = 20;
var leaderboardName = "weekly_imposter_wins";
var result = await client.listLeaderboardRecordsAroundOwner(session, leaderboardName, userId, expiry: null, limit);

result.records.forEach(fuction(record){
    console.log("%o:%o", record.owner.id, record.score);
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

var friendsList = await client.ListFriendsAsync(session);
var userIds = [];
friendsList.friends.forEach(function(friend){
    userIds.push(friend.user.id);
});
var recordList = await client.listLeaderboardRecords(session, "weekly_imposter_wins", userIds, expiry: null, 100, cursor: null);

recordList.records.forEach(fuction(record){
    console.log("%o:%o", record.username, record.score);
});

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var groupId = "<group id>";
var groupUserList = await client.listGroupUsers(session, groupId);
var userIds = [];
groupUserList.forEach(function(group_user){
    if (group_user.state < 3){
        userIds.push(group_user.id);
    }
});

var recordList = await client.listLeaderboardRecords(session, "weekly_imposter_wins", userIds, expiry: null, 100, cursor: null);
recordList.records.forEach(fuction(record){
    console.log("%o:%o", record.username, record.score);
});

1
2

var leaderboardId = "<leaderboard id>";
await client.deleteLeaderboardRecord(session, leaderboardId);

1
2

var id = "<tournament id>";
await await client.joinTournament(session, id);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

var categoryStart = 1;
var categoryEnd = 2;
var startTime = 1538147711;
var endTime = null; // all tournaments from the start time
var limit = 100; // number to list per page
var cursor = null;
var result = await client.listTournaments(session, categoryStart, categoryEnd, startTime, endTime, limit, cursor);

result.tournaments.forEach(function(tournament) {
    console.log("%o:%o", tournament.id, tournament.title);
});

1
2
3
4
5
6

var tournamentName = "weekly_top_detective";
var limit = 20;
var result = await client.listTournamentRecords(session, tournamentName, limit);
result.records.forEach(function(record) {
  console.log("%o:%o", record.owner.id, record.score);
});

1
2
3
4
5
6
7

var userId = "<user id>";
var limit = 20;
var tournamentName = "weekly_top_detective";
var result = await client.listTournamentRecordsAroundOwner(session, tournamentName, userId, limit);
result.records.forEach(function(record) {
  console.log("%o:%o", record.owner.id, record.score);
});

1
2
3
4
5

var tournamentName = "weekly_top_detective";
var score = 1;
var subscore = 0;
var metadata = { "map": "space_station"};
await client.writeTournamentRecord(session, tournamentName, score, subscore, metadata);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

socket.onnotification = (notification) => {
    const rewardCode = 100;
    switch (notification.code) {
        case rewardCode:
            console.log("Congratulations, you won the tournament!\n%o\n%o", notification.subject, notification.content);
            break;
        default:
            console.log("Other notification: %o:%o\n%o", notification.code, notification.subject, notification.content);
            break;
    }
};

1
2
3
4
5

const result = await client.listNotifications(session, 10);
result.notifications.forEach(notification => {
  console.info("Notification code %o and subject %o.", notification.code, notification.subject);
});
console.info("Fetch more results with cursor:", result.cacheable_cursor);