discord-bot-game/Bot/HackerBattle.fs

module Degenz.HackerBattle

open System
open System.Threading.Tasks
open DSharpPlus
open DSharpPlus.Entities
open DSharpPlus.EventArgs
open DSharpPlus.SlashCommands
open Degenz
open Degenz.Shared

let attack (ctx : InteractionContext) (target : DiscordUser) =
    async {
        let! attacker = DbService.tryFindPlayer ctx.Member.Id
        let! defender = DbService.tryFindPlayer target.Id
        match attacker , defender with
        | Some attacker , Some defender ->
            let updatedAttacks =
                attacker.Attacks
                |> removeExpiredActions (TimeSpan.FromMinutes(15)) (fun (atk : Attack) -> atk.Timestamp)
            do! DbService.updatePlayer <| { attacker with Attacks = updatedAttacks }
            if updatedAttacks.Length < 2 then
                let embed = Embeds.pickHack "Attack" attacker defender

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
                    |> Async.AwaitTask

            else
                let builder = DiscordInteractionResponseBuilder()
                let timestamp = updatedAttacks |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
                let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
                builder.Content <- $"No more hacks available, 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

        | None , _ -> do! notYetAHackerMsg ctx
        | _ , None -> do! createSimpleResponseAsync "Your target is not connected to the network, they must join first by using the /redpill command" ctx
    } |> Async.StartAsTask
    :> Task

let defend (ctx : InteractionContext) =
    async {
        let! player = DbService.tryFindPlayer ctx.Member.Id
        match player with
        | Some player ->
            let updatedDefenses = removeExpiredActions (TimeSpan.FromHours(24)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses
            do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }
            if updatedDefenses.Length < 3 then
                let embed = Embeds.pickDefense "Defend" player

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
                    |> Async.AwaitTask
            else
                let builder = DiscordInteractionResponseBuilder()
                let timestamp = updatedDefenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
                let timeRemaining = TimeSpan.FromMinutes(15) - (DateTime.UtcNow - timestamp)
                // TODO: Make this handle hours and minutes
                builder.Content <- $"Cannot add new defense, please wait {timeRemaining.Hours} hours and {timeRemaining.Minutes} minutes to add another defense"

                builder.AsEphemeral true |> ignore

                do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
        | None -> do! notYetAHackerMsg ctx
    } |> Async.StartAsTask
    :> Task

let handleAttack (event : ComponentInteractionCreateEventArgs) =
    let updatePlayer amount attack p =
        { p with Attacks = Array.append [| attack |] p.Attacks ; Bank = Math.Max(p.Bank + amount, 0) }
    async {
        let split = event.Id.Split("-")
        let weapon = Enum.Parse(typedefof<Hack>, split.[1]) :?> Hack
        let ( resultId , targetId ) = UInt64.TryParse split.[2]
        let! resultPlayer = DbService.tryFindPlayer event.User.Id
        let! resultTarget = DbService.tryFindPlayer targetId
        match resultPlayer , resultTarget , true , resultId with
        | Some player , Some target , true , true ->
           let updatedDefenses = removeExpiredActions (TimeSpan.FromHours(24)) (fun (p : Defense) -> p.Timestamp) target.Defenses
           do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }
           let wasSuccessfulHack =
                updatedDefenses
                |> Seq.toArray
                |> Array.map (fun dfn -> int dfn.DefenseType)
                |> Array.map (calculateDamage (int weapon))
                |> Array.contains Weak
           match wasSuccessfulHack with
           | false ->
//                let prize = 1.337f // LEET
                let prize = 13
                let attack = { HackType = enum<Hack>(int weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }

                let! _ =
                  [ DbService.updatePlayer <| updatePlayer prize attack player
                    DbService.updatePlayer { target with Bank = Math.Max(target.Bank - prize, 0)} ]
                    |> Async.Parallel

                let builder = DiscordInteractionResponseBuilder()
                builder.IsEphemeral <- true
                builder.Content <- $"Successfully hacked {split.[3]} using {weapon}! You just won {prize} GoodBoyTokenz!"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                    |> Async.AwaitTask

                let builder = Embeds.eventSuccessfulHack event targetId prize
                let channel = event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle)
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
           | true ->
                let builder = DiscordInteractionResponseBuilder()
                let prize = 2
                builder.IsEphemeral <- true
                builder.Content <- $"Hack failed! {split.[3]} was able to mount a successful defense! You lost {prize} GoodBoyTokenz!"
                do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                    |> Async.AwaitTask

                let attack = { HackType = enum<Hack>(int weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
                do! DbService.updatePlayer <| updatePlayer -prize attack player
                do! DbService.updatePlayer { target with Bank = target.Bank + prize }

                let builder = DiscordMessageBuilder()
                builder.WithContent($"Hacking attempt failed! <@{targetId}> defended hack from {event.User.Username} and took {prize} from them! ") |> ignore
                let channel = (event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle))
                do! channel.SendMessageAsync(builder)
                    |> Async.AwaitTask
                    |> Async.Ignore
        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error occurred processing attack"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let handleDefense (event : ComponentInteractionCreateEventArgs) =
    async {
        let split = event.Id.Split("-")
        let ( shieldResult , shield ) = Shield.TryParse(split.[1])
        let! playerResult = DbService.tryFindPlayer event.User.Id
        match playerResult , shieldResult with
        | Some player , true ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- $"Mounted a {shield} defense for 24 hours"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                |> Async.AwaitTask

            let defense = { DefenseType = shield ; Timestamp = DateTime.UtcNow }
            do! DbService.updatePlayer <| { player with Defenses = Array.append [| defense |] player.Defenses  }

            let builder = DiscordMessageBuilder()
            builder.WithContent($"{event.User.Username} has protected their system!") |> ignore
            let channel = event.Guild.Channels.Values |> Seq.find (fun c -> c.Name = "battle-1")
            do! channel.SendMessageAsync(builder)
                |> Async.AwaitTask
                |> Async.Ignore
        | _ ->
            let builder = DiscordInteractionResponseBuilder()
            builder.IsEphemeral <- true
            builder.Content <- "Error parsing Button Id"
            do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
                    |> Async.AwaitTask
    }

let handleButtonEvent (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
    let task =
        match event.Id with
        | id when id.StartsWith("Attack")  -> handleAttack event
        | id when id.StartsWith("Defend")  -> handleDefense event
        | id when id.StartsWith("Trainer") -> Trainer.handleButtonEvent 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 {
        return! task
    } |> Async.StartAsTask
    :> Task

type HackerGame() =
    inherit ApplicationCommandModule ()

    [<SlashCommand("hack", "Send a hack attack to another player")>]
    member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) =
        let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) ctx.Member.Roles
        if ctx.Channel.Id = GuildEnvironment.channelTraining && hasTraineeRole then
            Trainer.attack ctx target
        else
            attack ctx target

    [<SlashCommand("defend", "Create a passive defense that will last 24 hours")>]
    member this.DefendCommand (ctx : InteractionContext) =
        let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) ctx.Member.Roles
        if ctx.Channel.Id = GuildEnvironment.channelTraining && hasTraineeRole then
            Trainer.defend ctx
        else
            defend ctx