304 lines
14 KiB
Forth
304 lines
14 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
|
|
|
|
let getTimeTillCooldownFinishes (timespan : TimeSpan) timestamp =
|
|
let timeRemaining = timespan - (DateTime.UtcNow - timestamp)
|
|
if timeRemaining.Hours > 0 then
|
|
$"{timeRemaining.Hours} hours"
|
|
elif timeRemaining.Minutes > 0 then
|
|
$"{timeRemaining.Minutes} minutes"
|
|
else
|
|
$"{timeRemaining.Seconds} seconds"
|
|
|
|
let checkForExistingHack defenderId attacker =
|
|
let updatedAttacks =
|
|
attacker.Attacks
|
|
|> removeExpiredActions (TimeSpan.FromHours(24)) (fun atk -> atk.Timestamp)
|
|
updatedAttacks
|
|
|> Array.tryFind (fun a -> a.Target.Id = defenderId)
|
|
|> function
|
|
| Some attack ->
|
|
let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(24)) attack.Timestamp
|
|
Error $"You can only hack the same target once every 24 hours, wait {cooldown} to attempt another hack on {attack.Target.Name}."
|
|
| None ->
|
|
Ok attacker
|
|
|
|
let checkIfHackHasCooldown hack attacker =
|
|
let mostRecentHackAttack =
|
|
attacker.Attacks
|
|
|> Array.tryFind (fun a -> a.HackType = hack)
|
|
|> function
|
|
| Some a -> a.Timestamp
|
|
| None -> DateTime.MinValue
|
|
if DateTime.UtcNow - mostRecentHackAttack > TimeSpan.FromMinutes(5) then
|
|
Ok attacker
|
|
else
|
|
let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromMinutes(5)) mostRecentHackAttack
|
|
Error $"{hack} is currently on cooldown, wait {cooldown} to use it again."
|
|
|
|
let checkIfInventoryIsEmpty attacker =
|
|
match attacker.Weapons with
|
|
| [||] -> Error $"You currently do not have any Hacks to use against others. Please go to the store and purchase one."
|
|
| _ -> Ok attacker
|
|
|
|
let calculateDamage (hack: int) (shield: int) =
|
|
let hackClass = getClass hack
|
|
let protectionClass = getClass shield
|
|
|
|
match hackClass, protectionClass with
|
|
| h, p when h = p -> Weak
|
|
| _ -> Strong
|
|
|
|
let runHackerBattle defender hack =
|
|
defender.Defenses
|
|
|> removeExpiredActions (TimeSpan.FromHours(6)) (fun (pro : Defense) -> pro.Timestamp)
|
|
|> Seq.toArray
|
|
|> Array.map (fun dfn -> int dfn.DefenseType)
|
|
|> Array.map (calculateDamage (int hack))
|
|
|> Array.contains Weak
|
|
|
|
let updateCombatants attacker defender hack prize =
|
|
let updatePlayer amount attack p =
|
|
{ p with Attacks = Array.append [| attack |] p.Attacks ; Bank = Math.Max(p.Bank + amount, 0) }
|
|
let attack = { HackType = enum<Hack>(int hack) ; Timestamp = DateTime.UtcNow ; Target = { Id = defender.DiscordId ; Name = defender.Name } }
|
|
|
|
[ DbService.updatePlayer <| updatePlayer prize attack attacker
|
|
DbService.updatePlayer <| modifyPlayerBank defender -prize ]
|
|
|> Async.Parallel
|
|
|> Async.Ignore
|
|
|
|
let successfulHack (event : ComponentInteractionCreateEventArgs) attacker defender hack =
|
|
async {
|
|
let prize = 3
|
|
|
|
do! updateCombatants attacker defender hack prize
|
|
|
|
let embed = DiscordEmbedBuilder()
|
|
embed.ImageUrl <- Embeds.getHackGif hack
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.AddEmbed embed |> ignore
|
|
builder.Content <- $"Successfully hacked {defender.Name} using {hack}! You just won {prize} GoodBoyTokenz!"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
|
|
let builder = Embeds.eventSuccessfulHack event defender.DiscordId prize
|
|
let channel = event.Guild.GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
}
|
|
|
|
let failedHack (event : ComponentInteractionCreateEventArgs) attacker defender hack =
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let prize = 2
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Hack failed! {defender.Name} was able to mount a successful defense! You lost {prize} GoodBoyTokenz!"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
|
|
do! updateCombatants attacker defender hack -prize
|
|
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"Hacking attempt failed! <@{defender.DiscordId}> 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 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 hackAttempt =
|
|
checkForExistingHack defender.DiscordId attacker
|
|
|> Result.bind checkIfInventoryIsEmpty
|
|
match hackAttempt with
|
|
| Ok _ ->
|
|
let embed = Embeds.pickHack "Attack" attacker defender
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
|
|
|> Async.AwaitTask
|
|
| Error msg ->
|
|
let builder =
|
|
DiscordInteractionResponseBuilder()
|
|
.WithContent(msg)
|
|
.AsEphemeral(true)
|
|
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 handleAttack (event : ComponentInteractionCreateEventArgs) =
|
|
async {
|
|
let split = event.Id.Split("-")
|
|
let hack = 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
|
|
|
|
// TODO: Do not let player hack themselves
|
|
match resultPlayer , resultTarget , true , resultId with
|
|
| Some attacker , Some defender , true , true ->
|
|
do! checkForExistingHack defender.DiscordId attacker
|
|
|> Result.bind (checkIfHackHasCooldown hack)
|
|
|> function
|
|
| Ok _ ->
|
|
runHackerBattle defender hack
|
|
|> function
|
|
| false -> successfulHack event attacker defender hack
|
|
| true -> failedHack event attacker defender hack
|
|
| Error msg ->
|
|
let builder =
|
|
DiscordInteractionResponseBuilder()
|
|
.WithContent(msg)
|
|
.AsEphemeral(true)
|
|
event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
| _ ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- "Error occurred processing attack"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
}
|
|
|
|
let defend (ctx : InteractionContext) =
|
|
async {
|
|
let! player = DbService.tryFindPlayer ctx.Member.Id
|
|
match player with
|
|
| Some player ->
|
|
if player.Shields.Length > 0 then
|
|
let embed = Embeds.pickDefense "Defend" player
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, embed)
|
|
|> Async.AwaitTask
|
|
else
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.Content <- $"You currently do not have any Shields to protect your system. Please go to the store and purchase one."
|
|
builder.AsEphemeral true |> ignore
|
|
do! ctx.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
| None -> do! notYetAHackerMsg ctx
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
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 updatedDefenses = removeExpiredActions (TimeSpan.FromHours(6)) (fun (pro : Defense) -> pro.Timestamp) player.Defenses
|
|
let alreadyUsedShield = updatedDefenses |> Array.exists (fun d -> d.DefenseType = shield)
|
|
|
|
match alreadyUsedShield , updatedDefenses.Length < 2 with
|
|
| false , true ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
let embed = DiscordEmbedBuilder()
|
|
embed.ImageUrl <- Embeds.getShieldGif shield
|
|
builder.IsEphemeral <- true
|
|
builder.AddEmbed embed |> ignore
|
|
builder.Content <- $"Mounted a {shield} defense for 6 hours"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, 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.GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
| _ , false ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
let timestamp = updatedDefenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
|
|
let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(6)) timestamp
|
|
builder.Content <- $"You are only allowed two shields at a time. Wait {cooldown} minutes to add another shield"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }
|
|
| true , _ ->
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
let timestamp = updatedDefenses |> Array.find (fun d -> d.DefenseType = shield) |> fun a -> a.Timestamp
|
|
let cooldown = getTimeTillCooldownFinishes (TimeSpan.FromHours(6)) timestamp
|
|
builder.Content <- $"{shield} shield is already in use. Wait {cooldown} minutes to use this shield again"
|
|
do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
do! DbService.updatePlayer <| { player with Defenses = updatedDefenses }
|
|
|
|
| _ ->
|
|
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
|
|
|
|
// [<SlashCommand("test-autocomplete", "Create a passive defense that will last 24 hours")>]
|
|
member this.TestAutoComplete (ctx : InteractionContext) =
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
// builder.WithContent("Not working")
|
|
builder.IsEphemeral <- true
|
|
do! ctx.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
|
|
|