@arkadiuminc/sdk 2.48.0 → 2.50.0

package/dist/pkg/api/features/nakama/nakama-provider.d.ts

@@ -7,19 +7,17 @@ import { ApiAccount } from '@heroiclabs/nakama-js/dist/api.gen';
 export declare type RpcGetNkUserByEagleIdParams = {
     EagleUserId: string | number;
 };
-export declare type RpcGetNkUserByEagleUserNameParams = {
-    EagleUserName: string | number;
-};
 export interface RpcGetNkUserResponse {
     CustomId: string;
     UserId: string;
     UserName: string;
-    message: string | null;
+    Message: string | null;
 }
 export interface NakamaContext {
     client: NakamaClient | null;
     session: NakamaSession | null;
     socket: NakamaSocket | null;
+    gameId?: string;
 }
 export declare class NakamaProvider {
     private host;
@@ -31,17 +29,18 @@ export declare class NakamaProvider {
     private env;
     private gameId;
     private _isConnected;
+    private _gameCtx;
     private RPC_GET_USER_BY_EAGLE_ID;
     constructor(host: IHost, auth: Auth);
     init(env: ApiEnv): void;
     isSupported(): boolean;
-    private getGameId;
     isUserAuthorized(): boolean;
     private getNakamaClient;
     private subscribeToEagleAuthChanges;
     private getNakamaVars;
     private initNakamaSession;
     private initNakamaSessionViaEagle;
+    getGameContext(): Promise<NakamaContext>;
     /**
      * this method is called when the user is logged in
      * CAUTION: this method is called from eagle login status change, therefore it can't throw

package/dist/pkg/api/features/tournaments/index.d.ts

@@ -0,0 +1,72 @@
+import { NakamaService } from '../nakama/nakama-service';
+import { NakamaProvider } from '../nakama/nakama-provider';
+import { RpcProvider } from '../../core/rpc';
+
+export declare type Tournament = {
+    id?: string;
+    title?: string;
+    description?: string;
+    duration?: number;
+    category?: number;
+    sortOrder?: number;
+    size?: number;
+    maxSize?: number;
+    maxNumScore?: number;
+    canEnter?: boolean;
+    nextReset?: number;
+    metadata?: object;
+    createTime?: number;
+    startTime?: number;
+    endTime?: number;
+    startActive?: number;
+    endActive?: number;
+};
+export declare type TournamentEntry = {
+    ownerId?: string;
+    rank?: number;
+    score?: number;
+    subscore?: number;
+    /** The username of the score owner, if the owner is a user. */
+    username?: string;
+    /** The number of submissions to this score record. */
+    numScore: number;
+    /** The maximum number of score updates allowed by the owner. */
+    maxNumScore: number;
+    metadata?: object;
+};
+export declare type SubmitTournamentScoreParams = {
+    tournamentId: string;
+    score: number;
+    subscore?: number;
+    metadata?: object;
+};
+export declare class TournamentsArena extends NakamaService {
+    private RPC_GET_TOURNAMENT_LIST_BY_CONTEXT;
+    private RPC_JOIN_TOURNAMENT;
+    private RPC_SUBMIT_SCORE_TO_TOURNAMENT;
+    constructor(nakamaProvider: NakamaProvider, rpcProvider: RpcProvider);
+    protected onSocketConnectionChanged(isConnected: boolean): void;
+    getTournaments(): Promise<Tournament[]>;
+    hasJoinedTournament(tournamentId: string): Promise<boolean>;
+    joinTournament(tournamentId: string): Promise<boolean>;
+    canSubmitScoreToTournament(tournamentId: string): Promise<boolean>;
+    submitTournamentScore(params: SubmitTournamentScoreParams): Promise<boolean>;
+    getTopTournamentEntries(tournamentId: string, top: number): Promise<TournamentEntry[]>;
+    getTournamentUserEntry(tournamentId: string): Promise<TournamentEntry | null>;
+    getTournamentUsersEntries(tournamentId: string, userIds: string[]): Promise<TournamentEntry[]>;
+    getTournamentEntriesAroundUser(tournamentId: string, amount?: number): Promise<TournamentEntry[]>;
+    private mapNakamaTournamentEntryToTournamentEntry;
+}
+export declare class TournamentsGame {
+    private rpcProvider;
+    constructor(rpcProvider: RpcProvider);
+    getTournaments(): Promise<Tournament[]>;
+    hasJoinedTournament(tournamentId: string): Promise<boolean>;
+    joinTournament(tournamentId: string): Promise<boolean>;
+    canSubmitScoreToTournament(tournamentId: string): Promise<boolean>;
+    submitTournamentScore(params: SubmitTournamentScoreParams): Promise<boolean>;
+    getTopTournamentEntries(tournamentId: string, top: number): Promise<TournamentEntry[]>;
+    getTournamentUserEntry(tournamentId: string): Promise<TournamentEntry | null>;
+    getTournamentUsersEntries(tournamentId: string, userIds: string[]): Promise<TournamentEntry[]>;
+    getTournamentEntriesAroundUser(tournamentId: string, amount?: number): Promise<TournamentEntry[]>;
+}

package/dist/pkg/api/features/tournaments/tournaments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/pkg/api/features/wallet/index.d.ts

@@ -14,8 +14,11 @@ export declare class WalletArena implements Wallet {
     private virtualItemGateway;
     private currencySku;
     private isInited;
+    private _isGemsSupported;
     constructor(backendApi: Backend, lifecycle: GameLifecycleArena, rpcProvider: RpcProvider);
     init(env: ApiEnv): Promise<void>;
+    setGemsSupported(isSupported: boolean): void;
+    private isGemsSupported;
     /**
      * Allows querying for the wallet balance
      * @returns the amount of gems in the user wallet
@@ -42,4 +45,5 @@ export declare class WalletGame implements Wallet {
      * @returns true if the spending of the gem amount was successful, false otherwise
      */
     consumeGems(amount: number): Promise<boolean>;
+    isGemsSupported(): Promise<boolean>;
 }

package/dist/pkg/arkadium-arena-sdk.d.ts

@@ -15,6 +15,7 @@ import { FriendsArena } from './api/features/friends';
 import { NotificationsArena } from './api/features/notifications';
 import { ChatArena } from './api/features/chat';
 import { RatingsArena } from './api/features/ratings';
+import { TournamentsArena } from './api/features/tournaments';
 
 import * as MockUserUtils from './api/utils/mockUser';
 /** @hidden */
@@ -35,13 +36,14 @@ export declare class ArkadiumArenaSdk {
     notifications: NotificationsArena;
     chats: ChatArena;
     ratings: RatingsArena;
+    tournaments: TournamentsArena;
     private currentEnv;
     private currentTarget;
     private gamePingSender;
     private gamePingListener;
     $pingNotification: Observable<number>;
     version: string;
-    constructor(backendApi: Backend, host: HostArena, lifecycle: GameLifecycleArena, ads: AdsArena, auth: AuthArena, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena, wallet: WalletArena, debug: DebugProviderArena, supportV1: SupportV1, leaderboard: LeaderboardArena, friends: FriendsArena, notifications: NotificationsArena, chats: ChatArena, ratings: RatingsArena);
+    constructor(backendApi: Backend, host: HostArena, lifecycle: GameLifecycleArena, ads: AdsArena, auth: AuthArena, analytics: AnalyticsApiContract, timeoutTester: TimeoutTesterContract, persistence: PersistenceArena, wallet: WalletArena, debug: DebugProviderArena, supportV1: SupportV1, leaderboard: LeaderboardArena, friends: FriendsArena, notifications: NotificationsArena, chats: ChatArena, ratings: RatingsArena, tournaments: TournamentsArena);
     setEnv(e: ApiEnv): void;
     initialize(env: ApiEnv, isGameSide: boolean, sessionStorage?: SessionStorageType | null): Promise<void>;
     private envDiscoverListener;

package/dist/pkg/arkadium-game-sdk.d.ts

@@ -9,6 +9,7 @@ import { PersistenceGame } from './api/features/persistence';
 import { Wallet, WalletGame } from './api/features/wallet';
 import { HostGame } from './api/features/host';
 import { LeaderboardGame } from './api/features/leaderboard';
+import { TournamentsGame } from './api/features/tournaments';
 
 export declare class ArkadiumGameSdk {
     version: string;
@@ -26,7 +27,8 @@ export declare class ArkadiumGameSdk {
     persistence: PersistenceGame;
     wallet: Wallet;
     leaderboard: LeaderboardGame;
-    constructor({ rpcProvider, backendApi, host, lifecycle, ads, auth, analytics, timeoutTester, persistence, wallet, leaderboard }: {
+    tournaments: TournamentsGame;
+    constructor({ rpcProvider, backendApi, host, lifecycle, ads, auth, analytics, timeoutTester, persistence, wallet, leaderboard, tournaments }: {
         rpcProvider: RpcProvider;
         backendApi: Backend;
         host: HostGame;
@@ -38,6 +40,7 @@ export declare class ArkadiumGameSdk {
         persistence: PersistenceGame;
         wallet: WalletGame;
         leaderboard: LeaderboardGame;
+        tournaments: TournamentsGame;
     });
     initialize(env: ApiEnv, isGameSide: boolean): Promise<void>;
     getEnv(): ApiEnv;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkadiuminc/sdk",
-  "version": "2.48.0",
+  "version": "2.50.0",
   "description": "",
   "keywords": [],
   "main": "dist/pkg/arkadium-sdk.umd.js",