Plugin

Prev Next

Available in Classic and VPC

The Plug-in server provides a variety of features to help game developers make their games more rich and diverse. This document will help you understand the main features and benefits of the Plug-in server.
This feature is not provided by default and is only available to subscribers. Please subscribe through the customer center.

Its main features are as follows:

  • Statistics query
  • Leaderboard
  • Friend management
  • Push
  • Data store
  • External payment (Xsolla, PlayUs, MyCard, Danal, etc.)
  • External payment item management
  • Identity verification PASS (Korea)
  • Get API usage

Swagger API document

See Swagger API.
gamepot-swagger

After clicking Authorize, you can use it by entering your API key and project ID, and you can test all the features.

View statistics

You can view various statistical information in the game through the Plug-in server. This allows developers to perform various analysis tasks, such as analyzing user behavior and monitoring game progress.

Leaderboard

The leaderboard is an important feature that promotes competition between users in the game and increases the sense of accomplishment. Users can compare their performance with other users through the leaderboard and check their ranking in the game. This plays a big role in motivating users and increasing their immersion in the game.

Main features and advantages

  • Performance comparison: Users can compare their in-game performance with other users through the leaderboard. This allows them to objectively evaluate their skills and progress.
  • Competition promotion: The leaderboard promotes competition between users. To reach the top ranks, users will invest more time and effort into the game.
  • Goal setting: The leaderboard presents users with specific goals to achieve. For example, the goal could be to overtake the next-ranked user or to break the highest score.
  • Community formation: A community is naturally formed among users with common goals. Users can strengthen their relationships by congratulating each other on their achievements and sharing game strategies.
  • Compensation and incentives: Users who rank high on the leaderboard can be rewarded with in-game rewards or certificates. This increases the user's sense of accomplishment and encourages continued interest in the game.

Implementation method

  1. Data collection: Collect the users' game play data (e.g., scores, levels achieved, etc.).
  2. Sorting and ranking: Sort and rank users' performance based on the collected data. Various sorting algorithms can be used in this process.
  3. Leaderboard update: Update the leaderboard at a set interval (e.g., daily, weekly, monthly). It is also possible to build a system that updates in real time.
  4. User interface: Provide an intuitive user interface so that users can easily check the leaderboard and know their ranking.
  5. Security and fraud prevention: The leaderboard system requires security measures to prevent fraud. For example, there is a feature that detects and eliminates abnormal scores.

The leaderboard system is an effective way to enhance the competitive element of the game and promote interaction between users. Developers can maximize the excitement of their games and encourage long-term user engagement through the leaderboard.

Friend management

It provides a feature that allows users to add and manage friends in the game. This can promote social interaction and help build in-game communities.

Push

Push notifications are a feature that delivers notifications to users within a game. This allows users to check important events that occur in the game in real time. Push notifications can be used in various forms, including in-game notifications, event notifications, and warning messages.

Data store

Data store is a system that provides the ability to store, manage, and retrieve various data generated in the game. It plays a very important role in the game development process and comprehensively covers various information such as game progress, user settings, and performance records. Efficient use of data stores can greatly improve game stability and user experience.

Main features and advantages

  1. Data storage and management: Store and manage users' game progress, settings, item possession status, etc. This allows users to restore their previous progress exactly when they restart the game after stopping it.

  2. Real-time data synchronization: Data synchronization between multiple users is important in multiplayer games. The data store synchronizes data in real time to provide a consistent gaming experience for all users.

  3. Data analysis and statistics: Analyze various data generated in the game to understand user behavior, the efficiency of the in-game economic system, and the popularity of items. This allows developers to discover areas for improvement in the game and improve the user experience.

  4. Security and stability: The data store ensures the stability and security of user data. Data is encrypted and stored, and is protected from unauthorized access. It also provides a backup and recovery system to prevent data loss.

  5. Flexible data modeling: Developers can design a data model to meet the requirements of the game and can easily modify and expand it as needed. This allows for flexible management of the data store as the game evolves.

  6. Efficient resource management: When using a cloud-based data store service, you can efficiently manage server resources. Resources are automatically adjusted according to usage, allowing you to achieve cost efficiency and performance optimization at the same time.

Use cases

  • Storage of progress: When the user stops and then resumes the game, the previously acquired items, levels, locations, etc. are accurately restored.
  • Storage of settings: Save the user's personal in-game settings (e.g., sound level, graphics settings, etc.) and apply them when the game is restarted.
  • Leaderboard: Store the user's performance in the data store and create a leaderboard for all users or friends based on this.
  • In-game economy: Manage users' item purchases and transaction history, and monitor the balance of the in-game economy system.

Data stores are essential for improving the quality of games and the user experience. Game developers can effectively manage game data through the data store and provide users with a seamless game play experience.

Store data

Use the following code to store data in the datastore.
Data is stored in a map format with namespace and key values.

  • C#:
// Create example data
var data = new Dictionary<string, object>();
data["key1"] = "value1";
data["key2"] = "value2";

NBase.putDatastore(
    [NAMESPACE: String],
    [KEY: String],
    [DATA: Dictionary<string, object>],
    (datastore, error) => {
        if (error != null)
        {
            // failed
        }
        else
        {
            // success
        }   
    });
  • Kotlin:
// Create example data
val data = MutableMapOf<String, Any?>()
data["key1"] = "value1"
data["key2"] = "value2"

NBase.putDatastore([NAMESPACE: String], [KEY: String], [DATA: MutableMapOf<String, Any?>]) { datastore, e ->
    if (e != null) {
        // failed
    } else {
        // success
    }
}
  • Java:
// Create example data
Map<String, Object> data = new HashMap<>();
data.put("key1", "value1");
data.put("key2", "value2");

NBase.INSTANCE.putDatastore([(String)NAMESPACE], [(String)KEY], [(Map<String, Object>)DATA]) { datastore, e ->
    if (e != null) {
        // failed
    } else {
        // success
    }
    return null;
});
  • Swift:
// Create example data
var data: [String: Any] = [:]
data["key1"] = "value1"
data["key2"] = "value2"

NBase.putDatastore(namespace: [NAMESPACE: String], key: [KEY: String], data: [data: [String: Any]]) { result in
    switch result {
    case let .success(data):
        if let data = data {
            // success
        } else {
            // data is nil
        }
    case let .failure(error):
        // failed
    }
}
  • Objective-C:
// Create example data
NSMutableDictionary *data = [NSMutableDictionary dictionary];
data[@"key1"] = @"value1";
data[@"key2"] = @"value2";

[NBaseBridge.shared putDatastore:[NAMESPACE: String] key:[KEY: String] data:[data: NSDictionary] :^(NSDictionary * _Nullable result, NSError * _Nullable error) {
    if (error) {
        // failed
    } else {
        // success
    }
}];

Search data

Use the following code to query multiple matching datastores.

  • C#:
NBase.getDatastores(
    [NAMESPACE: String],
    (datastores, error) => {
        if (error != null)
        {
            // failed
        }
        else
        {
            // success
        } 
    });
  • Kotlin:
NBase.getDatastores([NAMESPACE: String]) { datastores, e ->
    if (e != null) {
        // failed
    } else {
        // success
    }
}
  • Java:
NBase.INSTANCE.getDatastores([(String)NAMESPACE], (datastores, e) -> {
    if (e != null) {
        // failed
    } else {
        // success
    }
    return null;
});
  • Swift:
NBase.getDatastores(namespace: [NAMESPACE: String]) { result in
    switch result {
    case let .success(data):
        if let data = data {
            // success
        } else {
            // data is nil
        }
    case let .failure(error):
        // failed
    }
}
  • Objective-C:
[NBaseBridge.shared getDatastores:[NAMESPACE: String] :^(NSDictionary * _Nullable result, NSError * _Nullable error) {
    if (error) {
        // failed
    } else {
        // success
    }
}];

Use the following code to query a datastore with a specific matching namespace and key value.

  • C#:
NBase.getDatastore(
    [NAMESPACE: String],
    [KEY: String],
    (datastore, error) => {
        if (error != null)
        {
            // failed
        }
        else
        {
            // success
        } 
    });
  • Kotlin:
NBase.getDatastore([NAMESPACE], [KEY]) { datastore, e ->
    if (e != null) {
        // failed
    } else {
        // success
    }
}
  • Java:
NBase.INSTANCE.getDatastore([NAMESPACE], [KEY], (datastore, e) -> {
    if (e != null) {
        // failed
    } else {
        // success
    }
    return null;
});
  • Swift:
NBase.getDatastore(namespace: [NAMESPACE: String], key: [KEY: String]) { result in
    switch result {
    case let .success(data):
        if let data = data {
            // success
        } else {
            // data is nil
        }
    case let .failure(error):
        // failed
    }
}
  • Objective-C:
[NBaseBridge.shared getDatastore:[NAMESPACE: String] key:[KEY: String] :^(NSDictionary * _Nullable result, NSError * _Nullable error) {
    if (error) {
        // failed
    } else {
        // success
    }
}];

Delete data

Use the following code to delete data stored in the datastore.

  • C#:
NBase.deleteDatastore(
    [NAMESPACE: String],
    [KEY: String],
    (datastore, error) => {
        if (error != null)
        {
            // failed
        }
        else
        {
            // success
        }   
    });
  • Kotlin:
NBase.deleteDatastore([NAMESPACE: String], [KEY: String]) { datastore, e ->
    if (e != null) {
        // failed
    } else {
        // success
    }
}
  • Java:
NBase.INSTANCE.deleteDatastore([(String)NAMESPACE], [(String)KEY], (datastore, e) -> {
    if (e != null) {
        // failed
    } else {
        // success
    }
    return null;
});
  • Swift:
NBase.deleteDatastore(namespace: [NAMESPACE: String], key: [KEY: String]) { result in
    switch result {
    case let .success(data):
        if let data = data {
            // success
        } else {
            // data is nil
        }
    case let .failure(error):
        // failed
    }
}
  • Objective-C:
[NBaseBridge.shared deleteDatastore:[NAMESPACE: String] key:[KEY: String] :^(NSDictionary * _Nullable result, NSError * _Nullable error) {
    if (error) {
        // failed
    } else {
        // success
    }
}];

Item management for external payment

It provides management features for items purchased through external payment. This feature allows developers to conveniently purchase, distribute, and manage external payment items.

Identity verification PASS (Korea)

For games that are serviced in Korea, we provide an identity verification feature in accordance with legal requirements. This allows users to play games safely and ensures that developers comply with regulations.
This feature is provided in the form of a webview, and it can be used by adding the self-authentication key value issued by Danal to the dashboard and then accessing it with the SDK or web.

Identity verification in Unity

NBaseSDK.NBase.openIdentity((status, error) => {
    Debug.Log("result: " + status);
}

Identity verification on web

After integrating with the existing JavaScript SDK, it can be used as follows:

GP.Identity('61d075b0aa289337e4c71e89',{userId: "userId"},function(resp) {
  if(resp.success) {
    alert(resp.orderId);  // You can import the verification result to Server To Server with orderId.
  } else {
    alert(resp.error);
  }
})

Get API usage

It provides a feature that allows you to query API calls and usage through the Plug-in server. This allows developers to monitor the performance of the system and perform optimization work as needed.