Adds overlays for modal, adds MAX chance geld required

app/src/components/BossInfo.tsx

@@ -2,7 +2,7 @@ import { formatUnits } from "viem"
 import { BossLevel, usePlayer } from "../providers/PlayerProvider"
 import styles from "../styles/Info.module.css"
 import { useEffect, useReducer, useRef } from "react"
-import { calculateBalance } from "./Counter"
+import { calculateBalance, toReadable } from "./Counter"
 
 export const bossLevelToClass: Record<BossLevel, string> = {
   0: styles.boss0,
@@ -14,7 +14,7 @@ export const bossLevelToClass: Record<BossLevel, string> = {
   6: styles.boss6,
 }
 
-const bossToName: Record<BossLevel, string> = {
+export const bossToName: Record<BossLevel, string> = {
   0: "Gluttonous",
   1: "Slothful",
   2: "Lusty",
@@ -24,7 +24,7 @@ const bossToName: Record<BossLevel, string> = {
   6: "Greedy",
 }
 
-const bossToReward: Record<BossLevel, bigint> = {
+export const bossToReward: Record<BossLevel, bigint> = {
   0: BigInt("200000000000000000"),
   1: BigInt("28274420000000000000"),
   2: BigInt("174191628800000000000"),
@@ -70,11 +70,12 @@ const BossInfo = () => {
   const [, render] = useReducer(p => !p, false);
   useEffect(() => {
     const tickInterval = setInterval(() => {
-      chanceToDefeat.current = getBossChanceToDefeat(boss?.level ?? 0, calculateBalance(
+      const _balance = calculateBalance(
         balance ?? BigInt(0),
         army?.profit_per_second ?? BigInt(0),
         player?.last_raided_at ?? BigInt(0)
-      ))
+      );
+      chanceToDefeat.current = getBossChanceToDefeat(boss?.level ?? 0, _balance)
       render();
     }, 100);
     return () => clearInterval(tickInterval)
@@ -86,6 +87,7 @@ const BossInfo = () => {
       <strong>{parseFloat((chanceToDefeat.current * 100).toFixed(2))} % to slay</strong>{" "}
       {chanceToDefeat.current == maxChance ? <small className={styles.maxed}>(MAXED)</small> : <small>(Max {maxChance * 100}%)</small>}
     </p>
+    <p><small>{toReadable(bossToBossPower[boss?.level ?? 0])} GELD = max chance</small></p>
   </div>
 }
 

app/src/components/BossOutcomeModal.tsx

@@ -0,0 +1,41 @@
+import { formatUnits } from "viem";
+import { usePlayer } from "../providers/PlayerProvider";
+import styles from "../styles/Modal.module.css";
+import bgStyles from "../styles/Background.module.css";
+import { bossToName, bossToReward } from "./BossInfo";
+import { bossLevelToClass } from "./Boss";
+
+
+interface BossOutcomeModalProps {
+  setIsOpen: (val: boolean) => void,
+}
+
+const BossOutcomeModal = ({ setIsOpen }: BossOutcomeModalProps) => {
+  const { lastBossResult } = usePlayer();
+  if (lastBossResult == null) return null;
+
+  const outcome = lastBossResult.reward != BigInt(0);
+  const ascended = lastBossResult.prestigeGained;
+
+  const text = outcome ? <span>and you <strong className={styles.won}>won!</strong> 🤩</span> : <span>and you <strong className={styles.lost}>lost</strong> 😔</span>;
+  const rewardAmount = parseFloat(parseFloat(formatUnits(bossToReward[lastBossResult.level], 18).toString()).toFixed(4));
+  const rewardText =
+    ascended ? <p>You won <strong>{rewardAmount} RGCVII</strong> and <strong>ASCENDED!!!</strong>. This means you beat the bosses and gained a <strong>Prestige level</strong>. Your GELD is now forfeit, but your legend lives on.</p>
+      : outcome ? <p>You won <strong>{rewardAmount} RGCVII</strong></p>
+        : <p>Your GELD is now forfeit.<br />Try again 💪 we know you can do it!</p>
+
+  const bossName = bossToName[lastBossResult.variant];
+  const bossClass = bossLevelToClass[lastBossResult.variant];
+
+  return <div className={`${styles.modal} ${styles.bossModal}`}>
+    <h2>You battled {bossName} Moloch!</h2>
+    <div className={`${bgStyles.boss} ${bossClass} ${styles.image}`} />
+    <p className={styles.outcome}>{text}</p>
+    {rewardText}
+    <div>
+      <button onClick={() => setIsOpen(false)}>Onward!</button>
+    </div>
+  </div>
+}
+
+export default BossOutcomeModal 

app/src/components/RegistrationModal.tsx

@@ -1,6 +1,7 @@
 import { useCallback } from "react";
 import { usePlayer } from "../providers/PlayerProvider";
 import styles from "../styles/Modal.module.css";
+import bgStyles from "../styles/Background.module.css";
 
 interface RegistrationModalProps {
   isOpen: boolean;
@@ -14,13 +15,13 @@ const RegistrationModal = ({ isOpen, setIsOpen }: RegistrationModalProps) => {
     setIsOpen(false);
   }, [register, setIsOpen])
   if (!isOpen) return null;
-  return <div className={styles.modal}>
-    <h2>Insert coins to continue</h2>
+  return <div className={bgStyles.leaderboardOverlay}><div className={styles.modal}>
+    <h2 style={{ textAlign: "center" }}>Insert coins to continue</h2>
     <div>
       <button onClick={() => onRegister("RGCVII")}>500 RGCVII</button>
       <button onClick={() => onRegister("ETH")}>0.0005 ETH</button>
     </div>
-  </div>
+  </div></div>
 }
 
 export default RegistrationModal

app/src/providers/PlayerProvider.tsx

@@ -1,9 +1,11 @@
-import React, { createContext, ReactNode, useCallback, useContext, useEffect, useState } from 'react'
+import React, { createContext, ReactNode, useCallback, useContext, useEffect, useRef, useState } from 'react'
 import { useAccount, useReadContract, useWriteContract } from 'wagmi'
 import contractAbi from "../../../out/RaidGeld.sol/RaidGeld.json"
 import { Hash, parseEther } from 'viem'
 import contracts from '../../contract_address'
 import WaitingForTxModal from '../components/WaitingForTxModal'
+import BossOutcomeModal from '../components/BossOutcomeModal'
+import styles from "../styles/Background.module.css"
 
 const { contractAddress, daoTokenAddress } = contracts
 const abi = contractAbi.abi
@@ -33,11 +35,20 @@ export interface Boss {
   variants: [BossLevel, BossLevel, BossLevel, BossLevel, BossLevel, BossLevel, BossLevel]
 }
 
+export interface LastBossResult {
+  level: BossLevel;
+  variant: BossLevel;
+  battled_at: bigint;
+  reward: bigint;
+  prestigeGained: boolean;
+}
+
 export interface PlayerContextType {
   isRegistered: boolean,
   player: null | Player,
   army: null | Army,
   boss: null | Boss,
+  lastBossResult: null | LastBossResult,
   balance: bigint,
   register: (arg: "ETH" | "RGCVII") => void,
   raid: () => void,
@@ -50,6 +61,7 @@ const PlayerContext = createContext<PlayerContextType>({
   player: null,
   army: null,
   boss: null,
+  lastBossResult: null,
   balance: BigInt(0),
   register: () => { },
   raid: () => { },
@@ -61,6 +73,8 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
   const { address, isConnected } = useAccount();
   const { writeContract, error } = useWriteContract();
   const [[txHash, callbackFn], setHashAndCallback] = useState<[Hash | null, () => void]>([null, () => { }])
+  const [bossBattledModalOpen, setBossBattlesModalOpen] = useState(false);
+  const hasFetchedLastBossFirstTime = useRef(false);
 
   useEffect(() => {
     console.warn(error)
@@ -125,6 +139,17 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
     }
   });
 
+  const { data: lastBossResult } = useReadContract({
+    address: contractAddress,
+    abi,
+    functionName: 'getLastBossResult',
+    args: [address],
+    query: {
+      enabled: isConnected,
+      refetchInterval: 15
+    }
+  });
+
   console.log(balance, player, army, boss)
 
   const register = useCallback((arg: "RGCVII" | "ETH") => {
@@ -133,11 +158,12 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
         abi,
         address: contractAddress,
         functionName: 'register_eth',
-        value: parseEther("0.0005"),
+        value: parseEther("0.00005"),
       }, {
         onSuccess: (hash) => {
           setHashAndCallback([hash, resetHashAndCallback])
-        }
+        },
+        onError: () => resetHashAndCallback()
       })
     } else if (arg === "RGCVII") {
       writeContract({
@@ -156,10 +182,12 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
             }, {
               onSuccess: (hash) => {
                 setHashAndCallback([hash, resetHashAndCallback])
-              }
+              },
+              onError: () => resetHashAndCallback()
             })
           ])
-        }
+        },
+        onError: () => resetHashAndCallback()
       });
     }
   }, [writeContract, resetHashAndCallback])
@@ -172,7 +200,8 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
     }, {
       onSuccess: (hash) => {
         setHashAndCallback([hash, resetHashAndCallback])
-      }
+      },
+      onError: () => resetHashAndCallback()
     })
   }, [writeContract, resetHashAndCallback])
 
@@ -190,8 +219,23 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
       abi,
       address: contractAddress,
       functionName: 'battle_with_boss',
+    }, {
+      onSuccess: (hash) => {
+        setHashAndCallback([hash, () => resetHashAndCallback()])
+      },
+      onError: () => resetHashAndCallback()
     })
-  }, [writeContract])
+  }, [writeContract, resetHashAndCallback])
+
+  useEffect(() => {
+    if (lastBossResult != null) {
+      if (hasFetchedLastBossFirstTime.current) {
+        setBossBattlesModalOpen(true);
+      } else {
+        hasFetchedLastBossFirstTime.current = true;
+      }
+    }
+  }, [lastBossResult])
 
   return (
     <PlayerContext.Provider value={{
@@ -200,13 +244,17 @@ const PlayerProvider = ({ children }: { children: ReactNode }) => {
       army: army as Army,
       boss: boss as Boss,
       balance: balance as bigint,
+      lastBossResult: lastBossResult as LastBossResult,
       register,
       raid,
       addUnit,
       battleWithBoss
     }}>
       {children}
-      {txHash && <WaitingForTxModal hash={txHash} callbackFn={callbackFn} />}
+      <div className={`${(txHash || bossBattledModalOpen) ? styles.leaderboardOverlay : ""}`}>
+        {txHash && <WaitingForTxModal hash={txHash} callbackFn={callbackFn} />}
+        {bossBattledModalOpen && <BossOutcomeModal setIsOpen={setBossBattlesModalOpen} />}
+      </div>
     </PlayerContext.Provider>
   );
 }

app/src/styles/Modal.module.css

@@ -47,6 +47,41 @@
     margin-bottom: 0;
   }
 }
+.bossModal {
+  padding: 32px;
+  z-index: 3;
+  max-width: 100%;
+  width: 500px;
+  text-align: center;
+  margin-top: 50px;
+  .outcome {
+    font-size: 1.7rem;
+  }
+  .image {
+    position: relative;
+    margin: 0 auto;
+    top: 0;
+    &::after {
+      display: none;
+    }
+  }
+  & p {
+    margin: 0.5rem 0;
+  }
+  & button {
+    margin: 1rem;
+  }
+  .lost {
+    color: var(--accent-color);
+  }
+  .won {
+    color: var(--hover-color);
+  }
+  .lost,
+  .won {
+    font-size: 2rem;
+  }
+}
 
 @keyframes spin {
   0% {

app/src/wagmi.ts

@@ -2,7 +2,6 @@ import { getDefaultConfig } from '@rainbow-me/rainbowkit';
 import {
   base,
   baseSepolia,
-  sepolia,
   foundry
 } from 'wagmi/chains';
 
@@ -13,7 +12,6 @@ export const config = getDefaultConfig({
     baseSepolia,
     foundry,
     base,
-    ...(process.env.NEXT_PUBLIC_ENABLE_TESTNETS === 'true' ? [sepolia] : []),
   ],
   ssr: true,
 });

src/RaidGeld.sol

@@ -5,7 +5,7 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 
 import {RaidGeldUtils} from "../src/RaidGeldUtils.sol";
-import {Army, Player, Raider, Boss} from "../src/RaidGeldStructs.sol";
+import {Army, Player, Raider, Boss, LastBossResult} from "../src/RaidGeldStructs.sol";
 import "../src/Constants.sol";
 
 contract RaidGeld is ERC20, Ownable, Constants {
@@ -16,6 +16,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
     mapping(address => Player) private players;
     mapping(address => Army) private armies;
     mapping(address => Boss) private bosses;
+    mapping(address => LastBossResult) private lastBossResults;
 
     // WETH
     IWETH public immutable weth = IWETH(WETH);
@@ -44,6 +45,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
     event DaoTokenBuyInAmountSet(address indexed owner, uint256 oldAmount, uint256 newAmount);
     event PrestigeGained(address indexed player, uint32 prestigeLevel);
     event BossDefeated(address indexed player, uint8 bossLevel, uint256 earnings);
+    event BossBattle(address indexed player, uint8 bossLevel, bool hasWon);
 
     // Modifier for functions that should only be available to registered players
     modifier onlyPlayer() {
@@ -106,6 +108,9 @@ contract RaidGeld is ERC20, Ownable, Constants {
             profit_per_second: 0
         });
         bosses[_playerAddress] = Boss({level: 0, variants: RaidGeldUtils.generate_boss_variants(block.prevrandao)});
+        
+        // dont change lastBossResult 
+        // that only changes after boss battles and on init
     }
 
     // New player want to register with ETH
@@ -171,6 +176,11 @@ contract RaidGeld is ERC20, Ownable, Constants {
         return bosses[addr];
     }
 
+    // Function to get the Boss struct
+    function getLastBossResult(address addr) public view returns (LastBossResult memory) {
+        return lastBossResults[addr];
+    }
+
     // Quick fn to check if user is registered
     function isRegistered(address addr) public view returns (bool) {
         return players[addr].created_at != 0;
@@ -248,6 +258,14 @@ contract RaidGeld is ERC20, Ownable, Constants {
             ? RaidGeldUtils.getBossPower(boss_to_attack.level)
             : balanceOf(msg.sender);
         bool hasWonBattle = RaidGeldUtils.calculateBossFight(boss_to_attack.level, geld_to_burn, block.prevrandao);
+        emit BossBattle(msg.sender, boss_to_attack.level, hasWonBattle);
+        lastBossResults[msg.sender] = LastBossResult({
+            battled_at: block.timestamp,
+            level: boss_to_attack.level,
+            variant: boss_to_attack.variants[boss_to_attack.level],
+            prestigeGained: false,
+            reward: 0
+        });
         if (hasWonBattle) {
             // Burn geld, send some sweet DAO Token and continue
             _burn(msg.sender, geld_to_burn);
@@ -256,11 +274,14 @@ contract RaidGeld is ERC20, Ownable, Constants {
             daoToken.transfer(msg.sender, reward);
             emit BossDefeated(msg.sender, boss_to_attack.level, reward);
 
+            lastBossResults[msg.sender].reward = reward;
+
             if (boss_to_attack.level == 6) {
                 // User ascends! Moloch is defeated, user can start a new run
                 players[msg.sender].prestige_level += 1;
                 emit PrestigeGained(msg.sender, players[msg.sender].prestige_level);
                 player_dies(msg.sender);
+                lastBossResults[msg.sender].prestigeGained = true;
                 return [hasWonBattle, true /* New prestige level! */ ];
             } else {
                 // else go to next boss
@@ -268,6 +289,7 @@ contract RaidGeld is ERC20, Ownable, Constants {
             }
         } else {
             // Whoops u died, boss defeated you
+            lastBossResults[msg.sender].reward = 0;
             player_dies(msg.sender);
         }
         return [hasWonBattle, false /* hasnt gotten prestige level */ ];

src/RaidGeldStructs.sol

@@ -28,3 +28,11 @@ struct Boss {
     uint8 level;
     uint8[7] variants;
 }
+
+struct LastBossResult {
+    uint256 battled_at;
+    uint256 reward;
+    uint8 level;
+    uint8 variant;
+    bool prestigeGained;
+}

test/RaidGeld.t.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.8.13;
 
 import {Test, console} from "forge-std/Test.sol";
 import {stdStorage, StdStorage} from "forge-std/Test.sol";
-import {RaidGeld, Army, Player, Boss} from "../src/RaidGeld.sol";
+import {RaidGeld, Army, Player, Boss, LastBossResult} from "../src/RaidGeld.sol";
 import "../src/RaidGeldUtils.sol";
 import {Constants} from "../src/Constants.sol";
 
@@ -283,6 +283,13 @@ contract raid_geldTest is Test, Constants {
 
         uint256 afterBossDaoBalance = raid_geld.daoToken().balanceOf(player1);
         uint256 afterBossContractBalance = raid_geld.daoToken().balanceOf(address(raid_geld));
+        LastBossResult memory bossResult = raid_geld.getLastBossResult(player1);
+
+        assertEq(bossResult.battled_at, block.timestamp);
+        assertEq(bossResult.reward, afterBossDaoBalance - initialDaoBalance);
+        assertEq(bossResult.level, boss.level);
+        assertEq(bossResult.variant, boss.variants[boss.level]);
+        assertEq(bossResult.prestigeGained, false);
 
         // User should receive funs, contract should lose them
         assertLt(initialDaoBalance, afterBossDaoBalance);
@@ -306,6 +313,7 @@ contract raid_geldTest is Test, Constants {
         registerPlayerWithDaoToken();
         raid_geld.addUnit(0, 1);
 
+        Boss memory boss = raid_geld.getBoss(player1);
         bool[2] memory results = raid_geld.battle_with_boss();
         // Should lose with just starting GELD 
         assertEq(results[0], false);
@@ -321,6 +329,13 @@ contract raid_geldTest is Test, Constants {
         assertEq(raid_geld.balanceOf(player1), 0);
         // Units should reset
         assertEq(army.moloch_denier.level, 0);
+
+        LastBossResult memory bossResult = raid_geld.getLastBossResult(player1);
+        assertEq(bossResult.battled_at, block.timestamp);
+        assertEq(bossResult.reward, 0);
+        assertEq(bossResult.level, boss.level);
+        assertEq(bossResult.variant, boss.variants[boss.level]);
+        assertEq(bossResult.prestigeGained, false);
     }
 
     function test_08_player_who_lost_can_restart() public {
@@ -388,6 +403,8 @@ contract raid_geldTest is Test, Constants {
             if (results[0] == true && results[1] == true) {
                 success = true;
                 Player memory player = raid_geld.getPlayer(player1);
+                LastBossResult memory bossResult = raid_geld.getLastBossResult(player1);
+                assertEq(bossResult.prestigeGained, true);
                 vm.assertEq(player.prestige_level, 1);
                 vm.assertEq(player.n_runs, tries);
                 break;