pley.h

 
#ifndef _PLEY_SDK_H_
#define _PLEY_SDK_H_
 
#if defined(_WIN32)
    #define PLEY_SDK_API __declspec(dllexport)
#elif defined(__GNUC__)
    #define PLEY_SDK_API __attribute__((visibility("default")))
#else
    #define PLEY_SDK_API
#endif
 
#if EMSCRIPTEN
    #include <emscripten.h>
#endif
 
#if EMSCRIPTEN
    #define PLEY_KEEPALIVE EMSCRIPTEN_KEEPALIVE
#else
    #define PLEY_KEEPALIVE
#endif
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdint.h>
#include <string.h>
#ifndef __cplusplus
#include <stdbool.h>
#endif

typedef int32_t PleyResult;
 
enum {
    PLEY_RESULT_OK = 0,
 
    PLEY_RESULT_INTERNAL_ERROR = -1,
    PLEY_RESULT_INVALID_ARGUMENTS = -2,
    PLEY_RESULT_UNSUPPORTED_METHOD = -3,
    PLEY_RESULT_NOT_ALLOWED_METHOD = -4,
 
    PLEY_RESULT_SDK_ALREADY_CREATED = -100,
    PLEY_RESULT_SDK_NOT_INITIALIZED = -101,
    PLEY_RESULT_SDK_ALREADY_INITIALIZED = -102,
    PLEY_RESULT_SDK_NOT_CONNECTED = -103,
    PLEY_RESULT_SDK_HOST_DISCONNECTED = -104,
    PLEY_RESULT_SDK_REPORT_GAME_LOADED_CALLED_MULTIPLE_TIMES = -105,
    PLEY_RESULT_SDK_CONNECTION_CANCELED = -107,
 
    PLEY_RESULT_FLK_FILE_NOT_FOUND = -200,
    PLEY_RESULT_FLK_FILE_TOO_BIG = -201,
    PLEY_RESULT_FLK_BUFFER_TOO_SMALL = -202,
    PLEY_RESULT_FLK_CLOUD_STORAGE_CONFLICT = -203,
 
    PLEY_RESULT_PMK_PAYMENT_CANCELLED_BY_USER = -400,
    PLEY_RESULT_PMK_PAYMENT_FAILED = -401,
    PLEY_RESULT_PMK_PRODUCT_NOT_FOUND = -402,
    PLEY_RESULT_PMK_PAYMENT_ALREADY_IN_PROGRESS = -403,
    PLEY_RESULT_PMK_CONSUMED_ENTITLEMENT_ALREADY_CONSUMED = -405,
    PLEY_RESULT_PMK_CONSUMED_ENTITLEMENT_NOT_FOUND = -406,
 
    PLEY_RESULT_AUK_ALREADY_LOGGED_IN = -600,
    PLEY_RESULT_AUK_USER_DID_NOT_SIGN_UP = -601,
 
    PLEY_RESULT_ATK_ALREADY_INITIALIZED = -700,
    PLEY_RESULT_ATK_EVENT_ALREADY_REPORTED = -701,
    PLEY_RESULT_ATK_PROPERTY_NOT_FOUND = -702,
    
    PLEY_RESULT_ATK_GAME_LOADED_ALREADY_REPORTED = -800,
    PLEY_RESULT_ATK_GAME_USER_INTERACTED_ALREADY_REPORTED = -801,
    PLEY_RESULT_ATK_GAME_USER_ENGAGED_ALREADY_REPORTED = -802,
 
    PLEY_RESULT_ADK_UNKNOWN = -900,
    PLEY_RESULT_ADK_ADS_DISABLED = -901,
    PLEY_RESULT_ADK_NOT_READY = -902,
    PLEY_RESULT_ADK_TIMEOUT = -903,
    PLEY_RESULT_ADK_INVALID = -904,
    PLEY_RESULT_ADK_ERROR = -905,
    PLEY_RESULT_ADK_NO_AD_PRELOADED = -906,
    PLEY_RESULT_ADK_FREQUENCY_CAPPED = -907,
    PLEY_RESULT_ADK_DISMISSED = -908,
    PLEY_RESULT_ADK_ALREADY_SHOWING_AD = -909,
 
    PLEY_RESULT_CON_PLEY_CONNECT_DISABLED = -1000,
};

 
typedef void(*PleyBasicCB)(
    PleyResult result,
    void*       data
);
 
typedef void(*PleyLogCB)(
    int32_t     level,
    const char* location,
    const char* message,
    void*       callback_data
);
 
typedef struct PleyGameArgument {
    char        name[256];
    const char* value;
} PleyGameArgument;
 
typedef void(*PleyOnGameActiveStatusChangedCB)(
    bool  game_active,
    void* callback_data
);
 
typedef struct PleyKeyValue {
    char key[64];
    char value[1024];
} PleyKeyValue;
 
typedef void(*PleyOnGamePauseRequestCB)(
    void* callback_data
);
 
typedef void(*PleyOnGameUnpauseRequestCB)(
    void* callback_data
);
 
enum {
    PLEY_LOG_LEVEL_DEBUG = 0,
    PLEY_LOG_LEVEL_INFO,
    PLEY_LOG_LEVEL_WARNING,
    PLEY_LOG_LEVEL_ERROR
};
 
typedef int32_t PleyLogLevel;
 
typedef struct PleyCore {
    bool         (*is_initialized)();
    PleyResult   (*get_game_arguments)(const PleyGameArgument** arguments, int32_t* arguments_len);
    PleyResult   (*set_on_game_active_status_changed)(PleyOnGameActiveStatusChangedCB callback, void* callback_data);
    PleyResult   (*is_game_active)(bool* is_game_active);
    PleyResult   (*show_save_bookmark_prompt)();
    PleyResult   (*exit_game)();
    PleyResult   (*crash_game)(const char* error_message);
    PleyResult   (*restart_game)();
    void         (*set_on_log)(PleyLogCB callback, void* callback_data);
    PleyLogLevel (*get_min_log_level)();
    void         (*set_min_log_level)(PleyLogLevel level);
    bool         (*is_log_standard_output_enabled)();
    void         (*set_log_standard_output_enabled)(bool enabled);
    PleyResult   (*set_support_dialog_custom_fields)(const PleyKeyValue* fields, int32_t fields_len);
    PleyResult   (*get_stack_trace)(const char** stack_trace);
    PleyResult   (*set_on_game_pause_request_callback)(PleyOnGamePauseRequestCB callback, void* callback_data);
    PleyResult   (*set_on_game_unpause_request_callback)(PleyOnGameUnpauseRequestCB callback, void* callback_data);
    PleyResult   (*show_controls_menu)();
    PleyResult   (*show_cookie_consent)();
    PleyResult   (*show_support_window)();
    PleyResult   (*get_playable_location)(const char** runner);
    PleyResult   (*get_device_language)(const char** lang);
} PleyCore;


 
typedef struct PleyFileKit {
    PleyResult (*get_file_size)(const char* filepath, uint32_t* file_size);
    void       (*read_file)(const char* filepath, uint8_t* buffer, uint32_t buffer_len, PleyBasicCB callback, void* callback_data);
    PleyResult (*preload_file)(const char* filepath);
    PleyResult (*get_cloud_storage_path)(const char** ptr);
    void       (*sync_cloud_storage)(PleyBasicCB callback, void* callback_data);
    PleyResult (*start_file_queue)();
    PleyResult (*stop_file_queue)();
    PleyResult (*get_file_url)(const char* filepath, const char** url);
} PleyFileKit;


typedef struct PleyPMKPrice {
    int32_t amount_dividend;
    int32_t amount_divisor;
    char    currency_iso_4217[3];
} PleyPMKPrice;
 
typedef struct PleyPMKProduct {
    const char*  id;
    const char*  name;
    PleyPMKPrice price;
} PleyPMKProduct;
 
typedef struct PleyPMKEntitlement {
    const char* entitlement_id;
    const char* product_id;
} PleyPMKEntitlement;
 
typedef void(*PleyPMKRequestPaymentCB)(
    PleyResult  error,
    const char* entitlement_id,
    void*       data
);
 
typedef void(*PleyPMKGetProductsCB)(
    PleyResult            result,
    const PleyPMKProduct* products,
    int32_t               products_len,
    const PleyResult*     results,
    int32_t               results_len,
    void*                 data
);
 
typedef void(*PleyPMKGetEntitlementsCB)(
    PleyResult                result,
    const PleyPMKEntitlement* entitlements,
    int32_t                   entitlements_len,
    void*                     data
);
 
typedef void(*PleyPMKDangerouslyConsumedEntitlementCB)(
    PleyResult                result,
    const PleyResult*         results,
    int32_t                   results_len,
    void*                     data
);
 
typedef struct PleyPaymentsKit {
    void (*get_products)(const char** product_ids, int32_t product_ids_len, PleyPMKGetProductsCB callback, void* callback_data);
    void (*request_payment)(const char* product_id, const char* invoice_email, PleyPMKRequestPaymentCB callback, void* callback_data);
    void (*get_entitlements)(PleyPMKGetEntitlementsCB callback, void* callback_data);
    void (*dangerously_consume_entitlement)(const char** entitlement_ids, int32_t entitlement_ids_len, PleyPMKDangerouslyConsumedEntitlementCB callback, void* callback_data);
} PleyPaymentsKit;

 

typedef struct PleyResolution {
    int32_t width;
    int32_t height;
} PleyResolution;
 
typedef void(*PleyPFKViewportSizeChangedCB)(
    PleyResolution resolution,
    void* callback_data
);
 
typedef void(*PleyPFKFullscreenChangedCB)(
    bool fullscreen,
    void* callback_data
);
 
typedef struct PleyPerformanceKit {
    PleyResult (*get_viewport_size)(PleyResolution* resolution);
    PleyResult (*get_common_resolutions)(const PleyResolution** resolutions, int32_t* resolutions_len);
    PleyResult (*set_on_viewport_size_changed)(PleyPFKViewportSizeChangedCB callback, void* callback_data);
    PleyResult (*set_aspect_ratio)(float aspect_ratio);
    PleyResult (*set_game_resolution)(const PleyResolution* resolution, bool match_common, bool cap_to_screen);
    PleyResult (*get_game_resolution)(PleyResolution* resolution);
    PleyResult (*get_is_fullscreen)(bool* is_fullscreen);
    PleyResult (*set_on_fullscreen_changed)(PleyPFKFullscreenChangedCB callback, void* callback_data);
    PleyResult (*set_fullscreen)(bool value);
} PleyPerformanceKit;


 
typedef void(*PleyAUKRequestSignUpCB)(
    PleyResult result,
    void*      callback_data
);
 
typedef void(*PleyAUKSignUpCB)(
    void* callback_data
);
 
typedef struct PleyAuthKit {
    PleyResult   (*get_game_user_id)(const char** id);
    PleyResult   (*dangerously_get_game_user_id)(const char** id);
    PleyResult   (*get_username)(const char** username);
    PleyResult   (*get_session_token)(const char** session_token);
    PleyResult   (*is_user_logged_in)(bool* is_logged_in);
    void         (*request_sign_up)(bool force_sign_up, PleyAUKRequestSignUpCB callback, void* callback_data);
    PleyResult   (*set_on_sign_up_callback)(PleyAUKSignUpCB callback, void* callback_data);
} PleyAuthKit;


typedef int32_t PleyAccountLinkResult;
 
enum {
    PLEY_ACCOUNT_LINK_RESULT_OK = 0,
    PLEY_ACCOUNT_LINK_RESULT_CANCELED = 1,
    PLEY_ACCOUNT_LINK_RESULT_FAILED = 2,
};
typedef struct PleyConnectionKit {
    PleyResult   (*get_account_link_code)(const char** account_link_code);
    void         (*set_account_link_result)(PleyAccountLinkResult result, PleyBasicCB callback, void* callback_data);
    void         (*show_qr_code)(PleyBasicCB callback, void* callback_data);
} PleyConnectionKit;


 
typedef int32_t PleyCurrencyType;
 
enum {
    PLEY_CURRENCY_TYPE_NORMAL = 0,
    PLEY_CURRENCY_TYPE_PREMIUM = 1,
};
 
typedef struct PleyCurrency {
    const char* name;
    int32_t amount;
    PleyCurrencyType type;
} PleyCurrency;
 
typedef struct PleyATKConfig {
    const char* custom_user_id;
    bool cross_platform_user;
    int32_t current_level;
    const char* application_version;
    const char* username;
    const PleyCurrency* currencies;
    int32_t currencies_len;
} PleyATKConfig;
 
typedef int32_t PleyVariantType;
 
enum {
    PLEY_VARIANT_TYPE_INT = 0,
    PLEY_VARIANT_TYPE_LONG = 1,
    PLEY_VARIANT_TYPE_FLOAT = 2,
    PLEY_VARIANT_TYPE_DOUBLE = 3,
    PLEY_VARIANT_TYPE_STRING = 4,
    PLEY_VARIANT_TYPE_BOOL = 5,
};
 
typedef struct PleyVariant {
    void* value;
    PleyVariantType type; 
} PleyVariant;
 
typedef struct PleyAnalyticsParameter {
    const char* name;
    PleyVariant variant; 
} PleyAnalyticsParameter;
 
typedef struct PleyATKScene {
    char id[256];
    char name[256];
} PleyATKScene;
 
typedef void(*PleyATKGetUserPropertyCB)(
    PleyResult result,
    const char* name,
    const PleyVariant* variant,
    void* callback_data
);
 
typedef struct PleyAnalyticsKit {
    PleyResult (*initialize_analytics)(const PleyATKConfig* config);
    PleyResult (*is_analytics_initialized)(bool* is_initialized);
    PleyResult (*game_loaded)();
    PleyResult (*user_interacted)();
    PleyResult (*user_engaged)();
    PleyResult (*scene_changed)(const PleyATKScene* new_scene);
    PleyResult (*tutorial_started)();
    PleyResult (*tutorial_advanced)(const char* step);
    PleyResult (*tutorial_completed)();
    PleyResult (*tutorial_skipped)();
    PleyResult (*level_advanced)(const int32_t level);
    PleyResult (*currency_spent)(const char* name, const int32_t amount, PleyCurrencyType type, const int32_t* new_balance, const char* source);
    PleyResult (*currency_gained)(const char* name, const int32_t amount, PleyCurrencyType type, const int32_t* new_balance, const char* source);
    PleyResult (*store_opened)();
    PleyResult (*offer_shown)(const char* offer);
 
    PleyResult (*loading_start)();
    PleyResult (*loading_stop)();
 
    PleyResult (*gameplay_start)();
    PleyResult (*gameplay_stop)();

    PleyResult (*custom_event)(const char* name, PleyAnalyticsParameter* parameters, int32_t parameters_len);
    PleyResult (*set_user_property)(const char* name, const PleyVariant* variant);
    PleyResult (*remove_user_property)(const char* name);
    PleyResult (*clear_all_user_properties)();
} PleyAnalyticsKit;


 
typedef int32_t PleyAdType;
 
enum {
    PLEY_AD_TYPE_INTERSTITIAL = 0,
    PLEY_AD_TYPE_REWARD  = 1,
};
 
typedef void(*PleyADKShowAdCB)(
    PleyResult result,
    void* callback_data
);
 
typedef void(*PleyADKCanShowAdCB)(
    PleyResult result,
    bool can_show_ad,
    void* callback_data
);
 
typedef struct PleyAdsKit {
    void (*show_ad)(PleyAdType ad_type, PleyADKShowAdCB callback, void* callback_data);
    void (*can_show_ad)(PleyAdType ad_type, PleyADKCanShowAdCB callback, void* callback_data);
} PleyAdsKit;


typedef void (*PleyDevStateCB)(int state, const char *msg);
typedef struct PleyUnityConf {
    const char unity_version[64];
} PleyUnityConf;
 
typedef struct PleyInitParams {
    PleyUnityConf* unity_conf;
#if !EMSCRIPTEN
    PleyDevStateCB dev_state_cb;
    const char *   dev_room_id;
#endif
} PleyInitParams;
 
typedef struct Pley {
    PleyCore*             core;
    PleyAuthKit*          auth_kit;
    PleyPaymentsKit*      payments_kit;
    PleyPerformanceKit*   performance_kit;
    PleyFileKit*          file_kit;
    PleyConnectionKit*    connection_kit;
    PleyAnalyticsKit*     analytics_kit;
    PleyAdsKit*           ads_kit;
} Pley;

typedef void (*PleyDestroy)(Pley* pley);
 
typedef void(*PleyInitCB)(
    PleyResult  result,
    Pley*       pley,
    PleyDestroy destroy,
    void*        callback_data
);

PLEY_SDK_API PleyResult pley_init(
    PleyInitParams* params,
    PleyInitCB      callback,
    void*           callback_data
);

PLEY_SDK_API bool pley_result_is_ok(PleyResult res);

PLEY_SDK_API bool pley_result_is_error(PleyResult res);

PLEY_SDK_API const char *pley_sdk_get_version();

 
#ifdef __cplusplus
}
#endif
 
#endif