Fix a few bugs with the store and hacker game

HackerBattle/Commands.fs

@@ -96,11 +96,11 @@ let handleAttack (event : ComponentInteractionCreateEventArgs) =
         { p with Attacks = Array.append [| attack |] p.Attacks ; Bank = MathF.Max(p.Bank + amount, 0f) }
     async {
         let split = event.Id.Split("-")
-        let  ( resultHack , weapon ) = Weapon.TryParse(split.[1])
+        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 , resultHack , resultId with
+        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 }
@@ -108,12 +108,12 @@ let handleAttack (event : ComponentInteractionCreateEventArgs) =
                 updatedDefenses
                 |> Seq.toArray
                 |> Array.map (fun dfn -> int dfn.DefenseType)
-                |> Array.map (calculateDamage weapon)
+                |> Array.map (calculateDamage (int weapon))
                 |> Array.contains Weak
            match wasSuccessfulHack with
            | false ->
                 let prize = 1.337f // LEET
-                let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
+                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 = MathF.Max(target.Bank - prize, 0f)}
 
@@ -137,11 +137,12 @@ let handleAttack (event : ComponentInteractionCreateEventArgs) =
                 do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                     |> Async.AwaitTask
 
-                let attack = { HackType = enum<Weapon>(weapon) ; Timestamp = DateTime.UtcNow ; Target = { Id = targetId ; Name = split.[3] } }
+                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} and took {prize} from them! ") |> ignore
+                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
@@ -163,7 +164,7 @@ let handleDefense (event : ComponentInteractionCreateEventArgs) =
         | Some player , true ->
             let builder = DiscordInteractionResponseBuilder()
             builder.IsEphemeral <- true
-            builder.Content <- $"Mounted a {shield} defense for 1 hour"
+            builder.Content <- $"Mounted a {shield} defense for 24 hours"
             do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
                 |> Async.AwaitTask
 

HackerBattle/HackerBattle.fs

@@ -19,7 +19,7 @@ type HackerGame() =
     member this.DefendCommand (ctx : InteractionContext) = Commands.defend ctx
 
 let config = DiscordConfiguration()
-config.Token <- "OTIyNDIyMDIyMTI1MDEwOTU1.YcBOcw.JxfW1CSIwEO7j6RbRFCnPZ-HoTk"
+config.Token <- "OTMyMzI5NDAzNjYzNDEzMjQ4.YeRZaw.ZyCo5L8HFsCvx8JuhdAwqrH3hZI"
 config.TokenType <- TokenType.Bot
 config.Intents <- DiscordIntents.All
 //config.MinimumLogLevel <- Microsoft.Extensions.Logging.LogLevel.Trace

PlayerInteractions/PlayerInteractions.fs

@@ -134,8 +134,6 @@ config.Intents <- DiscordIntents.All
 
 let client = new DiscordClient(config)
 
-//client.add_ComponentInteractionCreated(AsyncEventHandler(handleButtonEvent))
-
 let slash = client.UseSlashCommands()
 
 // My server

Shared/Shared.fs

@@ -95,8 +95,8 @@ let notYetAHackerMsg =
 let hackDescription = ""
 
 let statusFormat player =
-    $"Hack Inventory: {player.Weapons}
+    $"Hack Inventory: {player.Weapons |> Array.toList}
-Shield Inventory: {player.Shields}
+Shield Inventory: {player.Shields |> Array.toList}
 Active Hacks: {player.Attacks |> Array.toList}
 Active Defenses: {player.Defenses |> Array.toList}
 Bank: {player.Bank}"

Store/Store.fs

@@ -111,8 +111,7 @@ module Commands =
                     |> Array.iter
                         (fun wps ->
                             wps
-                            |> Array.map (fun w ->
+                            |> Array.map (fun w -> DiscordButtonComponent(ButtonStyle.Primary, $"Weapon-{w}", $"{w}"))
-                                DiscordButtonComponent(ButtonStyle.Primary, $"{player.DiscordId}-Weapon-{w}", $"{w}"))
                             |> Seq.cast<DiscordComponent>
                             |> builder.AddComponents
                             |> ignore)
@@ -120,8 +119,7 @@ module Commands =
                     |> Array.iter
                         (fun shs ->
                             shs
-                            |> Array.map (fun s ->
+                            |> Array.map (fun s -> DiscordButtonComponent(ButtonStyle.Primary, $"Shield-{s}", $"{s}"))
-                                DiscordButtonComponent(ButtonStyle.Primary, $"{player.DiscordId}-Shield-{s}", $"{s}"))
                             |> Seq.cast<DiscordComponent>
                             |> builder.AddComponents
                             |> ignore)
@@ -137,15 +135,45 @@ module Commands =
         } |> Async.StartAsTask
           :> Task
 
-let handleSellButtonEvents (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
+    let handleSellButtonEvents (_ : DiscordClient) (event : ComponentInteractionCreateEventArgs) =
-    async {
+        async {
-        let builder = DiscordInteractionResponseBuilder()
+            let! playerResult = DbService.tryFindPlayer event.User.Id
-        builder.IsEphemeral <- true
+            match playerResult with
-        builder.Content <- $"{event.Id}"
+            | Some player ->
-        do! event.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
+                let split = event.Id.Split("-")
-                |> Async.AwaitTask
+                let itemType = match split.[0] with "Weapon" -> ItemType.Weapon | _ -> ItemType.Shield
-    } |> Async.StartAsTask
+                let itemName = split.[1]
-    :> Task
+                match itemType with
+                | ItemType.Weapon ->
+                    let item = getItems ItemType.Weapon |> Array.find (fun w -> w.Name = itemName)
+                    let salePrice = item.Cost / 2.f
+                    let updatedWeapons = player.Weapons |> Array.filter (fun (w : Weapon) -> string w <> itemName)
+                    let updatedPlayer = { player with Bank = player.Bank + salePrice ; Weapons = updatedWeapons }
+                    do! DbService.updatePlayer updatedPlayer
+                    let builder = DiscordInteractionResponseBuilder()
+                    builder.IsEphemeral <- true
+                    builder.Content <- $"Sold weapon {itemName} for {salePrice}! Current Balance: {updatedPlayer.Bank}"
+                    do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
+                        |> Async.AwaitTask
+                | ItemType.Shield ->
+                    let item = getItems ItemType.Shield |> Array.find (fun s -> s.Name = itemName)
+                    let salePrice = item.Cost / 2.f
+                    let updatedShields = player.Shields |> Array.filter (fun (s : Shield) -> string s <> itemName)
+                    let updatedPlayer = { player with Bank = player.Bank + salePrice ; Shields = updatedShields }
+                    do! DbService.updatePlayer updatedPlayer
+                    let builder = DiscordInteractionResponseBuilder()
+                    builder.IsEphemeral <- true
+                    builder.Content <- $"Sold shield {itemName} for {salePrice}! Current Balance: {updatedPlayer.Bank}"
+                    do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
+                        |> Async.AwaitTask
+            | None ->
+                let builder = DiscordInteractionResponseBuilder()
+                builder.IsEphemeral <- true
+                builder.Content <- "An error occurred and the user doesn't not exist"
+                do! event.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, builder)
+                    |> Async.AwaitTask
+        } |> Async.StartAsTask
+        :> Task
 
 type EmptyGlobalCommandToAvoidFamousDuplicateSlashCommandsBug() = inherit ApplicationCommandModule ()
 
@@ -168,14 +196,14 @@ type Store() =
         Commands.sellItem ctx
 
 let config = DiscordConfiguration()
-config.Token <- "OTIyNDIyMDIyMTI1MDEwOTU1.YcBOcw.JxfW1CSIwEO7j6RbRFCnPZ-HoTk"
+config.Token <- "OTMyMzA3NTE0ODc4NDg4NjY2.YeRFCA.3NXX4tLObXU3rVgPt8D1fE58FnY"
 config.TokenType <- TokenType.Bot
 config.Intents <- DiscordIntents.All
 //config.MinimumLogLevel <- Microsoft.Extensions.Logging.LogLevel.Trace
 
 let client = new DiscordClient(config)
 
-client.add_ComponentInteractionCreated(AsyncEventHandler(handleSellButtonEvents))
+client.add_ComponentInteractionCreated(AsyncEventHandler(Commands.handleSellButtonEvents))
 
 let slash = client.UseSlashCommands()