Updated unit tests, README, and Vignette

Changes:
- Added unit tests for app.R
- Updated README file
- Updated Vignette

Author: davidcleve

DESCRIPTION

@@ -21,7 +21,7 @@ RoxygenNote: 7.3.3
 Imports:
     checkmate (>= 2.3.4),
     shiny (>= 1.13.0)
-Suggests: 
+Suggests:
     knitr,
     rmarkdown,
     shinytest2,

R/app.R

@@ -328,13 +328,13 @@ server <- function(input, output, session) {
     # Print win or loss message in large bold text
     tagList(if (is_winner(picked(), sequence())) {
       p("You won! That was the highest number.",
-        style = "font-size: 20px; font-weight: bold;")
+        style = "font-size: 20px; font-weight: bold; color: #28a745;")
     } else {
       p(paste("You lost! The highest number was", max_label),
-        style = "font-size: 20px; font-weight: bold;")
+        style = "font-size: 20px; font-weight: bold; color: #dc3545;")
     },
     # Add action button to restart the game
-    actionButton("restart", "Play again"))
+    div(style = "text-align: center;", actionButton("restart", "Play again")))
   })
 
   # Reset all game state when the player clicks Play again, returning to setup.

README.md

@@ -1,14 +1,43 @@
 # GoogolGame
-Play the googol game to explore the theory of optimal stopping or use it as a task in your research!
-
-In the coming weeks I want to create an application that allows users to play the googol game (also known as secretary problem, marriage problem, and more).
-The googol game demonstrates a scenario involving optimal stopping theory.
-
-The basic idea is simple: a set of cards (e.g. 10) each contains a random number between zero and infinity. The cards are shuffled, placed face down in a line, and revealed one at a time. After each reveal, the player must decide whether to stop or continue searching for a higher number. Once a card is passed, the player cannot return to it later. The goal is to stop on the highest number in the deck.
-
-My application will allow players to use card sets of different sizes, with values either entered manually or generated randomly.
-The game can be used to explore optimal stopping theory and may also have applications in research or education.
 
 <!-- badges: start -->
 [![R-CMD-check](https://github.com/Programming-The-Next-Step-2026/GoogolGame/actions/workflows/R-CMD-check.yaml/badge.svg)](https://github.com/Programming-The-Next-Step-2026/GoogolGame/actions/workflows/R-CMD-check.yaml)
 <!-- badges: end -->
+
+## Do You Know This Problem? 
+
+You just finished your workout and it's time to shower. But first — that email you've been putting off all day. Then the dishes, and the floor isn't going to vacuum itself. After all that housework you deserve a little reward, so you sit down to finish your favourite series. By now the sweat has long dried, so it barely matters anyway. And it's late and your roommates are asleep, so it would be rude to shower. And you were planning to work out again tomorrow anyways — so what's the point of showering at all? You could go on like this forever.
+
+The question is: **when is the right moment**? To stop and say: now I decide to do it?
+
+To take the shower, to take out the trash, or to pick the card with the highest number…
+
+The card with the highest number, you ask? The idea comes from Martin Gardner who first described a gambling game called Googol.
+
+## What is the Googol Game?
+
+The Googol Game demonstrates optimal stopping theory. The rules are simple: Player 1 writes any numbers they like on a set of cards, then turns them face down and shuffles them. Player 2 turns over one card at a time and must decide when to stop — betting that the current card is the highest. Crucially, you cannot go back. If you pass a card, it's gone.
+
+Is there an optimal point to stop?
+
+Explore this question with the Googol Game app!
+
+## Installation
+
+```r
+# install.packages("devtools")
+devtools::install_github("Programming-The-Next-Step-2026/GoogolGame")
+```
+
+## Usage
+
+```r
+GoogolGame::play_googol()
+```
+
+## Features
+
+- **Random mode**: the app generates a sequence of numbers across a wide range of scales — from small integers up to Googol-sized values (e.g. "3 Million", "7 Googol").
+- **Manual mode**: enter your own numbers one at a time using a base value and a multiplier (None, Million, Billion, Trillion, Googol).
+- Players can reveal cards one at a time and decide to stop if they think they found the highest number.
+- Win and loss messages are displayed, with an option to play again.

tests/testthat/test-app.R

@@ -8,51 +8,8 @@ test_that("app loads on setup page", {
   app$stop()
 })
 
-# # 2. Random mode: Start switches to game page
-# test_that("random mode Start switches to game page", {
-#   app <- AppDriver$new(play_googol())
-#   app$set_inputs(mode = "random", n_cards = 3)
-#   app$click("start")
-#   app$wait_for_idle()
-#   # Reveal first card so the Pick button appears
-#   app$click("next_card")
-#   app$wait_for_idle()
-#   expect_true("pick" %in% names(app$get_values()$input))
-#   app$stop()
-# })
-#
-# # 3. Pick switches to result page
-# test_that("Pick switches to result page", {
-#   app <- AppDriver$new(play_googol())
-#   app$set_inputs(mode = "random", n_cards = 3)
-#   app$click("start")
-#   app$wait_for_idle()
-#   app$click("next_card")
-#   app$wait_for_idle()
-#   app$click("pick")
-#   app$wait_for_idle()
-#   expect_true("restart" %in% names(app$get_values()$input))
-#   app$stop()
-# })
-#
-# # 4. Play again returns to setup
-# test_that("Play again returns to setup page", {
-#   app <- AppDriver$new(play_googol())
-#   app$set_inputs(mode = "random", n_cards = 3)
-#   app$click("start")
-#   app$wait_for_idle()
-#   app$click("next_card")
-#   app$wait_for_idle()
-#   app$click("pick")
-#   app$wait_for_idle()
-#   app$click("restart")
-#   app$wait_for_idle()
-#   expect_true("start" %in% names(app$get_values()$input))
-#   app$stop()
-# })
-
-# 5. Manual mode with valid numbers starts game
-test_that("manual mode with valid numbers starts game", {
+# 2. Start switches to game page
+test_that("Start switches to game page", {
   app <- AppDriver$new(play_googol())
   app$set_inputs(mode = "manual", number_1 = 100, multiplier_1 = "None")
   app$click("add_row")
@@ -67,7 +24,43 @@ test_that("manual mode with valid numbers starts game", {
   app$stop()
 })
 
-# 6. Manual mode with invalid entry (i.e. only 1 number) shows an error and stays on setup
+# 3. Pick switches to result page
+test_that("Pick switches to result page", {
+  app <- AppDriver$new(play_googol())
+  app$set_inputs(mode = "manual", number_1 = 100, multiplier_1 = "None")
+  app$click("add_row")
+  app$wait_for_idle()
+  app$set_inputs(number_2 = 500, multiplier_2 = "None")
+  app$click("start")
+  app$wait_for_idle()
+  app$click("next_card")
+  app$wait_for_idle()
+  app$click("pick")
+  app$wait_for_idle()
+  expect_true("restart" %in% names(app$get_values()$input))
+  app$stop()
+})
+
+# 4. Play again returns to setup
+test_that("Play again returns to setup page", {
+  app <- AppDriver$new(play_googol())
+  app$set_inputs(mode = "manual", number_1 = 100, multiplier_1 = "None")
+  app$click("add_row")
+  app$wait_for_idle()
+  app$set_inputs(number_2 = 500, multiplier_2 = "None")
+  app$click("start")
+  app$wait_for_idle()
+  app$click("next_card")
+  app$wait_for_idle()
+  app$click("pick")
+  app$wait_for_idle()
+  app$click("restart")
+  app$wait_for_idle()
+  expect_true("start" %in% names(app$get_values()$input))
+  app$stop()
+})
+
+# 5. Manual mode with invalid entry (i.e. only 1 number) shows an error and stays on setup
 test_that("manual mode with invalid entry shows error and stays on setup page", {
   app <- AppDriver$new(play_googol())
   app$set_inputs(mode = "manual", number_1 = 100, multiplier_1 = "None")

vignettes/how-to-use-the-googol-game-app.Rmd

@@ -14,61 +14,114 @@ knitr::opts_chunk$set(
 )
 ```
 
-```{r setup}
-library(GoogolGame)
-```
-
 ## What is the Googol Game?
 
-The Googol Game is based on the mathematical Secretary Problem. A sequence of
-numbers is revealed one at a time. Your goal is to pick the highest number in
+The Googol Game is a gambling problem first described by Martin Gardner. A sequence 
+of numbers is revealed one at a time. Your goal is to pick the highest number in
 the sequence — but once you pass a number, you cannot go back. You win only if
 the number you pick turns out to be the highest in the entire sequence,
 including numbers you never saw.
 
+## How to install the app
+
+```{r, eval = FALSE}
+# install.packages("devtools")
+devtools::install_github("Programming-The-Next-Step-2026/GoogolGame")
+```
+
 ## How to launch the app
 
 ```{r, eval = FALSE}
+library(GoogolGame)
 play_googol()
 ```
 
-## Step-by-step instructions
+## Scenario
+
+**Purpose**: scenario that describes how to use the GoogolGame app.
+
+**User**: everybody that is interested in the Googol Game or optimal stopping theory.
+It is especially fun if you play it together with a second person!
+
+**Equipment**: any computer with a supported browser. You must have installed R. All
+other dependencies will be installed automatically when downloading the package.
 
-### Step 1: Choose a sequence type
+**Scenario**:
+
+**Step 1: Choose a sequence type**
 
 When the app opens, choose how to generate the sequence of numbers:
 
 - **Random**: the app generates a sequence of random numbers for you. Enter
-  how many cards you want and click **Start game**.
+  how many cards you want (e.g. 3) and click **Start game**.
+  
+<img src="images/random_generation.png" width="100%" />
+
 - **Manual**: enter your own numbers one at a time. For each number, type a
   value and optionally select a multiplier (e.g. select `2` and `Googol` to
   enter 2 Googol). Click **Add number** to add another number. You need at 
-  least 2 numbers and you can add as many numbers as you want. 
+  least 2 numbers and you can add as many numbers as you want.
+
+<img src="images/manual_generation.png" width="100%" />
+
   **Note**: manual entry requires a second person — one who enters the numbers
   and one who plays the game! Hand the keyboard to a friend to enter the 
-  numbers and don't peek at the screen ;)
+  numbers and don't peek at the screen.
+
+**Step 2: Play the game**
 
-### Step 2: Play the game
+After clicking **Start game**, all cards are shown face-down in blue. Click
+**Reveal first card** to turn over the first card.
 
-After clicking **Start game**, the cards are revealed one at a time:
+<img src="images/reveal_first_card.png" width="100%" />
 
-- Cards you have already seen are shown with their number.
-- The current card shows its number and is the one you can pick.
-- Cards not yet revealed are shown as `?`.
+From there, after each reveal you have two choices:
 
-At each card you have two choices:
+- Click **Pick this number** if you think the current card (highlighted in
+  green) is the highest.
+- Click **Next** to pass it and reveal the next card. Passed cards turn grey.
 
-- Click **Pick this number** to select the current card as your answer.
-- Click **Next** to pass and reveal the next card.
+<img src="images/next_or_pick.png" width="100%" />
 
 On the last card, only **Pick this number** is available — you must pick.
 
-### Step 3: See the result
+<img src="images/pick_this_number.png" width="100%" />
+
+**Step 3: See the result**
 
 After picking, the app shows whether you won or lost:
 
 - **Win**: your chosen number was the highest in the sequence.
 - **Loss**: a higher number existed elsewhere in the sequence, along with what
   that number was.
 
+<img src="images/win_or_loss.png" width="100%" />
+
 Click **Play again** to return to the setup page and start a new game.
+
+## Flowchart
+
+The flowchart below shows the full flow of the app, distinguishing between
+user actions and the software functions triggered behind the scenes.
+
+**Colours**: <span style="color:#2c7be5">■</span> blue = user action,
+<span style="color:#28a745">■</span> green = software action.
+
+<img src="images/flowchart.png" width="80%" />
+
+## Extra: optimal stopping theory
+
+Is there a strategy that maximises your chances of picking the highest number?
+Yes — and the answer comes from mathematics.
+
+The optimal strategy is to let the first 37% of cards pass without
+picking, no matter how high they are. After that, pick the next card that is
+higher than all the cards you have already seen. If no such card appears, pick
+the last card.
+
+This strategy gives you approximately a 37% chance of picking the highest
+number, regardless of how many cards there are. Remarkably, no other strategy
+can do better in the long run.
+
+Try it out: with 10 cards, skip the first 3 or 4 and then pick the next card
+that beats them all.