rdiscord_sdk 1.1.0

data/lib/rdiscord_sdk/enums.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Discord
+  module Result
+    Ok = 0
+    ServiceUnavailable = 1
+    InvalidVersion = 2
+    LockFailed = 3
+    InternalError = 4
+    InvalidPayload = 5
+    InvalidCommand = 6
+    InvalidPermissions = 7
+    NotFetched = 8
+    NotFound = 9
+    Conflict = 10
+    InvalidSecret = 11
+    InvalidJoinSecret = 12
+    NoEligibleActivity = 13
+    InvalidInvite = 14
+    NotAuthenticated = 15
+    InvalidAccessToken = 16
+    ApplicationMismatch = 17
+    InvalidDataUrl = 18
+    InvalidBase64 = 19
+    NotFiltered = 20
+    LobbyFull = 21
+    InvalidLobbySecret = 22
+    InvalidFilename = 23
+    InvalidFileSize = 24
+    InvalidEntitlement = 25
+    NotInstalled = 26
+    NotRunning = 27
+    InsufficientBuffer = 28
+    PurchaseCanceled = 29
+    InvalidGuild = 30
+    InvalidEvent = 31
+    InvalidChannel = 32
+    InvalidOrigin = 33
+    RateLimited = 34
+    OAuth2Error = 35
+    SelectChannelTimeout = 36
+    GetGuildTimeout = 37
+    SelectVoiceForceRequired = 38
+    CaptureShortcutAlreadyListening = 39
+    UnauthorizedForAchievement = 40
+    InvalidGiftCode = 41
+    PurchaseError = 42
+    TransactionAborted = 43
+  end
+
+  module CreateFlags
+    Default = 0
+    NoRequireDiscord = 1
+  end
+
+  module LogLevel
+    Error = 1
+    Warn = 2
+    Info = 3
+    Debug = 4
+  end
+
+  module UserFlag
+    Partner = 2
+    HypeSquadEvents = 4
+    HypeSquadHouse1 = 64
+    HypeSquadHouse2 = 128
+    HypeSquadHouse3 = 256
+  end
+
+  module PremiumType
+    None = 0
+    Tier1 = 1
+    Tier2 = 2
+  end
+
+  module ImageType
+    User = 0
+  end
+
+  module ActivityType
+    Playing = 0
+    Streaming = 1
+    Listening = 2
+    Watching = 3
+  end
+
+  module ActivityActionType
+    Join = 1
+    Spectate = 2
+  end
+
+  module ActivityJoinRequestReply
+    No = 0
+    Yes = 1
+    Ignore = 2
+  end
+
+  module Status
+    Offline = 0
+    Online = 1
+    Idle = 2
+    DoNotDisturb = 3
+  end
+
+  module RelationshipType
+    None = 0
+    Friend = 1
+    Blocked = 2
+    PendingIncoming = 3
+    PendingOutgoing = 4
+    Implicit = 5
+  end
+
+  module LobbyType
+    Private = 1
+    Public = 2
+  end
+
+  module LobbySearchComparison
+    LessThanOrEqual = -2
+    LessThan = -1
+    Equal = 0
+    GreaterThan = 1
+    GreaterThanOrEqual = 2
+    NotEqual = 3
+  end
+
+  module LobbySearchCast
+    String = 1
+    Number = 2
+  end
+
+  module LobbySearchDistance
+    Local = 1
+    Default = 2
+    Extended = 3
+    Global = 4
+  end
+
+  module EntitlementType
+    Purchase = 1
+    PremiumSubscription = 2
+    DeveloperGift = 3
+    TestModePurchase = 4
+    FreePurchase = 5
+    UserGift = 6
+    PremiumPurchase = 7
+  end
+
+  module SkuType
+    Application = 1
+    DLC = 2
+    Consumable = 3
+    Bundle = 4
+  end
+
+  module InputModeType
+    VoiceActivity = 0
+    PushToTalk = 1
+  end
+end

data/lib/rdiscord_sdk/version.rb

@@ -0,0 +1,16 @@
+module Discord
+  VERSION = "0.1.1"
+  DISCORD_VERSION = "2"
+  DISCORD_APPLICATION_MANAGER_VERSION = "1"
+  DISCORD_USER_MANAGER_VERSION = "1"
+  DISCORD_IMAGE_MANAGER_VERSION = "1"
+  DISCORD_ACTIVITY_MANAGER_VERSION = "1"
+  DISCORD_RELATIONSHIP_MANAGER_VERSION = "1"
+  DISCORD_LOBBY_MANAGER_VERSION = "1"
+  DISCORD_NETWORK_MANAGER_VERSION = "1"
+  DISCORD_OVERLAY_MANAGER_VERSION = "1"
+  DISCORD_STORAGE_MANAGER_VERSION = "1"
+  DISCORD_STORE_MANAGER_VERSION = "1"
+  DISCORD_VOICE_MANAGER_VERSION = "1"
+  DISCORD_ACHIEVEMENT_MANAGER_VERSION = "1"
+end

data/lib/rdiscord_sdk.rb

@@ -0,0 +1,3 @@
+require "rdiscord_sdk.so"
+require_relative "rdiscord_sdk/version"
+require_relative "rdiscord_sdk/enums"

data/rdiscord_sdk.gemspec

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |spec|
+  spec.name = "rdiscord_sdk"
+  spec.version = "1.1.0"
+  spec.authors = ["Matthew Lyons"]
+  spec.email = ["matthew@nowaffles.com"]
+
+  spec.summary = "Ruby bindings for the Discord Game SDK"
+  spec.homepage = "https://github.com/Speak2Erase/rdiscord_sdk"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib", "ext"]
+  spec.extensions = ["ext/rdiscord_sdk/extconf.rb"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/third-party/include/achievement_manager.cpp

@@ -0,0 +1,98 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "achievement_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class AchievementEvents final {
+public:
+    static void OnUserAchievementUpdate(void* callbackData, DiscordUserAchievement* userAchievement)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->AchievementManager();
+        module.OnUserAchievementUpdate(*reinterpret_cast<UserAchievement const*>(userAchievement));
+    }
+};
+
+IDiscordAchievementEvents AchievementManager::events_{
+  &AchievementEvents::OnUserAchievementUpdate,
+};
+
+void AchievementManager::SetUserAchievement(Snowflake achievementId,
+                                            std::uint8_t percentComplete,
+                                            std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->set_user_achievement(
+      internal_, achievementId, percentComplete, cb.release(), wrapper);
+}
+
+void AchievementManager::FetchUserAchievements(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->fetch_user_achievements(internal_, cb.release(), wrapper);
+}
+
+void AchievementManager::CountUserAchievements(std::int32_t* count)
+{
+    if (!count) {
+        return;
+    }
+
+    internal_->count_user_achievements(internal_, reinterpret_cast<int32_t*>(count));
+}
+
+Result AchievementManager::GetUserAchievement(Snowflake userAchievementId,
+                                              UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement(
+      internal_, userAchievementId, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+Result AchievementManager::GetUserAchievementAt(std::int32_t index,
+                                                UserAchievement* userAchievement)
+{
+    if (!userAchievement) {
+        return Result::InternalError;
+    }
+
+    auto result = internal_->get_user_achievement_at(
+      internal_, index, reinterpret_cast<DiscordUserAchievement*>(userAchievement));
+    return static_cast<Result>(result);
+}
+
+} // namespace discord

data/third-party/include/achievement_manager.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class AchievementManager final {
+public:
+    ~AchievementManager() = default;
+
+    void SetUserAchievement(Snowflake achievementId,
+                            std::uint8_t percentComplete,
+                            std::function<void(Result)> callback);
+    void FetchUserAchievements(std::function<void(Result)> callback);
+    void CountUserAchievements(std::int32_t* count);
+    Result GetUserAchievement(Snowflake userAchievementId, UserAchievement* userAchievement);
+    Result GetUserAchievementAt(std::int32_t index, UserAchievement* userAchievement);
+
+    Event<UserAchievement const&> OnUserAchievementUpdate;
+
+private:
+    friend class Core;
+
+    AchievementManager() = default;
+    AchievementManager(AchievementManager const& rhs) = delete;
+    AchievementManager& operator=(AchievementManager const& rhs) = delete;
+    AchievementManager(AchievementManager&& rhs) = delete;
+    AchievementManager& operator=(AchievementManager&& rhs) = delete;
+
+    IDiscordAchievementManager* internal_;
+    static IDiscordAchievementEvents events_;
+};
+
+} // namespace discord

data/third-party/include/activity_manager.cpp

@@ -0,0 +1,177 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "activity_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+class ActivityEvents final {
+public:
+    static void OnActivityJoin(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoin(static_cast<const char*>(secret));
+    }
+
+    static void OnActivitySpectate(void* callbackData, char const* secret)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivitySpectate(static_cast<const char*>(secret));
+    }
+
+    static void OnActivityJoinRequest(void* callbackData, DiscordUser* user)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityJoinRequest(*reinterpret_cast<User const*>(user));
+    }
+
+    static void OnActivityInvite(void* callbackData,
+                                 EDiscordActivityActionType type,
+                                 DiscordUser* user,
+                                 DiscordActivity* activity)
+    {
+        auto* core = reinterpret_cast<Core*>(callbackData);
+        if (!core) {
+            return;
+        }
+
+        auto& module = core->ActivityManager();
+        module.OnActivityInvite(static_cast<ActivityActionType>(type),
+                                *reinterpret_cast<User const*>(user),
+                                *reinterpret_cast<Activity const*>(activity));
+    }
+};
+
+IDiscordActivityEvents ActivityManager::events_{
+  &ActivityEvents::OnActivityJoin,
+  &ActivityEvents::OnActivitySpectate,
+  &ActivityEvents::OnActivityJoinRequest,
+  &ActivityEvents::OnActivityInvite,
+};
+
+Result ActivityManager::RegisterCommand(char const* command)
+{
+    auto result = internal_->register_command(internal_, const_cast<char*>(command));
+    return static_cast<Result>(result);
+}
+
+Result ActivityManager::RegisterSteam(std::uint32_t steamId)
+{
+    auto result = internal_->register_steam(internal_, steamId);
+    return static_cast<Result>(result);
+}
+
+void ActivityManager::UpdateActivity(Activity const& activity, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->update_activity(internal_,
+                               reinterpret_cast<DiscordActivity*>(const_cast<Activity*>(&activity)),
+                               cb.release(),
+                               wrapper);
+}
+
+void ActivityManager::ClearActivity(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->clear_activity(internal_, cb.release(), wrapper);
+}
+
+void ActivityManager::SendRequestReply(UserId userId,
+                                       ActivityJoinRequestReply reply,
+                                       std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_request_reply(internal_,
+                                  userId,
+                                  static_cast<EDiscordActivityJoinRequestReply>(reply),
+                                  cb.release(),
+                                  wrapper);
+}
+
+void ActivityManager::SendInvite(UserId userId,
+                                 ActivityActionType type,
+                                 char const* content,
+                                 std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->send_invite(internal_,
+                           userId,
+                           static_cast<EDiscordActivityActionType>(type),
+                           const_cast<char*>(content),
+                           cb.release(),
+                           wrapper);
+}
+
+void ActivityManager::AcceptInvite(UserId userId, std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->accept_invite(internal_, userId, cb.release(), wrapper);
+}
+
+} // namespace discord

data/third-party/include/activity_manager.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ActivityManager final {
+public:
+    ~ActivityManager() = default;
+
+    Result RegisterCommand(char const* command);
+    Result RegisterSteam(std::uint32_t steamId);
+    void UpdateActivity(Activity const& activity, std::function<void(Result)> callback);
+    void ClearActivity(std::function<void(Result)> callback);
+    void SendRequestReply(UserId userId,
+                          ActivityJoinRequestReply reply,
+                          std::function<void(Result)> callback);
+    void SendInvite(UserId userId,
+                    ActivityActionType type,
+                    char const* content,
+                    std::function<void(Result)> callback);
+    void AcceptInvite(UserId userId, std::function<void(Result)> callback);
+
+    Event<char const*> OnActivityJoin;
+    Event<char const*> OnActivitySpectate;
+    Event<User const&> OnActivityJoinRequest;
+    Event<ActivityActionType, User const&, Activity const&> OnActivityInvite;
+
+private:
+    friend class Core;
+
+    ActivityManager() = default;
+    ActivityManager(ActivityManager const& rhs) = delete;
+    ActivityManager& operator=(ActivityManager const& rhs) = delete;
+    ActivityManager(ActivityManager&& rhs) = delete;
+    ActivityManager& operator=(ActivityManager&& rhs) = delete;
+
+    IDiscordActivityManager* internal_;
+    static IDiscordActivityEvents events_;
+};
+
+} // namespace discord

data/third-party/include/application_manager.cpp

@@ -0,0 +1,78 @@
+#if !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include "application_manager.h"
+
+#include "core.h"
+
+#include <cstring>
+#include <memory>
+
+namespace discord {
+
+void ApplicationManager::ValidateOrExit(std::function<void(Result)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result) -> void {
+        std::unique_ptr<std::function<void(Result)>> cb(
+          reinterpret_cast<std::function<void(Result)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result));
+    };
+    std::unique_ptr<std::function<void(Result)>> cb{};
+    cb.reset(new std::function<void(Result)>(std::move(callback)));
+    internal_->validate_or_exit(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetCurrentLocale(char locale[128])
+{
+    if (!locale) {
+        return;
+    }
+
+    internal_->get_current_locale(internal_, reinterpret_cast<DiscordLocale*>(locale));
+}
+
+void ApplicationManager::GetCurrentBranch(char branch[4096])
+{
+    if (!branch) {
+        return;
+    }
+
+    internal_->get_current_branch(internal_, reinterpret_cast<DiscordBranch*>(branch));
+}
+
+void ApplicationManager::GetOAuth2Token(std::function<void(Result, OAuth2Token const&)> callback)
+{
+    static auto wrapper =
+      [](void* callbackData, EDiscordResult result, DiscordOAuth2Token* oauth2Token) -> void {
+        std::unique_ptr<std::function<void(Result, OAuth2Token const&)>> cb(
+          reinterpret_cast<std::function<void(Result, OAuth2Token const&)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), *reinterpret_cast<OAuth2Token const*>(oauth2Token));
+    };
+    std::unique_ptr<std::function<void(Result, OAuth2Token const&)>> cb{};
+    cb.reset(new std::function<void(Result, OAuth2Token const&)>(std::move(callback)));
+    internal_->get_oauth2_token(internal_, cb.release(), wrapper);
+}
+
+void ApplicationManager::GetTicket(std::function<void(Result, char const*)> callback)
+{
+    static auto wrapper = [](void* callbackData, EDiscordResult result, char const* data) -> void {
+        std::unique_ptr<std::function<void(Result, char const*)>> cb(
+          reinterpret_cast<std::function<void(Result, char const*)>*>(callbackData));
+        if (!cb || !(*cb)) {
+            return;
+        }
+        (*cb)(static_cast<Result>(result), static_cast<const char*>(data));
+    };
+    std::unique_ptr<std::function<void(Result, char const*)>> cb{};
+    cb.reset(new std::function<void(Result, char const*)>(std::move(callback)));
+    internal_->get_ticket(internal_, cb.release(), wrapper);
+}
+
+} // namespace discord

data/third-party/include/application_manager.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "types.h"
+
+namespace discord {
+
+class ApplicationManager final {
+public:
+    ~ApplicationManager() = default;
+
+    void ValidateOrExit(std::function<void(Result)> callback);
+    void GetCurrentLocale(char locale[128]);
+    void GetCurrentBranch(char branch[4096]);
+    void GetOAuth2Token(std::function<void(Result, OAuth2Token const&)> callback);
+    void GetTicket(std::function<void(Result, char const*)> callback);
+
+private:
+    friend class Core;
+
+    ApplicationManager() = default;
+    ApplicationManager(ApplicationManager const& rhs) = delete;
+    ApplicationManager& operator=(ApplicationManager const& rhs) = delete;
+    ApplicationManager(ApplicationManager&& rhs) = delete;
+    ApplicationManager& operator=(ApplicationManager&& rhs) = delete;
+
+    IDiscordApplicationManager* internal_;
+    static IDiscordApplicationEvents events_;
+};
+
+} // namespace discord