2022-06-22 23:37:46 -04:00
|
|
|
#include "discord.h"
|
|
|
|
|
2022-02-07 23:53:36 -05:00
|
|
|
#include <cstring>
|
2022-06-05 11:45:07 -04:00
|
|
|
#include <iomanip>
|
2022-06-22 23:37:46 -04:00
|
|
|
#include <map>
|
|
|
|
#include <sstream>
|
2022-02-07 23:53:36 -05:00
|
|
|
|
2023-01-07 10:34:01 -05:00
|
|
|
#include "common/log/log.h"
|
|
|
|
|
2024-05-01 07:49:26 -04:00
|
|
|
#include "discord_jak3.h"
|
2023-01-07 10:34:01 -05:00
|
|
|
#include "game/runtime.h"
|
|
|
|
|
2022-02-07 23:53:36 -05:00
|
|
|
int gDiscordRpcEnabled;
|
|
|
|
int64_t gStartTime;
|
2023-01-07 10:34:01 -05:00
|
|
|
|
|
|
|
static const std::map<GameVersion, std::string> rpc_client_ids = {
|
|
|
|
{GameVersion::Jak1, "938876425585434654"},
|
2024-05-01 07:49:26 -04:00
|
|
|
{GameVersion::Jak2, "1060390251694149703"},
|
|
|
|
{GameVersion::Jak3, "1226307413355790416"}};
|
2023-01-07 10:34:01 -05:00
|
|
|
|
|
|
|
void handleDiscordReady(const DiscordUser* user) {
|
|
|
|
lg::info("Discord: connected to user {}#{} - {}", user->username, user->discriminator,
|
|
|
|
user->userId);
|
|
|
|
}
|
|
|
|
|
|
|
|
void handleDiscordDisconnected(int errcode, const char* message) {
|
|
|
|
lg::info("Discord: disconnected ({}: {})", errcode, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
void handleDiscordError(int errcode, const char* message) {
|
|
|
|
lg::info("Discord: error ({}: {})", errcode, message);
|
|
|
|
}
|
|
|
|
|
|
|
|
void handleDiscordJoin(const char* /*secret*/) {}
|
|
|
|
void handleDiscordJoinRequest(const DiscordUser* /*request*/) {}
|
|
|
|
void handleDiscordSpectate(const char* /*secret*/) {}
|
|
|
|
|
2022-02-07 23:53:36 -05:00
|
|
|
void init_discord_rpc() {
|
2024-05-01 07:49:26 -04:00
|
|
|
if (g_game_version != GameVersion::Jak1 && g_game_version != GameVersion::Jak2 &&
|
|
|
|
g_game_version != GameVersion::Jak3) {
|
2023-01-07 10:34:01 -05:00
|
|
|
lg::error("Game version unsupported for Discord RPC - {}", fmt::underlying(g_game_version));
|
|
|
|
return;
|
|
|
|
}
|
2024-05-01 07:49:26 -04:00
|
|
|
if (g_game_version == GameVersion::Jak3) {
|
|
|
|
jak3::remap_hack();
|
|
|
|
}
|
2022-02-07 23:53:36 -05:00
|
|
|
gDiscordRpcEnabled = 1;
|
|
|
|
DiscordEventHandlers handlers;
|
|
|
|
memset(&handlers, 0, sizeof(handlers));
|
|
|
|
handlers.ready = handleDiscordReady;
|
|
|
|
handlers.disconnected = handleDiscordDisconnected;
|
|
|
|
handlers.errored = handleDiscordError;
|
|
|
|
handlers.joinGame = handleDiscordJoin;
|
|
|
|
handlers.joinRequest = handleDiscordJoinRequest;
|
|
|
|
handlers.spectateGame = handleDiscordSpectate;
|
2023-01-07 10:34:01 -05:00
|
|
|
Discord_Initialize(rpc_client_ids.at(g_game_version).c_str(), &handlers, 1, NULL);
|
2022-02-07 23:53:36 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
void set_discord_rpc(int state) {
|
|
|
|
gDiscordRpcEnabled = state;
|
|
|
|
}
|
|
|
|
|
|
|
|
// get full level name from symbol name ("village1" -> "Sandover Village")
|
2023-06-17 00:16:40 -04:00
|
|
|
const char* get_full_level_name(const std::map<std::string, std::string>& level_names,
|
|
|
|
const std::map<std::string, std::string>& level_name_remap,
|
|
|
|
const char* level_name) {
|
2022-02-07 23:53:36 -05:00
|
|
|
// ignore sublevels
|
2023-06-17 00:16:40 -04:00
|
|
|
auto it = level_name_remap.find(level_name);
|
|
|
|
auto actual_level_name = it == level_name_remap.end() ? level_name : it->second;
|
2022-02-07 23:53:36 -05:00
|
|
|
|
2023-06-17 00:16:40 -04:00
|
|
|
const auto& nice_name = level_names.find(actual_level_name);
|
|
|
|
if (nice_name != level_names.end()) {
|
2022-02-08 19:02:47 -05:00
|
|
|
return nice_name->second.c_str();
|
|
|
|
}
|
2022-06-23 18:44:42 -04:00
|
|
|
return "unknown";
|
2022-06-05 11:45:07 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// convert time of day float to a 24-hour hh:mm format string
|
|
|
|
std::string get_time_of_day(float time) {
|
|
|
|
int hour = static_cast<int>(time);
|
|
|
|
int minutes = static_cast<int>((time - hour) * 60);
|
|
|
|
std::stringstream ss;
|
|
|
|
ss << hour << ':' << std::setw(2) << std::setfill('0') << minutes;
|
|
|
|
return ss.str();
|
|
|
|
}
|
|
|
|
|
|
|
|
// are we in an area that's indoors, i.e. not affected by time of day?
|
2023-06-17 00:16:40 -04:00
|
|
|
bool indoors(std::vector<std::string> indoor_levels, const char* level_name) {
|
|
|
|
return std::find(indoor_levels.begin(), indoor_levels.end(), level_name) != indoor_levels.end();
|
2022-06-05 11:45:07 -04:00
|
|
|
}
|