217 lines
11 KiB
Forth
217 lines
11 KiB
Forth
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
|
|
|
|
[<Literal>]
|
|
// Degenz Server
|
|
//let battleChannel = 930363007781978142uL
|
|
// My server
|
|
let battleChannel = 927449884204867664uL
|
|
|
|
let attack (ctx : InteractionContext) (target : DiscordUser) =
|
|
async {
|
|
// TODO: We need to check if the player has any active embed hacks going, if not they can cheat
|
|
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 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<DiscordComponent>
|
|
|> builder.AddComponents
|
|
|> ignore
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> 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 builder = DiscordInteractionResponseBuilder()
|
|
builder.AddEmbed (constructEmbed "Pick a defense to mount for 24 hours") |> ignore
|
|
|
|
constructButtons "Defend" (string player.DiscordId) player.Shields
|
|
|> Seq.cast<DiscordComponent>
|
|
|> builder.AddComponents
|
|
|> ignore
|
|
|
|
builder.AsEphemeral true |> ignore
|
|
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> 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 = MathF.Max(p.Bank + amount, 0f) }
|
|
async {
|
|
let split = event.Id.Split("-")
|
|
let weapon = Enum.Parse(typedefof<Weapon>, split.[1]) :?> Weapon
|
|
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 attack = { HackType = enum<Weapon>(int weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
|
|
// TODO: Make a single update instead of two
|
|
do! DbService.updatePlayer <| updatePlayer prize attack player
|
|
do! DbService.updatePlayer { target with Bank = MathF.Max(target.Bank - prize, 0f)}
|
|
|
|
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 = DiscordMessageBuilder()
|
|
builder.WithContent($"{event.User.Username} successfully hacked <@{targetId}> for a total of {prize} GoodBoyTokenz") |> ignore
|
|
let channel = (event.Guild.GetChannel(battleChannel))
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| true ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let prize = 0.223f
|
|
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<Weapon>(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(battleChannel))
|
|
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) =
|
|
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
|
|
|
|
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) =
|
|
attack ctx target
|
|
|
|
[<SlashCommand("defend", "Create a passive defense that will last 24 hours")>]
|
|
member this.DefendCommand (ctx : InteractionContext) = defend ctx
|
|
|
|
|