269 lines
12 KiB
C#
269 lines
12 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Threading.Tasks;
|
|
using DSharpPlus;
|
|
using DSharpPlus.CommandsNext;
|
|
using DSharpPlus.CommandsNext.Attributes;
|
|
using DSharpPlus.Entities;
|
|
using Newtonsoft.Json;
|
|
namespace StarsiegeBot
|
|
{
|
|
[Group("deathmessage"), Aliases("dm")]
|
|
[Description("Gives a random death message. Or interacts with the death messages.")]
|
|
[Cooldown(1, 2, CooldownBucketType.Guild)]
|
|
class DeathMessages : BaseCommandModule
|
|
{
|
|
private DeathMessageLines _dmLines;
|
|
private bool _isEnabled;
|
|
private static readonly string s_fileName = "Json/deathmessages.json";
|
|
public DeathMessages()
|
|
{
|
|
Console.WriteLine("Death Message Commands Loaded.");
|
|
// If the DeathMessages file exists, load it. And enable the commands.
|
|
// Otherwise disable all the commands.
|
|
if (File.Exists(s_fileName))
|
|
{
|
|
// set some JSON text to blank.
|
|
string json = "";
|
|
using (FileStream fs = File.OpenRead(s_fileName))
|
|
using (StreamReader sr = new StreamReader(fs, new UTF8Encoding(false)))
|
|
json = sr.ReadToEnd();
|
|
// Decode the JSON and set it to dmLines.
|
|
_dmLines = JsonConvert.DeserializeObject<DeathMessageLines>(json);
|
|
// Enable all the commands.
|
|
_isEnabled = true;
|
|
}
|
|
else
|
|
{
|
|
// Echo out that we're missing a file. Disable the commands due to that.
|
|
Console.WriteLine($" --- --- --- --- {s_fileName} is missing");
|
|
_isEnabled = false;
|
|
}
|
|
}
|
|
[Command("load")]
|
|
[RequireOwner]
|
|
public async Task LoadDeathMessages(CommandContext ctx)
|
|
{
|
|
if (File.Exists(s_fileName))
|
|
{
|
|
// set some JSON text to blank.
|
|
string json = "";
|
|
using (FileStream fs = File.OpenRead(s_fileName))
|
|
using (StreamReader sr = new StreamReader(fs, new UTF8Encoding(false)))
|
|
json = sr.ReadToEnd();
|
|
// Decode the JSON and set it to dmLines.
|
|
_dmLines = JsonConvert.DeserializeObject<DeathMessageLines>(json);
|
|
// Enable all the commands.
|
|
_isEnabled = true;
|
|
await ctx.RespondAsync(StartEmbed("Loading Death Messages successul."));
|
|
}
|
|
else
|
|
{
|
|
// Echo out that we're missing a file. Disable the commands due to that.
|
|
await ctx.RespondAsync(StartEmbed("Can't load Death Messages. File missing."));
|
|
_isEnabled = false;
|
|
}
|
|
}
|
|
[Command("toggle"), Aliases("t")]
|
|
[RequireOwner]
|
|
public async Task ToggleDM(CommandContext ctx, [RemainingText] string isEnabled = null)
|
|
{
|
|
isEnabled = isEnabled.ToLower();
|
|
string output;
|
|
string[] turnOn = { "on", "true", "1" };
|
|
string[] turnOff = { "off", "false", "0" };
|
|
if (File.Exists(s_fileName))
|
|
{
|
|
if (turnOn.Contains(isEnabled))
|
|
{
|
|
_isEnabled = true;
|
|
}
|
|
else if (turnOff.Contains(isEnabled))
|
|
{
|
|
_isEnabled = false;
|
|
}
|
|
else
|
|
{
|
|
}
|
|
output = $"DeathMessages Enabled: {_isEnabled}";
|
|
}
|
|
else
|
|
{
|
|
_isEnabled = false;
|
|
output = $"{s_fileName} file is missing, and it can not be enabled.";
|
|
}
|
|
await ctx.RespondAsync(StartEmbed(output));
|
|
}
|
|
[GroupCommand]
|
|
public async Task DeathMessage(CommandContext ctx, [Description("Optional. Person you want to see kill you. If blank, will show generic death message.")] DiscordMember target = null)
|
|
{
|
|
// We're typing! (In all honesty, this is just used to avoid the 'async task not using await' messages I get.
|
|
// IF we're missing the Death Messages dot JSON file, we're going to get disabled... Check for that.
|
|
// If disabled, let the person know the command set is disabled, and return.
|
|
if (!_isEnabled)
|
|
{
|
|
return;
|
|
}
|
|
// set some basic output incase something goes south.
|
|
string line = "Something went wrong.";
|
|
// if there is no target, we're going to "kill" the author.
|
|
if (target == null)
|
|
{
|
|
int choice = Program.rnd.Next(0, _dmLines.Generic.Length);
|
|
line = _dmLines.Generic[choice];
|
|
await ctx.RespondAsync(string.Format(line, ctx.Message.Author.Mention));
|
|
}
|
|
// we have a valid target... Have the bot kill them.
|
|
else
|
|
{
|
|
// Pick a death message type at random.
|
|
int opt = Program.rnd.Next(1, 3);
|
|
// If we picked active death messages...
|
|
if (opt == 1)
|
|
{
|
|
// Pick an Active death message at random, and set our output to it.
|
|
int choice = Program.rnd.Next(0, _dmLines.Active.Length);
|
|
line = _dmLines.Active[choice];
|
|
}
|
|
else if (opt == 2)
|
|
{
|
|
// We picked a Passive death message type. Pick the exact line at random. Set it to the output.
|
|
int choice = Program.rnd.Next(0, _dmLines.Passive.Length);
|
|
line = _dmLines.Passive[choice];
|
|
}
|
|
// Give the selected death message to the user.
|
|
await ctx.RespondAsync(StartEmbed(string.Format(line, ctx.Message.Author.Mention, target.Mention)));
|
|
}
|
|
}
|
|
[Command("count")]
|
|
[Description("Gets the total of each type of death message")]
|
|
public async Task DeathMessageCount(CommandContext ctx)
|
|
{
|
|
// IF we're missing the Death Messages dot JSON file, we're going to get disabled... Check for that.
|
|
// If disabled, let the person know the command set is disabled, and return.
|
|
if (!_isEnabled)
|
|
{
|
|
return;
|
|
}
|
|
// We're typing here!
|
|
// List all the types of Death Message types, and how many we have of each one.
|
|
await ctx.RespondAsync(StartEmbed($"Active: {_dmLines.Active.Length}\r\nPassive: {_dmLines.Passive.Length}\r\nGeneric: {_dmLines.Generic.Length}"));
|
|
}
|
|
[Command("Add")]
|
|
[Description("Adds a message to the Pending Death Message Queue. Generic Death Messages require just a [Killed] while any other death message requires both a [Killed] and a [Killer] tags. These will be replaced with the correct information in game, and in the usage of random DM generation.")]
|
|
[Cooldown(1, 2, CooldownBucketType.Guild)]
|
|
public async Task DeathMessageNew(CommandContext ctx, [RemainingText, Description("The Death Message you want added. See help section.")] string msg)
|
|
{
|
|
// IF we're missing the Death Messages dot JSON file, we're going to get disabled... Check for that.
|
|
// If disabled, let the person know the command set is disabled, and return.
|
|
if (!_isEnabled)
|
|
{
|
|
await ctx.RespondAsync("Death Messages Commands have been disabled. Please contact the bot owners.");
|
|
return;
|
|
}
|
|
// Let Discord know we're typing.
|
|
// Message the owner know some one wants to add a new death message, along with a code block to that message.
|
|
// if the Queue is null, make it exist.
|
|
if (_dmLines.Queue is null)
|
|
_dmLines.Queue = new List<string>();
|
|
// add the message to the queue list.
|
|
_dmLines.Queue.Add(msg);
|
|
// Store the new stuff to file...
|
|
await StoreDeathMessages();
|
|
// Tell the person that the message has been added to a 'queue'.
|
|
await ctx.RespondAsync(StartEmbed("Your request has been added to the pending queue of requests."));
|
|
}
|
|
[Command("script")]
|
|
[Description("Gets a script file for all the death messages on the bot.")]
|
|
public async Task DeathMessagesScript(CommandContext ctx)
|
|
{
|
|
// IF we're missing the Death Messages dot JSON file, we're going to get disabled... Check for that.
|
|
// If disabled, let the person know the command set is disabled, and return.
|
|
if (!_isEnabled)
|
|
{
|
|
await ctx.RespondAsync("Death Messages Commands have been disabled. Please contact the bot owners.");
|
|
return;
|
|
}
|
|
// If this file exists... We could do one of two things. Delete it and remake it, or serve it up.
|
|
if (File.Exists("deathmessages.cs"))
|
|
{
|
|
File.Delete("deathmessages.cs");
|
|
}
|
|
// We're going to remake it. Open it.
|
|
using StreamWriter file = new StreamWriter("deathmessages.cs");
|
|
// Write out the total lines for each. Requirement for Starsiege.
|
|
await file.WriteLineAsync($"$deathMessage::genericCount = {_dmLines.Generic.Length};");
|
|
await file.WriteLineAsync($"$deathMessage::activeCount = {_dmLines.Active.Length};");
|
|
await file.WriteLineAsync($"$deathMessage::passiveCount = {_dmLines.Passive.Length};\r\n");
|
|
// Set count to 0. Iterate over each type of Death Message, and put it into the file.
|
|
int count = 0;
|
|
foreach (string death in _dmLines.Generic)
|
|
{
|
|
await file.WriteLineAsync(string.Format($"$deathMessage::generic{count} = \"{death}\";", "%s", "%s"));
|
|
count++;
|
|
}
|
|
// Reset the count...
|
|
count = 0;
|
|
foreach (string death in _dmLines.Active)
|
|
{
|
|
await file.WriteLineAsync(string.Format($"$deathMessage::active{count} = \"{death}\";", "%s", "%s"));
|
|
count++;
|
|
}
|
|
// Reset the count one last time...
|
|
count = 0;
|
|
foreach (string death in _dmLines.Passive)
|
|
{
|
|
await file.WriteLineAsync(string.Format($"$deathMessage::passive{count} = \"{death}\";", "%s", "%s"));
|
|
count++;
|
|
}
|
|
// We're done writing to it... So close the file.
|
|
file.Close();
|
|
// We're going to Message Build the response.
|
|
DiscordMessageBuilder msg = new DiscordMessageBuilder();
|
|
// Open the file to upload.
|
|
FileStream sound = new FileStream($"deathmessages.cs", FileMode.Open);
|
|
// Tell DSharp that we want to upload this file.
|
|
msg.WithFile("deathmessages.cs", sound);
|
|
// Add some content so its not a blank file.
|
|
msg.Content = "Here is your request for a death message script.";
|
|
// send that message.
|
|
await ctx.RespondAsync(msg);
|
|
// We're done with the file, so close access to it.
|
|
sound.Close();
|
|
}
|
|
private DiscordEmbedBuilder StartEmbed(string description)
|
|
{
|
|
DiscordEmbedBuilder embed = new DiscordEmbedBuilder
|
|
{
|
|
Description = description,
|
|
Color = Program.colours[Program.rnd.Next(0, Program.colours.Length)]
|
|
};
|
|
return embed;
|
|
}
|
|
|
|
private async Task StoreDeathMessages()
|
|
{
|
|
string output = JsonConvert.SerializeObject(_dmLines);
|
|
await File.WriteAllTextAsync(s_fileName, output);
|
|
return;
|
|
}
|
|
}
|
|
class DeathMessageLines
|
|
{
|
|
[JsonProperty("active")]
|
|
public string[] Active { get; set; }
|
|
[JsonProperty("passive")]
|
|
public string[] Passive { get; set; }
|
|
[JsonProperty("generic")]
|
|
public string[] Generic { get; set; }
|
|
[JsonProperty("flagged")]
|
|
public List<string> Flagged { get; set; }
|
|
[JsonProperty("queue")]
|
|
public List<string> Queue { get; set; }
|
|
}
|
|
}
|