Change events so it's a positive/negative dynamic and can be shared

Bot/Game.fs

@@ -68,10 +68,10 @@ module Player =
     let getShields (player : PlayerData) = getItems ItemType.Shield player
     let getHackEvents player =
         player.Events
-        |> Array.filter (fun act -> match act.Type with PlayerEventType.Hack -> true | _ -> false || act.ItemId < 12)
+        |> Array.filter (fun act -> match act.Type with PlayerEventType.Hacking -> true | _ -> false || act.ItemId < 12)
     let getShieldEvents player =
         player.Events
-        |> Array.filter (fun act -> match act.Type with PlayerEventType.Shield -> true | _ -> false || act.ItemId < 12)
+        |> Array.filter (fun act -> match act.Type with PlayerEventType.Shielding -> true | _ -> false || act.ItemId < 12)
 
     // TODO: This parameter is a result of putting the cooldown on the attack side. Put the cooldown on the defender
     // side and only check if it's the same target, we need to refactor Actions
@@ -89,9 +89,9 @@ module Player =
                     |> int
 
                 match act.Type , filterByAttackCooldown with
-                | PlayerEventType.Hack    , true  -> System.DateTime.UtcNow - act.Timestamp < System.TimeSpan.FromMinutes(itemCooldown)
+                | PlayerEventType.Hacking    , true  -> System.DateTime.UtcNow - act.Timestamp < System.TimeSpan.FromMinutes(itemCooldown)
-                | PlayerEventType.Hack    , false -> System.DateTime.UtcNow - act.Timestamp < Game.SameTargetAttackCooldown
+                | PlayerEventType.Hacking    , false -> System.DateTime.UtcNow - act.Timestamp < Game.SameTargetAttackCooldown
-                | PlayerEventType.Shield  , _     -> System.DateTime.UtcNow - act.Timestamp < System.TimeSpan.FromMinutes(itemCooldown)
+                | PlayerEventType.Shielding  , _     -> System.DateTime.UtcNow - act.Timestamp < System.TimeSpan.FromMinutes(itemCooldown)
                 | _ -> System.DateTime.UtcNow - act.Timestamp < System.TimeSpan.FromMinutes(itemCooldown))
         { player with Events = actions }
 
@@ -110,14 +110,14 @@ module Arsenal =
             let hacks , defenses =
                 actions
                 |> Array.filter (fun act -> act.ItemId < 12)
-                |> Array.partition (fun act -> match act.Type with PlayerEventType.Hack -> true | _ -> false)
+                |> Array.partition (fun act -> match act.Type with PlayerEventType.Hacking -> true | _ -> false)
             let hacks = hacks |> Array.take (min hacks.Length 10)
             hacks
             |> Array.append defenses
             |> Array.map (fun act ->
                 let item = Armory.getItem act.ItemId
                 match act.Type with
-                | PlayerEventType.Hack ->
+                | PlayerEventType.Hacking ->
                     let cooldown = Messaging.getTimeText false Game.SameTargetAttackCooldown act.Timestamp
                     $"Hacked {act.Adversary.Name} {cooldown} ago"
                 | _ ->

Bot/HackerBattle.fs

@@ -82,9 +82,9 @@ let updateCombatants attacker defender hack prize =
     let target = { Id = defender.DiscordId ; Name = defender.Name }
     let attack = {
         ItemId = int hack
-        Type = PlayerEventType.Hack
+        Type = PlayerEventType.Hacking
         Adversary = target
-        Result = if prize > 0<GBT> then PlayerEventResult.Successful else PlayerEventResult.Failed
+        Result = if prize > 0<GBT> then PlayerEventResult.Positive else PlayerEventResult.Negative
         Timestamp = DateTime.UtcNow
     }
 
@@ -191,8 +191,8 @@ let handleDefense (ctx : IDiscordContext) =
                 do! ctx.FollowUp embed |> Async.AwaitTask
                 let defense = {
                     ItemId = shieldId
-                    Type = PlayerEventType.Shield
+                    Type = PlayerEventType.Shielding
-                    Result = PlayerEventResult.Successful
+                    Result = PlayerEventResult.Positive
                     Timestamp = DateTime.UtcNow
                     Adversary = DiscordPlayer.empty
                 }

Bot/Thief.fs

@@ -85,7 +85,7 @@ let checkVictimStealingCooldown defender attacker =
     defender
     |> Player.removeExpiredActions false
     |> Player.getShieldEvents
-    |> Array.tryFind (fun pe -> pe.Type = PlayerEventType.Mugged)
+    |> Array.tryFind (fun pe -> pe.Type = PlayerEventType.Steal && pe.Result = PlayerEventResult.Negative)
     |> function
        | Some act ->
            let cooldown = VictimRecovery - (DateTime.UtcNow - act.Timestamp)
@@ -161,11 +161,11 @@ let handleSteal (ctx : IDiscordContext) =
             do! Messaging.sendFollowUpEmbed ctx (embed.Build())
             match! DbService.tryFindPlayer targetId with
             | Some t ->
-                let mugged = { ItemId = -1 ; Type = PlayerEventType.Mugged ; Result = PlayerEventResult.Failed ; Adversary = player.basicPlayer ; Timestamp = DateTime.UtcNow }
+                let mugged = { ItemId = -1 ; Type = PlayerEventType.Steal ; Result = PlayerEventResult.Negative ; Adversary = player.basicPlayer ; Timestamp = DateTime.UtcNow }
                 let actions = t |> Player.removeExpiredActions false |> fun p -> Array.append [| mugged |] p.Events
                 do! DbService.updatePlayer { t with Bank = max (t.Bank - prize) 0<GBT> ; Events = actions }
             | None -> ()
-            let stole = { ItemId = -1 ; Type = PlayerEventType.Steal ; Result = PlayerEventResult.Successful ; Adversary = dp ; Timestamp = DateTime.UtcNow }
+            let stole = { ItemId = -1 ; Type = PlayerEventType.Steal ; Result = PlayerEventResult.Positive ; Adversary = dp ; Timestamp = DateTime.UtcNow }
             let actions = player |> Player.removeExpiredActions false |> fun p -> Array.append [| stole |] p.Events
             do! DbService.updatePlayer { player with Bank = player.Bank + prize ; XP = player.XP + xp ; Events = actions }
             let newLevel = XP.getLevel (player.XP + xp)

Bot/Trainer.fs

@@ -142,8 +142,7 @@ let handleAttack (ctx : IDiscordContext) =
 
         let sb = StringBuilder("Here, ")
 
-        let! achievements = DbService.getAchievements player.DiscordId
+        let isFirstTrainer = player.Achievements |> Seq.contains trainerAchievement |> not
-        let isFirstTrainer = achievements |> Option.map (Seq.contains trainerAchievement >> not) |> Option.defaultValue true
         if isFirstTrainer then
             do! DbService.addAchievement player.DiscordId trainerAchievement
 
@@ -173,14 +172,14 @@ let handleAttack (ctx : IDiscordContext) =
                     Events = [
                         { PlayerEvent.Timestamp = System.DateTime.UtcNow
                           PlayerEvent.Adversary = { Id = GuildEnvironment.botIdHackerBattle ; Name = "Sensei" }
-                          PlayerEvent.Type = PlayerEventType.Shield
+                          PlayerEvent.Type = PlayerEventType.Shielding
-                          PlayerEvent.Result = PlayerEventResult.Successful
+                          PlayerEvent.Result = PlayerEventResult.Positive
                           PlayerEvent.ItemId = defaultHack.Id }
                         if not hasShields && Array.exists (fun act -> act.ItemId = freeShield.Id) player.Events |> not then {
                           PlayerEvent.Timestamp = System.DateTime.UtcNow
                           PlayerEvent.Adversary = { Id = GuildEnvironment.botIdHackerBattle ; Name = "Sensei" }
-                          PlayerEvent.Type = PlayerEventType.Shield
+                          PlayerEvent.Type = PlayerEventType.Shielding
-                          PlayerEvent.Result = PlayerEventResult.Successful
+                          PlayerEvent.Result = PlayerEventResult.Positive
                           PlayerEvent.ItemId = defaultHack.Id }
                     ] |> Seq.toArray
                       |> Array.append player.Events

DbService/DbService.fs

@@ -7,18 +7,6 @@ open MongoDB.Bson.Serialization
 open MongoDB.Driver
 open Degenz.Types
 
-[<CLIMutable>]
-type AttackAction =
-    { ActionId : int
-      Result : bool
-      Target : DiscordPlayer
-      Timestamp : DateTime }
-
-[<CLIMutable>]
-type DefenseAction =
-    { ActionId : int
-      Timestamp : DateTime }
-
 [<CLIMutable>]
 type PlayerEntry =
     { DiscordId : uint64

Shared/Shared.fs

@@ -68,17 +68,15 @@ module Types =
         with static member empty = { Id = 0uL ; Name = "None" }
 
     type PlayerEventResult =
-        | Successful = 0
+        | Positive = 0
         | Neutral = 1
-        | Failed = 2
+        | Negative = 2
 
     type PlayerEventType =
-        | Hack = 0
+        | Hacking = 0
-        | Shield = 1
+        | Shielding = 1
         | Steal = 2
-        | Mugged = 3
         | Imprison = 3
-        | Imprisoned = 3
 
     [<CLIMutable>]
     type PlayerEvent =
@@ -88,6 +86,7 @@ module Types =
           ItemId : int
           Timestamp : DateTime }
 
+    [<CLIMutable>]
     type PlayerTraits = {
         Strength : int
         Focus : int