285 lines
13 KiB
Forth
285 lines
13 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.Messaging
|
|
|
|
let checkPlayerIsAttackingThemselves defender attacker =
|
|
match attacker.DiscordId = defender.DiscordId with
|
|
| true -> Error "You think you're clever? You can't hack yourself, pal."
|
|
| false -> Ok attacker
|
|
|
|
let checkAlreadyHackedTarget defenderId attacker =
|
|
attacker.Events
|
|
|> Array.tryFind (fun pe -> pe.Adversary.Id = defenderId)
|
|
|> function
|
|
| Some event ->
|
|
let cooldown = getTimeText true Game.SameTargetAttackCooldown event.Timestamp
|
|
Error $"You can only hack the same target once every {Game.SameTargetAttackCooldown.Hours} hours, wait {cooldown} to attempt another hack on {event.Adversary.Name}."
|
|
| None -> Ok attacker
|
|
|
|
let checkItemHasCooldown itemId attacker =
|
|
let cooldown =
|
|
attacker.Events
|
|
|> Array.tryFind (fun a -> a.ItemId = itemId)
|
|
|> function
|
|
| Some a -> a.Timestamp
|
|
| None -> DateTime.MinValue
|
|
let item = Armory.getItem itemId
|
|
if DateTime.UtcNow - cooldown > TimeSpan.FromMinutes(int item.Cooldown) then
|
|
Ok attacker
|
|
else
|
|
let cooldown = getTimeText true (TimeSpan.FromMinutes(int item.Cooldown)) cooldown
|
|
let item = Armory.battleItems |> Array.find (fun i -> i.Id = itemId)
|
|
Error $"{item.Name} is currently on cooldown, wait {cooldown} to use it again."
|
|
|
|
let checkHasEmptyHacks attacker =
|
|
match Player.getHacks attacker with
|
|
| [||] -> Error $"You currently do not have any Hacks to steal 💰$GBT from others. Please go to the <#{GuildEnvironment.channelArmory}> and purchase one."
|
|
| _ -> Ok attacker
|
|
|
|
let checkPlayerOwnsWeapon itemId player =
|
|
match player.Inventory |> Array.exists (fun i -> i.Id = itemId) with
|
|
| true -> Ok player
|
|
| false -> Error $"You sold your weapon already, you cheeky bastard..."
|
|
|
|
let checkTargetHasMoney (target : PlayerData) attacker =
|
|
if target.Bank < Game.HackPrize
|
|
then Error $"{target.Name} does not have enough 💰$GBT to steal from, the broke loser. Pick a different target."
|
|
else Ok attacker
|
|
|
|
let checkPlayerHasShieldSlotsAvailable shield player =
|
|
let updatedPlayer = player |> Player.removeExpiredActions false
|
|
let defenses = Player.getShieldEvents updatedPlayer
|
|
match defenses |> Array.length >= 2 with
|
|
| true ->
|
|
let timestamp = defenses |> Array.rev |> Array.head |> fun a -> a.Timestamp // This should be the next expiring timestamp
|
|
let cooldown = getTimeText true (TimeSpan.FromMinutes(int shield.Cooldown)) timestamp
|
|
Error $"You are only allowed two shields at a time. Wait {cooldown} to add another shield"
|
|
| false -> Ok updatedPlayer
|
|
|
|
// TODO H: Need to update the new hacker game mechanics
|
|
let calculateDamage (hack : Item) (shield : Item) =
|
|
if hack.Power < shield.Power
|
|
then Weak
|
|
else Strong
|
|
|
|
let runHackerBattle defender hack =
|
|
defender
|
|
|> Player.removeExpiredActions false
|
|
|> Player.getShieldEvents
|
|
|> Array.map (fun dfn -> Armory.battleItems |> Array.find (fun w -> w.Id = dfn.ItemId))
|
|
|> Array.map (calculateDamage (hack))
|
|
|> Array.contains Weak
|
|
|
|
let updateCombatants attacker defender hack prize =
|
|
let updatePlayer amount attack p =
|
|
{ p with Events = Array.append [| attack |] p.Events ; Bank = max (p.Bank + amount) 0<GBT> }
|
|
let target = { Id = defender.DiscordId ; Name = defender.Name }
|
|
let attack = {
|
|
ItemId = int hack
|
|
Type = PlayerEventType.Hacking
|
|
Adversary = target
|
|
Result = if prize > 0<GBT> then PlayerEventResult.Positive else PlayerEventResult.Negative
|
|
Timestamp = DateTime.UtcNow
|
|
}
|
|
|
|
// TODO: This is what I was talking about, this isn't a "Shield" event, this is a hack event but there's an adversary
|
|
// who loses, so the event itself is to just "hack", so there's no "mugged" event, there's just a failed steal defense
|
|
// or something like that.
|
|
[ DbService.updatePlayer <| updatePlayer prize attack attacker
|
|
DbService.updatePlayer <| Player.modifyBank defender -prize ]
|
|
|> Async.Parallel
|
|
|> Async.Ignore
|
|
|
|
let successfulHack (ctx : IDiscordContext) attacker defender hack =
|
|
async {
|
|
do! updateCombatants attacker defender hack Game.HackPrize
|
|
|
|
let embed = Embeds.responseSuccessfulHack true defender.DiscordId (Armory.getItem hack)
|
|
do! ctx.FollowUp embed |> Async.AwaitTask
|
|
|
|
let builder = Embeds.eventSuccessfulHack ctx defender Game.HackPrize
|
|
let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
}
|
|
|
|
let failedHack (ctx : IDiscordContext) attacker defender hack =
|
|
async {
|
|
let msg = $"Hack failed! {defender.Name} was able to mount a successful defense! You lost {Game.ShieldPrize} $GBT!"
|
|
do! sendFollowUpMessage ctx msg
|
|
|
|
do! updateCombatants attacker defender hack -Game.ShieldPrize
|
|
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"Hacking attempt failed! <@{defender.DiscordId}> defended hack from {ctx.GetDiscordMember().Username} and stole {Game.ShieldPrize} $GBT from them! ") |> ignore
|
|
let channel = (ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle))
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
}
|
|
|
|
let attack (target : DiscordUser) (ctx : IDiscordContext) =
|
|
Game.executePlayerActionWithTarget target ctx (fun attacker defender -> async {
|
|
do! attacker
|
|
|> checkAlreadyHackedTarget defender.DiscordId
|
|
<!> (Player.removeExpiredActions true)
|
|
>>= checkHasEmptyHacks
|
|
>>= checkTargetHasMoney defender
|
|
>>= checkPlayerIsAttackingThemselves defender
|
|
|> function
|
|
| Ok atkr ->
|
|
let embed = Embeds.pickHack "Attack" atkr defender false
|
|
ctx.FollowUp(embed) |> Async.AwaitTask
|
|
| Error msg -> sendFollowUpMessage ctx msg
|
|
})
|
|
|
|
let handleAttack (ctx : IDiscordContext) =
|
|
Game.executePlayerAction ctx (fun attacker -> async {
|
|
let split = ctx.GetInteractionId().Split("-")
|
|
let hackId = int split.[1]
|
|
let hack = enum<HackId>(hackId)
|
|
let ( resultId , targetId ) = UInt64.TryParse split.[2]
|
|
let! resultTarget = DbService.tryFindPlayer targetId
|
|
|
|
match resultTarget , true , resultId with
|
|
| Some defender , true , true ->
|
|
do! attacker
|
|
|> Player.removeExpiredActions false
|
|
|> checkAlreadyHackedTarget defender.DiscordId
|
|
>>= checkPlayerOwnsWeapon hackId
|
|
>>= checkItemHasCooldown hackId
|
|
|> function
|
|
| Ok atkr ->
|
|
runHackerBattle defender (Armory.getItem (int hackId))
|
|
|> function
|
|
| false -> successfulHack ctx atkr defender hackId
|
|
| true -> failedHack ctx attacker defender hackId
|
|
| Error msg -> Messaging.sendFollowUpMessage ctx msg
|
|
| _ -> do! Messaging.sendFollowUpMessage ctx "Error occurred processing attack"
|
|
})
|
|
|
|
let defend (ctx : IDiscordContext) =
|
|
Game.executePlayerAction ctx (fun player -> async {
|
|
if Player.getShields player |> Array.length > 0 then
|
|
let p = Player.removeExpiredActions false player
|
|
let embed = Embeds.pickDefense "Defend" p false
|
|
do! ctx.FollowUp embed |> Async.AwaitTask
|
|
else
|
|
let msg = $"You currently do not have any Shields to protect yourself from hacks. Please go to the <#{GuildEnvironment.channelArmory}> and purchase one."
|
|
do! Messaging.sendFollowUpMessage ctx msg
|
|
})
|
|
|
|
let handleDefense (ctx : IDiscordContext) =
|
|
Game.executePlayerAction ctx (fun player -> async {
|
|
let split = ctx.GetInteractionId().Split("-")
|
|
let shieldId = int split.[1]
|
|
let shield = Armory.getItem shieldId
|
|
|
|
do! player
|
|
|> checkPlayerOwnsWeapon shieldId
|
|
>>= checkPlayerHasShieldSlotsAvailable shield
|
|
>>= checkItemHasCooldown shieldId
|
|
|> handleResultWithResponse ctx (fun _ -> async { // Don't use this player, it removes player cooldowns
|
|
let embed = Embeds.responseCreatedShield (Armory.getItem shieldId)
|
|
do! ctx.FollowUp embed |> Async.AwaitTask
|
|
let defense = {
|
|
ItemId = shieldId
|
|
Type = PlayerEventType.Shielding
|
|
Result = PlayerEventResult.Positive
|
|
Timestamp = DateTime.UtcNow
|
|
Adversary = DiscordPlayer.empty
|
|
}
|
|
do! DbService.updatePlayer <| { player with Events = Array.append [| defense |] player.Events }
|
|
let builder = DiscordMessageBuilder()
|
|
builder.WithContent($"{ctx.GetDiscordMember().Username} has protected their system!") |> ignore
|
|
let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
|
|
do! channel.SendMessageAsync(builder)
|
|
|> Async.AwaitTask
|
|
|> Async.Ignore
|
|
})
|
|
})
|
|
|
|
let arsenal (ctx : IDiscordContext) =
|
|
Game.executePlayerAction ctx (fun player -> async {
|
|
let updatedPlayer = Player.removeExpiredActions false player
|
|
let builder = DiscordFollowupMessageBuilder()
|
|
let embed = DiscordEmbedBuilder()
|
|
embed.AddField("Arsenal", Arsenal.statusFormat updatedPlayer) |> ignore
|
|
builder.AddEmbed(embed) |> ignore
|
|
builder.IsEphemeral <- true
|
|
do! ctx.FollowUp(builder) |> Async.AwaitTask
|
|
do! DbService.updatePlayer updatedPlayer
|
|
})
|
|
|
|
let handleButtonEvent (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
|
|
let eventCtx = DiscordEventContext event :> IDiscordContext
|
|
match event.Id with
|
|
| id when id.StartsWith("Attack") -> handleAttack eventCtx
|
|
| id when id.StartsWith("Defend") -> handleDefense eventCtx
|
|
| id when id.StartsWith("Trainer") -> Trainer.handleButtonEvent eventCtx |> Async.StartAsTask :> Task
|
|
| id when id.StartsWith("Steal") -> Thief.handleSteal eventCtx
|
|
| id when id.StartsWith("RPS") -> RockPaperScissors.handleRPS eventCtx
|
|
| _ ->
|
|
task {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
builder.Content <- $"Incorrect Action identifier {eventCtx.GetInteractionId()}"
|
|
do! eventCtx.Respond InteractionResponseType.ChannelMessageWithSource builder |> Async.AwaitTask
|
|
}
|
|
|
|
type HackerGame() =
|
|
inherit ApplicationCommandModule ()
|
|
|
|
let enforceChannels (ctx : IDiscordContext) (trainerFn : IDiscordContext -> Task) (battleFn : IDiscordContext -> Task) =
|
|
match ctx.GetChannel().Id with
|
|
| id when id = GuildEnvironment.channelTraining ->
|
|
let hasTraineeRole = Seq.exists (fun (r : DiscordRole) -> r.Id = GuildEnvironment.roleTrainee) (ctx.GetDiscordMember().Roles)
|
|
if hasTraineeRole then
|
|
trainerFn ctx
|
|
else
|
|
task {
|
|
let msg = $"You're currently not in training, either go to <#{GuildEnvironment.channelBattle}> to hack for real, "
|
|
+ "or restart training by clicking on the Pinned embed's button up top."
|
|
do! Messaging.sendSimpleResponse ctx msg
|
|
}
|
|
| id when id = GuildEnvironment.channelBattle ->
|
|
battleFn ctx
|
|
| _ ->
|
|
task {
|
|
let msg = $"You must go to <#{GuildEnvironment.channelBattle}> channel to hack, shield, or check your arsenal"
|
|
do! Messaging.sendSimpleResponse ctx msg
|
|
}
|
|
|
|
[<SlashCommand("arsenal", "Get the Hacks and Shields you own, and which ones are active")>]
|
|
member this.Arsenal (ctx : InteractionContext) =
|
|
enforceChannels (DiscordInteractionContext ctx) (Trainer.handleArsenal) arsenal
|
|
|
|
[<SlashCommand("hack", "Send a hack attack to another player")>]
|
|
member this.AttackCommand (ctx : InteractionContext, [<Option("target", "The player you want to hack")>] target : DiscordUser) =
|
|
enforceChannels (DiscordInteractionContext ctx) (Trainer.attack target) (attack target)
|
|
|
|
[<SlashCommand("shield", "Create a passive shield that will protect you for a certain time")>]
|
|
member this.ShieldCommand (ctx : InteractionContext) =
|
|
enforceChannels (DiscordInteractionContext ctx) Trainer.defend defend
|
|
|
|
// [<SlashCommand("test-autocomplete", "Create a passive defense that will last 24 hours")>]
|
|
member this.TestAutoComplete (ctx : InteractionContext) =
|
|
async {
|
|
let builder = DiscordInteractionResponseBuilder()
|
|
builder.IsEphemeral <- true
|
|
do! ctx.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
|
|
|> Async.AwaitTask
|
|
} |> Async.StartAsTask
|
|
:> Task
|
|
|
|
|
|
|