One Game Marketplace to Integrate Them All

Simply integrate marketplace functionality into your games, and brand game NFT items as “limited editions” and “special offers”.

Selling game items effectively and efficiently can directly boost the health of games. READYgg has built the infrastructure to guide and support games, F2P games in particular, to stimulate player purchases. Ready’s Store module provides developers with tons of customization, implementation options, testing, and fine-tuning support, which apply to NFT items alongside regular items. Let’s talk about some in-game merchandising strategies and how to integrate them with Ready’s SDK.

Built-In NFT Functionality

Because NFT items were integrated into the READYgg SDK from the get-go, all NFT needs have been thought of, integrated, and accounted for. This includes rarity, player wallets, currency, blockchain-based transactions, and gas fees.

Let’s work from the bottom up. All NFT transitions are based on blockchain, and the NFTs are even infused with the $RDYX blockchain-based token using fuseblock technology.

Before we continue: a word about blockchain

Blockchain is a term that usually refers to a specific chain. Choosing one single chain limits developer reach, and locks everyone in to rely on the security and utility of a single network. We don’t think this model allows for an ideal player or developer experience, so we made our infrastructure chain agnostic.

Games built on READYgg tech are built not on Layer 1 or 2, but on Layer 0, a layer that is underneath it all, allowing for complete interoperability and fluidity across chains, and player account abstraction, allowing developers and players alike to truly own their data without being beholden to one blockchain.

Now that this essential piece of Ready’s working tech is clear, let’s talk about how NFT minting works with Fuseblocks.

Fuseblock Minting

Fuseblock minting is achieved with the following code:

{
    "success": {
        "code": 200,
        "message": "Success",
        "status": "MINT_SUCCESS",
        "details": [
            {
                "item_id": UUID,
            }
        ]
    }
}

Even though READYgg is chain agnostic, layer 2 solutions such as Polygon are used for transaction scaling and gas fee elimination.

The player certainly does not see any of the on-chain transactions and does not pay for gas. The player will be prompted with a pop-up requesting that they set up a wallet for their first-ever NFT item (the player will be able to use the same wallet for any future NFT purchases in any game in the ecosystem), and all of the chain transactions occur instantly in the background.

Wallet generation is achieved with the following code:

{
    "success": {
        "code": 200,
        "message": "Success",
        "status": "WALLET_CREATED",
        "details": [
            {
                "wallet_public_key": UUID,
            }
        ]
    }
}

When you offer a collection of NFTs for sale, there will be a limited number of generated collectibles. On Ready’s Store module, you can set the number of NFTs available for purchase to match the number left in existence. Once an NFT collection is sold out, it can disappear from the inventory to make way for new, more relevant collections for players to purchase. This integrated Rarity is built into the framework of the NFT sale, adding an element of urgency that can be used for effective player marketing.

Flexible Pricing

The Store module gives developers complete flexibility when it comes to item pricing. This includes price listing in multiple currencies and featured discounts, rare offers, and limited-time deal scheduling. These pricing techniques can be placed strategically to stimulate better user experiences and higher game monetization. More on how to maximize the potential of rare offers and limited-time deals below 👇

Effective User Interface

One of the key components of your store is how users interact with it. At the end of the day, the entire reason you have an in-game store is to allow users to make purchases as painlessly and happily as possible. For this, you need the proper UI elements in place.

One of the most important factors for an effective store is proper organization. Imagine a Walmart with no signage, or clothing racks packed with women’s, men’s, children’s, and baby clothing all mixed together in a mess. No one wants to go through the time and trouble of searching blindly through a poorly organized store.

The key to organization is proper filters and tags. Help your players make you money! It’s as simple as identifying categories that your players will find helpful, interesting, and even enticing.

There are a few options for retrieving Store Offer data.

Retrieve offers via tags:

using System.Collections.Generic;
using RGN.Modules.Store;

namespace SomeNamespace
{
    internal sealed class SomeClass
    {
        public async void GetStoreOffersAsync()
        {
            var tags = new List<string> { "guns", "rifles" };
            var storeOffers = await StoreModule.I.GetByTagsAsync(tags);
        }
    }
}

Retrieve offers by timestamp:

[Serializable]
public class TimeInfo : IEquatable<TimeInfo>
{
    public bool hasStart;
    public long start;
    public bool hasEnd;
    public long end;
    public bool hasInterval;
    public long intervalDuration;
    public long intervalDelay;
}

Query timestamped items:

using RGN;
using RGN.Modules.Store;
using System;
using System.Collections.Generic;

namespace SomeNamespace
{
    internal sealed class GetStoreOffersByTimestamp
    {
        public async void GetStoreOffersForCurrentAppAsync()
        {
            DateTime dateTime = DateTime.Now;
            List<StoreOffer> storeOffers = await StoreModule.I.GetByTimestampAsync(
                RGNCore.I.AppIDForRequests, dateTime);
        }
    }
}

Retrieve offers with virtual item data:

using RGN.Modules.Store;
using RGN.Modules.VirtualItems;
using System;
using System.Collections.Generic;

namespace SomeNamespace
{
    internal sealed class GetStoreOffersWithVirtualItemsData
    {
        public async void GetStoreOffersForCurrentAppAsync()
        {
            DateTime dateTime = DateTime.Now;
            List<StoreOffer> storeOffers =
                await StoreModule.I.GetWithVirtualItemsDataForCurrentAppAsync(20);
            for (int i = 0; i < storeOffers.Count; ++i)
            {
                StoreOffer storeOffer = storeOffers[i];
                var storeOfferItems = storeOffer.GetVirtualItems();
                for (int j = 0; j < storeOfferItems.Count; ++j)
                {
                    VirtualItem virtualItem = storeOfferItems[j];
                    UnityEngine.Debug.Log(virtualItem.name);
                }
            }
        }
    }
}

Marketing Your NFT Items

The ability to list NFT items alongside regular items in your in-game store means that you get to market the NFT items as the next tier of game items. Listing these as “limited editions” or “special offers” is especially effective in making them enticing in the eyes of your players, and the NFT’s rarity and uniqueness can be used to add a sense of urgency by helping players understand that these items will not be offered for sale again. This is an “opportunity only for the next 20 days”, or “there will only ever be 100 of these items”.

The concept of NFT ownership may also be an effective tool for making these items more attractive, but this concept may be more foreign to your players, seeing as digital ownership is still not entirely tangible. As your game gains more traction and players experience the benefits of NFT ownership and utility (cross-game functionality or player avatar placement, for example), ownership may shift to a stronger selling point.

One of the unique characteristics of the READYgg ecosystem is that NFT items are not only listed alongside regular in-game items but are also bought using the same currency as regular items — in-game hard currency. The hard-currency game standard for NFTs is also the key to getting your games listed on Apple’s App Store and the Google Play Store. More on that here.

Players purchase single virtual items via the following code:

using System.Collections.Generic;
using RGN.Modules.Store;
using RGN.Modules.VirtualItems;

namespace SomeNamespace
{
    internal sealed class PurchaseVirtualItems
    {
        public async void BuyVirtualItemAsync(VirtualItem virtualItem)
        {
            List<string> itemsToPurchase =
                new List<string>() { virtualItem.id };
            var purchaseResult =
                await StoreModule.I.BuyVirtualItemsAsync(itemsToPurchase);
        }
    }
}

Players purchase virtual item collections via the following code:

using RGN.Modules.Store;

namespace SomeNamespace
{
    internal sealed class PurchaseStoreOffer
    {
        public async void BuyStoreOfferAsync(string storeOfferId)
        {
            var purchaseResult =
                await StoreModule.I.BuyStoreOfferAsync(storeOfferId);
        }
    }
}

The Store to Integrate Them All

The READYgg ecosystem is not only built on Unity, but also to unify player experiences by solving major barriers in the gaming space by providing developers with the tech to support integrated and intuitive user experiences, as well as a unified space for all web2 and web3 players. The Store module is an integral part of this, bridging the gap between web2 and web3 by listing the two side by side, and putting NFT items in a context web2 users can understand and appreciate. Unified user wallets and interoperable cross-game NFT items add more unity to the package.

Discover the power of READYgg by opening a developer account for free at dev.ready.gg and read up on the full SDK documentation for more integration info.