open System open System.Threading.Tasks open DSharpPlus open DSharpPlus.Entities open DSharpPlus.EventArgs open DSharpPlus.SlashCommands open Emzi0767.Utilities type ActionClass = | Network | Exploit | Penetration type IClass = abstract GetClass : unit -> ActionClass type Weapon = | Virus | Ransom | Worm | DDos | Crack | Injection interface IClass with member this.GetClass () = match this with | Virus | Ransom -> Exploit | DDos | Worm -> Network | Crack | Injection -> Penetration static member TryParse weapon = match weapon with | "Virus" -> Some Virus | "Ransom" -> Some Ransom | "Worm" -> Some Worm | "DDos" -> Some DDos | "Crack" -> Some Crack | "Injection" -> Some Injection | _ -> None type Shield = | Firewall | PortScan | Encryption | Cypher | Hardening | Sanitation interface IClass with member this.GetClass () = match this with | Firewall | PortScan -> Exploit | Encryption | Cypher -> Network | Hardening | Sanitation -> Penetration static member TryParse shield = match shield with | "Firewall" -> Some Firewall | "PortScan" -> Some PortScan | "Encryption" -> Some Encryption | "Cypher" -> Some Cypher | "Hardening" -> Some Hardening | "Sanitation" -> Some Sanitation | _ -> None type HackResult = | Strong | Weak type DiscordPlayer = { Id : uint64 Name : string } type Attack = { HackType : Weapon Target : DiscordPlayer Timestamp : DateTime } type Defense = { DefenseType : Shield Timestamp : DateTime } type Player = { DiscordId : uint64 Weapons : Weapon list Shields : Shield list Attacks : Attack list Defenses : Defense list Bank : single } let mutable players : Player list = [] let newPlayer (membr : uint64) = let h1 = [| Virus ; Ransom |] let h2 = [| DDos ; Worm |] let h3 = [| Crack ; Injection |] let d1 = [| Firewall ; PortScan |] let d2 = [| Encryption ; Cypher |] let d3 = [| Hardening ; Sanitation |] let rand = System.Random(System.Guid.NewGuid().GetHashCode()) let getRandom (actions : 'a array) = actions.[rand.Next(0,2)] let weapons = [ getRandom h1 ; getRandom h2 ; getRandom h3 ] let shields = [ getRandom d1 ; getRandom d2 ; getRandom d3 ] { DiscordId = membr Weapons = weapons Shields = shields Attacks = [] Defenses = [] Bank = 0f } let constructButtons (actionType : string) (playerInfo : string) (weapons : 'a list) = weapons |> Seq.map (fun hack -> DiscordButtonComponent( ButtonStyle.Primary, $"{actionType}-{hack}-{playerInfo}", $"{hack}")) let createSimpleResponseAsync msg (ctx : InteractionContext) = async { let builder = DiscordInteractionResponseBuilder() builder.Content <- msg builder.AsEphemeral true |> ignore do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } |> Async.StartAsTask :> Task let notYetAHackerMsg = createSimpleResponseAsync "You are not currently a hacker, first use the /redpill command to become one" let removeExpiredActions timespan (timestamp : 'a -> DateTime) actions = actions |> List.filter (fun act -> if DateTime.UtcNow - (timestamp act) < timespan then true else false) let constructEmbed message = let builder = DiscordEmbedBuilder() builder.Color <- Optional(DiscordColor.PhthaloGreen) builder.Description <- message let author = DiscordEmbedBuilder.EmbedAuthor() author.Name <- "Joebot Pro" author.Url <- "https://twitter.com/degenzgame" author.IconUrl <- "https://pbs.twimg.com/profile_images/1473192843359309825/cqjm0VQ4_400x400.jpg" builder.Author <- author builder.Build() type EmptyGlobalCommandToAvoidFamousDuplicateSlashCommandsBug() = inherit ApplicationCommandModule () type JoeBot() = inherit ApplicationCommandModule () [] member _.AddHackerRole (ctx : InteractionContext) = async { for role in ctx.Guild.Roles do if role.Value.Name = "Hacker" then do! ctx.Member.GrantRoleAsync(role.Value) |> Async.AwaitTask let player = players |> List.tryFind (fun p -> int64 p.DiscordId = int64 ctx.Member.Id) players <- match player with | Some _ -> players | None -> (newPlayer ctx.Member.Id)::players if Option.isSome player then do! ctx.CreateResponseAsync("Already registered as an elite haxxor", true) |> Async.AwaitTask else do! ctx.CreateResponseAsync("You are now an elite haxxor", true) |> Async.AwaitTask } |> Async.StartAsTask :> Task [] member _.RemoveHackerRole (ctx : InteractionContext) = async { for role in ctx.Member.Roles do if role.Name = "Hacker" then do! ctx.Member.RevokeRoleAsync(role) |> Async.AwaitTask players <- players |> List.filter (fun p -> p.DiscordId <> ctx.User.Id) do! ctx.CreateResponseAsync("You are now lame", true) |> Async.AwaitTask } |> Async.StartAsTask :> Task [] member this.AttackCommand (ctx : InteractionContext, [] target : DiscordUser) = // TODO: We need to check if the player has any active embed hacks going, if not they can cheat let attacker = players |> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id) let defender = players |> List.tryFind (fun p -> p.DiscordId = target.Id) match attacker , defender with | Some attacker , Some defender -> let updatedAttacks = removeExpiredActions (TimeSpan.FromMinutes(15)) (fun (atk : Attack) -> atk.Timestamp) attacker.Attacks players <- players |> List.map (fun p -> if p.DiscordId = attacker.DiscordId then { p with Attacks = updatedAttacks } else p) if updatedAttacks.Length < 2 then async { let builder = DiscordInteractionResponseBuilder() builder.AddEmbed (constructEmbed "Pick the hack you wish to use.") |> ignore let defenderInfo = $"{defender.DiscordId}-{target.Username}" constructButtons "Attack" defenderInfo attacker.Weapons |> Seq.cast |> builder.AddComponents |> ignore builder.AsEphemeral true |> ignore do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } |> Async.StartAsTask :> Task else async { let builder = DiscordInteractionResponseBuilder() let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - updatedAttacks.Head.Timestamp) builder.Content <- $"You already hacked, please wait {timeRemaining.Minutes} minutes and {timeRemaining.Seconds} seconds to attempt another hack" builder.AsEphemeral true |> ignore do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } |> Async.StartAsTask :> Task | None , _ -> notYetAHackerMsg ctx | _ , None -> createSimpleResponseAsync "Your target is not connected to the network, they must join first by using the /redpill command" ctx [] member this.DefendCommand (ctx : InteractionContext) = players |> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id) |> function | Some player -> async { let updatedDefenses = removeExpiredActions (TimeSpan.FromMinutes(60)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses players <- players |> List.map (fun p -> if p.DiscordId = player.DiscordId then { p with Defenses = updatedDefenses } else p) let builder = DiscordInteractionResponseBuilder() builder.AddEmbed (constructEmbed "Pick a defense to mount for a duration of time") |> ignore constructButtons "Defend" (string player.DiscordId) player.Shields |> Seq.cast |> builder.AddComponents |> ignore builder.AsEphemeral true |> ignore do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } |> Async.StartAsTask :> Task | None -> notYetAHackerMsg ctx [] member this.Status (ctx : InteractionContext) = async { return! match players |> List.tryFind (fun p -> p.DiscordId = ctx.Member.Id) with | Some player -> async { let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- $"%A{player}" do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } | None -> notYetAHackerMsg ctx |> Async.AwaitTask } |> Async.StartAsTask :> Task let calculateDamage (hack : IClass) (protection : IClass) = let hackClass = hack.GetClass() let protectionClass = protection.GetClass() match hackClass , protectionClass with | h , p when h = p -> Weak | _ -> Strong let handleAttack (event : ComponentInteractionCreateEventArgs) = let updatePlayer amount attack p = { p with Attacks = attack::p.Attacks Bank = MathF.Max(p.Bank + amount, 0f) } async { let split = event.Id.Split("-") let resultHack = Weapon.TryParse(split.[1]) let ( resultId , targetId ) = UInt64.TryParse split.[2] return! match resultHack , resultId with | Some weapon , true -> let hackType = weapon players |> List.find (fun p -> p.DiscordId = targetId) |> fun p -> p.Defenses |> List.map (fun dfn -> dfn.DefenseType) |> List.map (calculateDamage hackType) |> List.contains Weak |> function | false -> async { let prize = 0.1726f let attack = { HackType = hackType ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } } players <- players |> List.map (fun p -> if p.DiscordId = event.User.Id then updatePlayer prize attack p else p) let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- $"Successfully hacked {split.[3]} using {hackType}! You just won {prize} genz!" do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder) |> Async.AwaitTask let builder = DiscordMessageBuilder() builder.WithContent($"{event.User.Username} successfully hacked <@{targetId}>!") |> ignore let battleChannel = (event.Guild.GetChannel(927449884204867664uL)) do! battleChannel.SendMessageAsync(builder) |> Async.AwaitTask |> Async.Ignore } | true -> async { let builder = DiscordInteractionResponseBuilder() let loss = -0.0623f builder.IsEphemeral <- true builder.Content <- $"Hack failed! {split.[3]} was able to mount a successful defense! You lost {loss} genz!" do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder) |> Async.AwaitTask let attack = { HackType = hackType ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } } players <- players |> List.map (fun p -> if p.DiscordId = event.User.Id then updatePlayer loss attack p else p) let builder = DiscordMessageBuilder() builder.WithContent($"{event.User.Username} failed to hack <@{targetId}>!") |> ignore let battleChannel = (event.Guild.GetChannel(927449884204867664uL)) do! battleChannel.SendMessageAsync(builder) |> Async.AwaitTask |> Async.Ignore } | _ -> async { let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- "Error parsing Button Id" do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } } let handleDefense (event : ComponentInteractionCreateEventArgs) = async { let split = event.Id.Split("-") return! match Shield.TryParse(split.[1]) with | Some shield -> async { let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- $"Mounted a {shield} defense for 1 hour" do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder) |> Async.AwaitTask let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow } players <- players |> List.map (fun p -> { p with Defenses = defense::p.Defenses }) let builder = DiscordMessageBuilder() builder.WithContent($"{event.User.Username} has protected their system!") |> ignore let battleChannel = (event.Guild.GetChannel(927449884204867664uL)) do! battleChannel.SendMessageAsync(builder) |> Async.AwaitTask |> Async.Ignore } | _ -> async { let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- "Error parsing Button Id" do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } } let handleButtonEvent (client : DiscordClient) (event : ComponentInteractionCreateEventArgs) = async { return! match event.Id with | id when id.StartsWith("Attack") -> handleAttack event | id when id.StartsWith("Defend") -> handleDefense event | _ -> async { let builder = DiscordInteractionResponseBuilder() builder.IsEphemeral <- true builder.Content <- $"Incorrect Action identifier {event.Id}" do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder) |> Async.AwaitTask } } |> Async.StartAsTask :> Task let config = DiscordConfiguration() config.Token <- "OTIyNDIyMDIyMTI1MDEwOTU1.YcBOcw.JxfW1CSIwEO7j6RbRFCnPZ-HoTk" config.TokenType <- TokenType.Bot config.Intents <- DiscordIntents.All //config.MinimumLogLevel <- Microsoft.Extensions.Logging.LogLevel.Trace let client = new DiscordClient(config) client.add_ComponentInteractionCreated(AsyncEventHandler(handleButtonEvent)) let slash = client.UseSlashCommands() slash.RegisterCommands(922419263275425832uL); client.ConnectAsync () |> Async.AwaitTask |> Async.RunSynchronously Task.Delay(-1) |> Async.AwaitTask |> Async.RunSynchronously client.DisconnectAsync () |> Async.AwaitTask |> Async.RunSynchronously