diff --git a/Bot/Embeds.fs b/Bot/Embeds.fs
index d37fe70..8b27d11 100644
--- a/Bot/Embeds.fs
+++ b/Bot/Embeds.fs
@@ -110,13 +110,11 @@ let pickHack actionId attacker defender bonus isTrainer =
 let responseSuccessfulHack (hacker : PlayerData) (target : PlayerData) totalTaken bonus (hack : HackItem) =
     let earnedMoney = totalTaken > 0<GBT>
     
-    let msg = $"You successfully hacked <@{target.DiscordId}> using {hack.Name}!\n\n"
+    let msg = $"{hacker.Name} successfully hacked <@{target.DiscordId}>\n\n"
               + (if earnedMoney then $"**__Total Stolen__**: {totalTaken} 💰$GBT\n" else "")
         
     let bonusMsg =
-        if bonus > 0<GBT>
-            then $"Because your strength is `💪 {hacker.Stats.Strength.Amount}` and your target's strength is `💪 {target.Stats.Strength.Amount}` You stole an extra `{bonus}` 💰$GBT"
-            else ""
+        $"Because your strength is `💪 {hacker.Stats.Strength.Amount}` and your target's strength is `💪 {target.Stats.Strength.Amount}` You stole an extra `{bonus}` 💰$GBT"
     
     let embed =
         DiscordEmbedBuilder()
@@ -129,6 +127,48 @@ let responseSuccessfulHack (hacker : PlayerData) (target : PlayerData) totalTake
         .AddEmbed(embed.Build())
         .AsEphemeral(true)
 
+let responseSuccessfulHack2 successful (hacker : PlayerData) (target : PlayerData) (hackerMember : DiscordMember) (targetMember : DiscordMember) totalTaken bonus (hack : HackItem) =
+    let earnedMoney = totalTaken > 0<GBT>
+    
+    let msg = $"{hacker.Name} successfully hacked <@{target.DiscordId}> using {hack.Name}!\n\n"
+              + (if earnedMoney then $"**__Total Stolen__**: {totalTaken} 💰$GBT\n" else "")
+        
+    let bonusMsg =
+        if bonus > 0<GBT>
+            then $"Because **{hacker.Name}** strength is `💪 {hacker.Stats.Strength.Amount}` and **{target.Name}** strength is `💪 {target.Stats.Strength.Amount}`, they got a `{bonus}` 💰$GBT bonus"
+            else ""
+    
+    let embed1 =
+        DiscordEmbedBuilder()
+          .WithThumbnail(hackGif)
+          .WithColor(DiscordColor.Blurple)
+          .WithTitle("✅  Hack Successful!")
+          .WithDescription($"{msg}\n{bonusMsg}")
+        
+    let h = ( hacker.Name , hackerMember.AvatarUrl )
+    let t = ( target.Name , targetMember.AvatarUrl )
+    let winner = if successful then h else t
+    let loser = if successful then t else h
+    let winnerEmbed =
+        DiscordEmbedBuilder()
+          .WithAuthor(name = fst winner , iconUrl = snd winner)  
+          .WithColor(DiscordColor.Green)
+ 
+    let loserEmbed =
+        DiscordEmbedBuilder()
+          .WithAuthor(name = fst loser , iconUrl = snd loser)  
+          .WithColor(DiscordColor.Red)
+ 
+    winnerEmbed.AddField("Strength", $"{hacker.Stats.Strength.Amount}", true) |> ignore
+    winnerEmbed.AddField("New $GBT Balance", $"`💰` {hacker.Bank} ⋙ `💰` {hacker.Bank + totalTaken} `(+{totalTaken} $GBT)`", true) |> ignore
+    loserEmbed.AddField("Strength", $"{target.Stats.Strength.Amount}", true) |> ignore
+    loserEmbed.AddField("New $GBT Balance", $"`💰` {target.Bank} ⋙ `💰` {target.Bank - totalTaken} `(-{totalTaken} $GBT)`", true) |> ignore
+    let embeds =
+        if successful
+            then [ embed1 ; winnerEmbed ; loserEmbed ] |> List.map (fun e -> e.Build())
+            else [ embed1 ; loserEmbed ; winnerEmbed ] |> List.map (fun e -> e.Build())
+    DiscordMessageBuilder().AddEmbeds(embeds)
+    
 let responseCreatedShield (shield : ShieldItem) =
     let embed = DiscordEmbedBuilder().WithImageUrl(shield.ImageUrl)
     embed.Title <- "Mounted Shield"
@@ -138,11 +178,6 @@ let responseCreatedShield (shield : ShieldItem) =
         .AddEmbed(embed)
         .AsEphemeral(true)
 
-let eventSuccessfulHack (ctx : IDiscordContext) target prize =
-    DiscordMessageBuilder()
-        .WithAllowedMention(UserMention(target.DiscordId))
-        .WithContent($"**{ctx.GetDiscordMember().Username}** successfully hacked **{target.Name}** and took {prize} $GBT! - <@!{target.DiscordId}>")
-
 let getArsenalEmbed (player : PlayerData) =
     DiscordFollowupMessageBuilder()
         .AsEphemeral(true)
diff --git a/Bot/GameTypes.fs b/Bot/GameTypes.fs
index 30afbce..826fe1f 100644
--- a/Bot/GameTypes.fs
+++ b/Bot/GameTypes.fs
@@ -9,6 +9,8 @@ type mins
 [<Measure>]
 type GBT
 
+let gbt x = x * 1<GBT>
+
 type Range = { Min : int ; Max : int }
 
 module Range =
diff --git a/Bot/Games/HackerBattle.fs b/Bot/Games/HackerBattle.fs
index 0b3ccfe..4b75c96 100644
--- a/Bot/Games/HackerBattle.fs
+++ b/Bot/Games/HackerBattle.fs
@@ -109,34 +109,33 @@ let updateCombatants successfulHack (attacker : PlayerData) (defender : PlayerDa
     |> Async.Parallel
     |> Async.Ignore
 
-let successfulHack (ctx : IDiscordContext) attacker defender (hack : HackItem) =
+let hackerResult successfulHack (ctx : IDiscordContext) attacker defender (hack : HackItem) =
     async {
-        let bonus = strengthBonus attacker.Stats.Strength.Amount defender.Stats.Strength.Amount |> (*) 1<GBT>
-        let basePrize = hack.Power * 1<GBT>
-        let prizeAmount = if basePrize + bonus < defender.Bank then basePrize + bonus else defender.Bank
-        do! updateCombatants true attacker defender hack prizeAmount
-
-        let embed = Embeds.responseSuccessfulHack attacker defender prizeAmount bonus hack
-        do! ctx.FollowUp embed |> Async.AwaitTask
-
-        let builder = Embeds.eventSuccessfulHack ctx defender prizeAmount
-        let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
-        do! channel.SendMessageAsync(builder)
+        let prizeAmount , bonus =
+            if successfulHack then
+                let bonus = strengthBonus attacker.Stats.Strength.Amount defender.Stats.Strength.Amount |> gbt
+                let basePrize = gbt hack.Power
+                (if basePrize + bonus < defender.Bank then basePrize + bonus else defender.Bank) , bonus
+            else
+                if hack.Power < int attacker.Bank
+                    then gbt hack.Power , 0<GBT>
+                    else attacker.Bank  , 0<GBT>
+                    
+        let! defenderMember = ctx.GetGuild().GetMemberAsync(defender.DiscordId) |> Async.AwaitTask
+//        let failedMsg = $"Hack failed! {defender.Name} was able to mount a successful defense! You lost {lostAmount} 💰$GBT!"
+        let embed = Embeds.responseSuccessfulHack2 successfulHack attacker defender (ctx.GetDiscordMember()) defenderMember prizeAmount bonus hack
+        do! ctx.GetChannel().SendMessageAsync(embed)
             |> Async.AwaitTask
             |> Async.Ignore
-    }
 
-let failedHack (ctx : IDiscordContext) attacker defender (hack : HackItem) =
-    async {
-        let lostAmount = if hack.Power < int attacker.Bank then hack.Power else int attacker.Bank
-        let msg = $"Hack failed! {defender.Name} was able to mount a successful defense! You lost {lostAmount} 💰$GBT!"
-        do! sendFollowUpMessage ctx msg
-
-        do! updateCombatants false attacker defender hack (-lostAmount * 1<GBT>)
-
-        let builder = DiscordMessageBuilder()
-        builder.WithContent($"Hacking attempt failed! **{defender.Name}** defended hack from **{ctx.GetDiscordMember().Username}** and took {lostAmount} 💰$GBT from them! <@!{defender.DiscordId}>") |> ignore
-        let channel = (ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle))
+        do! updateCombatants successfulHack attacker defender hack prizeAmount
+        
+        let builder = DiscordMessageBuilder().WithAllowedMention(UserMention(defender.DiscordId))
+        if successfulHack then
+            builder.Content <- $"**{ctx.GetDiscordMember().Username}** successfully hacked **{defender.Name}** and took {prizeAmount} $GBT! - <@!{defender.DiscordId}>"
+        else
+            builder.Content <- $"Hacking attempt failed! **{defender.Name}** defended hack from **{ctx.GetDiscordMember().Username}** and took {prizeAmount} 💰$GBT from them! <@!{defender.DiscordId}>"
+        let channel = ctx.GetGuild().GetChannel(GuildEnvironment.channelEventsHackerBattle)
         do! channel.SendMessageAsync(builder)
             |> Async.AwaitTask
             |> Async.Ignore
@@ -162,7 +161,7 @@ let hack (target : DiscordUser) (ctx : IDiscordContext) =
     })
 
 let handleAttack (ctx : IDiscordContext) =
-    executePlayerAction ctx (fun attacker -> async {
+    executePlayerActionNoMsg ctx (fun attacker -> async {
         let tokens = ctx.GetInteractionId().Split("-")
         let hackId = tokens.[1]
         let item = Arsenal.weapons |> Inventory.findItemById hackId
@@ -181,9 +180,7 @@ let handleAttack (ctx : IDiscordContext) =
                 |> function
                    | Ok attacker -> async {
                        let result = runHackerBattle defender hackItem
-                       match result with
-                       | false -> do! successfulHack ctx attacker defender hackItem
-                       | true -> do! failedHack ctx attacker defender hackItem
+                       do! hackerResult (not result) ctx attacker defender hackItem
                        do! Analytics.hackedTarget (ctx.GetDiscordMember()) hackItem.Name (not result)
                     }
                    | Error msg -> Messaging.sendFollowUpMessage ctx msg
@@ -334,7 +331,6 @@ let handleMemberUpdated _ (event : GuildMemberUpdateEventArgs) =
         return ()
     } :> Task
 
-
 type HackerGame() =
     inherit ApplicationCommandModule ()
 
diff --git a/Bot/PlayerInteractions.fs b/Bot/PlayerInteractions.fs
index 7d5a787..b653692 100644
--- a/Bot/PlayerInteractions.fs
+++ b/Bot/PlayerInteractions.fs
@@ -9,7 +9,17 @@ open Degenz.DbService
 let executePlayerAction (ctx : IDiscordContext) (dispatch : PlayerData -> Async<unit>) =
     async {
         let builder = DiscordInteractionResponseBuilder().AsEphemeral(true)
-        do! ctx.Respond(InteractionResponseType.DeferredChannelMessageWithSource, builder) |> Async.AwaitTask
+        do! ctx.Respond(InteractionResponseType.DeferredMessageUpdate, builder) |> Async.AwaitTask
+        let! playerResult = tryFindPlayer (ctx.GetDiscordMember().Id)
+        match playerResult with
+        | Some player -> do! dispatch player
+        | None -> do! Messaging.sendFollowUpMessage ctx "You are currently not a hacker, first use the /redpill command to become one"
+    } |> Async.StartAsTask :> Task
+
+let executePlayerActionNoMsg (ctx : IDiscordContext) (dispatch : PlayerData -> Async<unit>) =
+    async {
+        let builder = DiscordInteractionResponseBuilder().AsEphemeral(true)
+        do! ctx.Respond(InteractionResponseType.DeferredMessageUpdate, builder) |> Async.AwaitTask
         let! playerResult = tryFindPlayer (ctx.GetDiscordMember().Id)
         match playerResult with
         | Some player -> do! dispatch player