private static void Initialize()
{
InitPatches();
AddNebulaBootstrapper();
RegisterKeyBinds();
DiscordManager.Setup(ActivityManager_OnActivityJoin);
}
public override void ProcessPacket(PlayerJoining packet, NebulaConnection conn)
{
Multiplayer.Session.NumPlayers = packet.NumPlayers;
DiscordManager.UpdateRichPresence();
Multiplayer.Session.World.SpawnRemotePlayerModel(packet.PlayerData);
Multiplayer.Session.World.OnPlayerJoining(packet.PlayerData.Username);
}
private void Update()
{
if (GameMain.isRunning && UIRoot.instance.launchSplash.willdone)
{
DiscordManager.Update();
}
}
public override void ProcessPacket(LobbyResponse packet, NebulaConnection conn)
{
using (BinaryUtils.Reader p = new BinaryUtils.Reader(packet.ModsSettings))
{
for (int i = 0; i < packet.ModsSettingsCount; i++)
{
string guid = p.BinaryReader.ReadString();
PluginInfo info = Chainloader.PluginInfos[guid];
if (info.Instance is IMultiplayerModWithSettings mod)
{
mod.Import(p.BinaryReader);
}
}
}
((LocalPlayer)Multiplayer.Session.LocalPlayer).IsHost = false;
Multiplayer.Session.NumPlayers = packet.NumPlayers;
Multiplayer.Session.IsInLobby = true;
DiscordManager.UpdateRichPresence(partyId: packet.DiscordPartyId);
UIRoot.instance.galaxySelect._Open();
UIRoot.instance.uiMainMenu._Close();
GameDesc gameDesc = new GameDesc();
gameDesc.SetForNewGame(packet.GalaxyAlgo, packet.GalaxySeed, packet.StarCount, 1, packet.ResourceMultiplier);
gameDesc.savedThemeIds = packet.SavedThemeIds;
UIRoot.instance.galaxySelect.gameDesc = gameDesc;
UIRoot.instance.galaxySelect.SetStarmapGalaxy();
}
private static async void ActivityManager_OnActivityJoin(string secret)
{
if (Multiplayer.IsActive)
{
Log.Warn("Cannot join lobby from Discord, we are already in a lobby.");
return;
}
if (string.IsNullOrWhiteSpace(secret))
{
Log.Warn("Received Discord invite without IP address.");
return;
}
var ipAddresses = secret.FromBase64().Split(';');
if (ipAddresses.Length != 1 && ipAddresses.Length != 3)
{
Log.Warn("Received invalid discord invite.");
return;
}
string ipAddress = string.Empty;
if (ipAddresses.Length == 1 && ipAddresses[0].Contains("ngrok"))
{
ipAddress = ipAddresses[0];
}
if (string.IsNullOrWhiteSpace(ipAddress) && await IPUtils.IsIPv6Supported())
{
if (ipAddresses.Length > 1)
{
if (IPUtils.IsIPv6(ipAddresses[1]))
{
ipAddress = $"{ipAddresses[1]}:{ipAddresses[2]}";
}
}
}
if (string.IsNullOrWhiteSpace(ipAddress))
{
if (IPUtils.IsIPv4(ipAddresses[0]))
{
ipAddress = $"{ipAddresses[0]}:{ipAddresses[2]}";
}
}
if (string.IsNullOrWhiteSpace(ipAddress))
{
Log.Warn("Received Discord invite with invalid IP address.");
return;
}
Log.Info("Joining lobby from Discord...");
UIMainMenu_Patch.OnMultiplayerButtonClick();
UIMainMenu_Patch.JoinGame($"{ipAddress}");
DiscordManager.UpdateRichPresence(ip: secret, secretPassthrough: true, updateTimestamp: true);
}
/// <summary>
/// UnloadContent will be called once per game and is the place to unload
/// game-specific content.
/// </summary>
protected override void UnloadContent()
{
WobbleAssets.Dispose();
WindowManager.UnHookEvents();
AudioManager.Dispose();
DiscordManager.Dispose();
BitmapFontFactory.Dispose();
}
static public void Initialize()
{
// 604680029439393812 <- Adri's AppID, in case we go back to that one.
// 649491503391047701 <- FRUP's AppID, currently being used.
DiscordManager.CreateClient("649491503391047701", Wobble.Discord.RPC.Logging.LogLevel.None);
Presence = new RichPresence();
Presence.Assets = new Assets();
Presence.Timestamps = new Timestamps();
}
public MessageService(DiscordManager discordManager, TwitchManager twitchManager, IServiceProvider serviceProvider, DiscordSocketClient discordSocketClient, ITwitchClient twitchClient)
{
_platforms.Add(discordManager);
_platforms.Add(twitchManager);
_serviceProvider = serviceProvider;
discordSocketClient.MessageReceived += OnDiscordMessageReceived;
twitchClient.OnMessageReceived += OnTwitchmessageReceived;
}
private void OnDestroy()
{
if (Singleton == this)
{
DiscordAPI.UnregisterEventsHandler(this);
DiscordAPI.Stop();
Singleton = null;
}
}
public static void HandleApplicationQuit_Prefix()
{
if (Multiplayer.IsActive)
{
Log.Warn("Multiplayer is still running, closing now...");
Multiplayer.LeaveGame();
}
DiscordManager.Cleanup();
}
protected override async Task OnMessage(VoiceOptionsMessage message)
{
DiscordManager.GetDiscord().GetOverlayManager().OpenVoiceSettings((result) =>
{
if (result == Result.Ok)
{
Console.WriteLine("Voice options have now been opened");
}
});
}
public static IHostBuilder CreateHostBuilder(string[] args)
{
DiscordManager.CreateDiscord();
return(Host.CreateDefaultBuilder(args)
.ConfigureWebHostDefaults(webBuilder =>
{
webBuilder.UseStartup <Startup>();
webBuilder.UseUrls("http://*:2324");
}));
}
protected virtual void Awake()
{
if (Singleton != null)
{
Destroy(gameObject);
return;
}
Singleton = this;
DontDestroyOnLoad(gameObject);
}
/// <summary>
/// </summary>
public TestDiscordScreen()
{
DiscordManager.CreateClient("473243746922659842", LogLevel.None);
DiscordManager.Client.SetPresence(new RichPresence()
{
Details = "TestDiscordScreen",
State = "Testing"
});
View = new TestDiscordScreenView(this);
}
public static void PerformExit()
{
if (MainWindow.CurrentProject.SavePrompt() == null)
{
return;
}
App.Logger.Log("Closing app");
DiscordManager?.Deinitialize();
Environment.Exit(0);
}
public static bool InitDiscord(DiscordManager __instance)
{
ModHelper.ModLogger.Debug("Triggered");
instance = __instance;
instance.discord = new Discord.Discord(599659394082406493L, 1UL);
SingletonMonoBehaviour <UnityGameManager> .instance.RegLoop(new UnityAction <float>(DiscordRunCallbacks), UnityGameManager.LoopType.Update, float.MaxValue);
instance.activityManager = instance.discord.GetActivityManager();
instance.applicationManager = instance.discord.GetApplicationManager();
instance.SetUpdateActivity(false, string.Empty);
return(false);
}
private void Awake()
{
if (INSTANCE)
{
Destroy(this);
}
else
{
INSTANCE = this;
DontDestroyOnLoad(gameObject);
}
}
public ServersController(
IConfig config,
EfDatabaseContextFactory databaseContextFactory,
ArkContextManager contextManager,
DiscordManager discordManager,
IArkServerService serverService,
ArkBotAnonymizeData anonymizeData) : base(config)
{
_databaseContextFactory = databaseContextFactory;
_contextManager = contextManager;
_discordManager = discordManager;
_serverService = serverService;
_anonymizeData = anonymizeData;
}
public ScheduledTasksManager(
ArkContextManager contextManager,
DiscordManager discordManager,
IConfig config)
{
_contextManager = contextManager;
_discordManager = discordManager;
_config = config;
_contextManager.InitializationCompleted += _contextManager_InitializationCompleted;
_timedTasks = new ConcurrentDictionary <TimedTask, bool>();
_timer = new Timer(_timer_Callback, null, Timeout.Infinite, Timeout.Infinite);
}
public void vip_chat(Client player, string message)
{
Account account = player.GetAccount();
Character character = player.GetCharacter();
if (VipStatus == false && account.AdminLevel == 0)
{
NAPI.Notification.SendNotificationToPlayer(player, "~r~ERROR:~w~VIP chat is currently disabled.");
return;
}
if (character.VIPToggled)
{
NAPI.Chat.SendChatMessageToPlayer(player, "You have /v toggled off.");
}
if (character.VMutedExpiration > TimeManager.GetTimeStamp)
{
NAPI.Notification.SendNotificationToPlayer(player, "~r~ERROR:~w~You are muted from VIP chat.");
return;
}
if (account.VipLevel == 0)
{
NAPI.Notification.SendNotificationToPlayer(player, "~y~You must be a VIP to use VIP chat.");
return;
}
Character c = player.GetCharacter();
var players = API.GetAllPlayers();
foreach (var p in players)
{
if (p == null)
{
continue;
}
Account pAccount = p.GetAccount();
if (pAccount?.VipLevel > 0 && character.VIPToggled == false)
{
NAPI.Chat.SendChatMessageToPlayer(p, Color.VipChat, "[V] " + c.rp_name() + ": " + message);
}
}
DiscordManager.SendVIPMessage("[V] " + c.rp_name() + $"[{account.AccountName}]" + ": " + message);
}
private async Task HandleClickedDisconnect()
{
if (!CurrentLobby.HasValue)
{
Console.WriteLine("No currently connected Lobby, skipping disconnect");
return;
}
var lobbyManager = DiscordManager.GetDiscord().GetLobbyManager();
lobbyManager.DisconnectLobby(CurrentLobby.Value.Id, (Result result) =>
{
Console.WriteLine("Disconnected from Lobby");
CurrentLobby = null;
});
}
private async void TokenInputChanged(object sender, TextChangedEventArgs e)
{
if (shouldNotVerify)
{
shouldNotVerify = false;
return;
}
_allOk = false;
_changed = true;
ChangeNextButtonStatus(false);
var previousLength = TokenTextBox.Text.Length;
TokenTextBox.Text = new string(TokenTextBox.Text.Where(c => c != '"').ToArray());
//if (TokenTextBox.Text.Length != previousLength)
//{
// shouldNotVerify = true;
//}
TokenStatus.Text = "Trying to connect...";
TokenStatus.Style = (Style)TokenStatus.Resources["NormalStyle"];
if (TokenTextBox.Text.Length < 59)
{
TokenStatus.Text = "Token too short";
TokenStatus.Style = (Style)TokenStatus.Resources["ErrorStyle"];
return;
}
try
{
TokenTextBox.IsEnabled = false;
await DiscordManager.InitialiseWithToken(TokenTextBox.Text);
_allOk = true;
TokenStatus.Text = "Succesfully connected!";
TokenStatus.Style = (Style)TokenStatus.Resources["ValidStyle"];
ChangeNextButtonStatus(true);
}
catch (Exception)
{
TokenStatus.Text = "Could not connect, is your token valid?";
TokenStatus.Style = (Style)TokenStatus.Resources["ErrorStyle"];
}
finally
{
await Task.Delay(5000);
TokenTextBox.IsEnabled = true;
}
}
protected override async Task OnMessage(ModuleExittingMessage message)
{
Console.WriteLine("Foundry module has initiated a leave");
DiscordManager.RemoveStatus();
if (CurrentLobby.HasValue)
{
DiscordManager.GetDiscord().GetLobbyManager().DisconnectLobby(CurrentLobby.Value.Id, (Result result) => { });
CurrentLobby = null;
}
await StatusWebsocket.WebSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Foundry module initiated a shutdown", CancellationToken.None);
if (message.ShouldExit)
{
Console.WriteLine("Foundry asked the API to exit, exitting..");
Environment.Exit(0);
}
}
private async Task HandleDeafen()
{
var voiceManager = DiscordManager.GetDiscord().GetVoiceManager();
voiceManager.SetSelfDeaf(!voiceManager.IsSelfDeaf());
var isDeafened = voiceManager.IsSelfDeaf();
Console.WriteLine("Deafened changed to " + isDeafened);
var msg = new WebsocketMessage()
{
Type = RichPresenceMessageTypes.VoiceStatus
};
msg.From(new VoiceStatusMessage {
IsConnected = true, IsMuted = IsSelfMuted(voiceManager), IsDeafened = voiceManager.IsSelfDeaf()
});
await Send(msg);
}
private void Load(Storage storage)
{
_dependencies.Cache(BeatmapManager = new BeatmapManager());
_dependencies.Cache(UserManager = new UserManager());
_dependencies.Cache(BeatmapMirrorAccess = new BeatmapMirrorAccess());
_dependencies.Cache(QsorDbContextFactory = new QsorDbContextFactory(storage));
_dependencies.Cache(ConfigManager = new QsorConfigManager(storage));
_dependencies.Cache(NotificationOverlay = new NotificationOverlay());
_dependencies.Cache(SentryLogger = new SentryLogger(this));
_dependencies.Cache(DiscordManager = new DiscordManager());
_dependencies.CacheAs(this);
_dependencies.CacheAs(Host);
AddInternal(DiscordManager);
Resources.AddStore(new NamespacedResourceStore <byte[]>(new DllResourceStore(typeof(QsorGame).Assembly), @"Resources"));
QsorDbContextFactory.Get().Migrate();
AddInternal(BeatmapManager);
AddInternal(NotificationOverlay);
Updater ??= new DummyUpdater();
UpdaterOverlay = new UpdaterOverlay();
_dependencies.Cache(UpdaterOverlay);
_dependencies.CacheAs(Updater);
LoadComponent(Updater);
ConfigManager.Save();
AddInternal(SettingsOverlay = new SettingsOverlay());
}
public VotingManager(
ArkContextManager contextManager,
DiscordManager discordManager,
ScheduledTasksManager scheduledTasksManager,
EfDatabaseContextFactory databaseContextFactory,
IConfig config,
IConstants constants,
ILifetimeScope scope,
IProgress <string> progress)
{
_contextManager = contextManager;
_discordManager = discordManager;
_scheduledTasksManager = scheduledTasksManager;
_databaseContextFactory = databaseContextFactory;
_config = config;
_constants = constants;
_scope = scope;
_progress = progress;
_contextManager.VoteInitiated += _contextManager_VoteInitiated;
_contextManager.VoteResultForced += _contextManager_VoteResultForced;
_contextManager.InitializationCompleted += _contextManager_InitializationCompleted;
}
public App()
{
// older version of .net (or perhaps just windows) use a different
// security protocol by default which does not work with specific
// web server settings used by some of the servers astra needs
// to contact
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
Logger.Info(nameof(App), $"Version {Assembly.GetExecutingAssembly().GetName().Version}");
if (Settings.Default.UpgradeRequired)
{
Logger.Info(nameof(App), "Upgrading settings file");
Settings.Default.Upgrade();
Settings.Default.UpgradeRequired = false;
Settings.Default.Save();
}
DispatcherUnhandledException += _UnhandledException;
DiscordManager = new DiscordManager();
}
public void admin_cmd(Client player, string text)
{
Account account = player.GetAccount();
if (account.AdminLevel > 0)
{
foreach (var c in API.GetAllPlayers())
{
if (c == null)
{
continue;
}
Account receiverAccount = c.GetAccount();
if (receiverAccount?.AdminLevel > 0)
{
NAPI.Chat.SendChatMessageToPlayer(c, Color.AdminChat, "[A] " + account.AdminName + ": " + text);
}
}
DiscordManager.SendAdminMessage("[A] " + account.AdminName + ": " + text);
}
}
protected override async Task OnMessage(GameStatusMessage playerStatus)
{
var activity = new Activity()
{
Details = playerStatus.Details,
State = playerStatus.State,
Party = new ActivityParty {
Id = playerStatus.WorldUniqueId, Size = new PartySize {
CurrentSize = playerStatus.CurrentPlayerCount, MaxSize = playerStatus.MaxPlayerCount
}
},
Assets = new ActivityAssets
{
LargeImage = "d20",
LargeText = "D20"
},
Instance = false,
Secrets = new ActivitySecrets {
Join = $"{playerStatus.FoundryUrl}/join"
}
};
DiscordManager.SetActivity(activity);
}
public async Task Run()
{
using var serviceProvider = new ServiceContainer();
using var client = GetDiscordClient();
if (_discordSettings.LogLevel == "Debug")
{
try
{
SoundDevice.DetectDevices();
}
catch (Exception e)
{
logger.Error(e, "Sound device detection failed: {exception}");
}
}
using var soundPlayer = new SoundPlayer(new SoundDevice(_soundSettings.InputDeviceName, _soundSettings.InputDeviceId), _soundSettings);
serviceProvider.AddService(typeof(ISoundPlayer), soundPlayer);
var discordManager = new DiscordManager(client, _discordSettings);
serviceProvider.AddService(typeof(DiscordManager), discordManager);
var commandImplementations = new CommandImplementations(discordManager, soundPlayer, _discordSettings);
serviceProvider.AddService(typeof(ICommandImplementations), commandImplementations);
SetupCommands(client, serviceProvider);
SetupVoice(client);
await client.ConnectAsync();
await Task.Run(() => new ConsoleCommands(commandImplementations).Listen());
}
