Add support for "Safe Pass" skill

- Add UI controls for automatically using Safe Pass on fumbles
- Added Action Wheel selector for choosing to use Safe Pass
- Restrict it to only Pass actions, at least until a FAQ says otherwise

Author: cmelchior

docs/bb2025/rules-faq-bb2025.md

@@ -189,11 +189,23 @@ round up.
 Technically, you are allowed to user other skills like Extra Arms, but since 
 it would be pointless, Jervis just ignore these skills.
 
-### Page 135 - Put the Boot In
+### Page 134 - Put the Boot In
 Technically, using the skill should be optional, but there doesn't seem to be 
 any use case for this (even a bad one), so until such a use case surfaces, this 
 skill is always used.
 
+### Page 135 - Safe Pass
+The skill uses the wording "Passing Ability Test", which is the same wording
+used for rolling for the throw in both Pass and Throw Team-mate actions. But 
+then the rest of the skill only describes what happens to the ball, indicating 
+that maybe they just mean that it works for normal Pass actions.
+
+If we allowed it to work for Throw Team-mate actions, it would open up a lot 
+of unspecified scenarios with regard to how the thrown player be handled? 
+
+For this reason, Jervis assumes that Safe Pass is only applicable for normal
+Pass actions (and by extension, throwing bombs).
+
 ### Page 138 - Very Long Legs
 While this skill is optional during Interceptions, Jervis always enables it as 
 the coach can just choose to not intercept instead. This lowers the complexity 

docs/bb2025/todo-skills-bb2025.md

@@ -179,11 +179,11 @@ a test class in `modules/jervis-engine/src/commonTest/kotlin/dk/ilios/jervis/bb2
   - [ ] Works for Bombs
   - [x] Works for normal passes
   - [x] Works for hail mary passes
-- [ ] Quick Pass
-- [ ] Rush
-- [ ] Sneaky Pass
 - [ ] Punt
 - [ ] Safe Pass
+  - [x] Works on Pass
+  - [x] Works on Hail Mary Pass
+  - [ ] Works on throwing a bomb
 
 ## Strength Skills
 

docs/bugs.md

@@ -3,6 +3,7 @@
 This file is just a temporary way to capture any bugs seen that I didn't have time to investigate yet.
 
 ## Known bugs
+- Move counter on field squares does not reset when a players action ends immediately (like when using Safe Pass)
 - Action Wheel animation isn't correct when animating D6 rererolls when automatically selecting the reroll type.
   It looks like two animations are running over each other or that some positions are being reused.
 - Action Wheel for Catch rerolls jump back to the thrower when undoing actions

modules/fumbbl-net/src/commonMain/kotlin/com/jervisffb/fumbbl/net/adapter/impl/AbortActionMapper.kt

@@ -52,7 +52,7 @@ object AbortActionMapper: CommandActionMapper {
         when ((command.reportList.first() as PlayerActionReport).playerAction) {
             PlayerAction.MOVE -> {
                 val movingPlayerId = command.modelChangeList.filterIsInstance<ActingPlayerSetPlayerId>().first().value!!
-                val movingPlayer = jervisGame.getPlayerById(PlayerId(movingPlayerId.id))!!
+                val movingPlayer = jervisGame.getPlayerById(PlayerId(movingPlayerId.id))
                 newActions.add(PlayerSelected(movingPlayer.id), TeamTurn.SelectPlayerOrEndTurn)
                 newActions.add(
                     { state, rules -> PlayerActionSelected(rules.teamActions.move.type) },

modules/fumbbl-net/src/commonMain/kotlin/com/jervisffb/fumbbl/net/adapter/impl/setup/SetupPlayerMapper.kt

@@ -42,9 +42,9 @@ object SetupPlayerMapper: CommandActionMapper {
         jervisCommands: List<JervisActionHolder>,
         newActions: MutableList<JervisActionHolder>
     ) {
-        val playerId = (command.modelChangeList.first() as FieldModelSetPlayerState).key!!
+        val playerId = (command.modelChangeList.first() as FieldModelSetPlayerState).key
         var coordinates = (command.modelChangeList[1] as FieldModelSetPlayerCoordinate).value!!
-        val selectedPlayer = jervisGame.getPlayerById(PlayerId(playerId))!!
+        val selectedPlayer = jervisGame.getPlayerById(PlayerId(playerId))
         newActions.add(PlayerSelected(selectedPlayer), SetupTeam.SelectPlayerOrEndSetup)
         if (coordinates.x < 0 || coordinates.y > 25) {
             newActions.add(DogoutSelected, SetupTeam.PlacePlayer)

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/bb2025/BB2025SkillSettings.kt

@@ -39,6 +39,7 @@ import com.jervisffb.engine.rules.bb2025.skills.QuickFoul
 import com.jervisffb.engine.rules.bb2025.skills.ReallyStupid
 import com.jervisffb.engine.rules.bb2025.skills.Regeneration
 import com.jervisffb.engine.rules.bb2025.skills.RightStuff
+import com.jervisffb.engine.rules.bb2025.skills.SafePass
 import com.jervisffb.engine.rules.bb2025.skills.Shadowing
 import com.jervisffb.engine.rules.bb2025.skills.Sidestep
 import com.jervisffb.engine.rules.bb2025.skills.Sprint
@@ -392,9 +393,9 @@ class BB2025SkillSettings: SkillSettings() {
                     // }
                 }
                 SkillType.SAFE_PASS -> {
-                    // addEntry(type, SkillCategory.PASSING) { player, category, _ , expiresAt ->
-                    // TODO()
-                    // }
+                    addNoValueEntry("Safe Pass", type, SkillCategory.PASSING) { player, category,expiresAt ->
+                        SafePass(player, category, expiresAt)
+                    }
                 }
 
                 //

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/bb2025/procedures/actions/pass/HailMaryPassStep.kt

@@ -2,6 +2,9 @@ package com.jervisffb.engine.rules.bb2025.procedures.actions.pass
 
 import com.jervisffb.engine.actions.Cancel
 import com.jervisffb.engine.actions.CancelWhenReady
+import com.jervisffb.engine.actions.Confirm
+import com.jervisffb.engine.actions.ConfirmWhenReady
+import com.jervisffb.engine.actions.ContinueWhenReady
 import com.jervisffb.engine.actions.FieldSquareSelected
 import com.jervisffb.engine.actions.GameAction
 import com.jervisffb.engine.actions.GameActionDescriptor
@@ -17,6 +20,7 @@ import com.jervisffb.engine.commands.context.RemoveContext
 import com.jervisffb.engine.commands.context.SetContext
 import com.jervisffb.engine.commands.fsm.ExitProcedure
 import com.jervisffb.engine.commands.fsm.GotoNode
+import com.jervisffb.engine.ext.d6
 import com.jervisffb.engine.fsm.ActionNode
 import com.jervisffb.engine.fsm.Node
 import com.jervisffb.engine.fsm.ParentNode
@@ -28,6 +32,8 @@ import com.jervisffb.engine.model.Team
 import com.jervisffb.engine.model.TurnOver
 import com.jervisffb.engine.model.context.assertContext
 import com.jervisffb.engine.model.context.getContext
+import com.jervisffb.engine.model.isSkillAvailable
+import com.jervisffb.engine.reports.ReportSkillUsed
 import com.jervisffb.engine.reports.ReportStartingPass
 import com.jervisffb.engine.rules.Rules
 import com.jervisffb.engine.rules.common.procedures.Bounce
@@ -39,14 +45,15 @@ import com.jervisffb.engine.rules.common.procedures.ThrowInContext
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassAction
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassContext
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassingType
+import com.jervisffb.engine.rules.common.skills.SkillType
 import com.jervisffb.engine.rules.common.tables.Range
 import com.jervisffb.engine.utils.INVALID_GAME_STATE
 
 /**
  * Procedure for handling the passing part of a [PassAction] when using [HailMary].
  *
  * See page 70 in the BB2025 rulebook.
- * See page XXX in the BB2025 rulebook.
+ * See page 129 in the BB2025 rulebook.
  */
 object HailMaryPassStep: Procedure() {
     override val initialNode: Node = DeclareTargetSquare
@@ -107,7 +114,7 @@ object HailMaryPassStep: Procedure() {
             val context = state.getContext<PassContext>()
             return when (val result = context.passingResult) {
                 PassingType.INACCURATE -> GotoNode(ResolveInaccuratePass)
-                PassingType.FUMBLED -> GotoNode(ResolveFumbledPass)
+                PassingType.FUMBLED -> GotoNode(ChooseToUseSafePass)
                 else -> INVALID_GAME_STATE("Unsupported passing result: $result")
             }
         }
@@ -158,6 +165,42 @@ object HailMaryPassStep: Procedure() {
         }
     }
 
+    object ChooseToUseSafePass: ActionNode() {
+        override fun actionOwner(state: Game, rules: Rules): Team {
+            return state.getContext<PassContext>().thrower.team
+        }
+
+        override fun getAvailableActions(state: Game, rules: Rules): List<GameActionDescriptor> {
+            val context = state.getContext<PassContext>()
+            val player = context.thrower
+            val hasSafePass = player.isSkillAvailable(SkillType.SAFE_PASS)
+            // Safe Pass requires a natural 1 on the dice. It doesn't work on a modified 1 and below.
+            val isSafePassEligible = (context.passingRoll?.result == 1.d6)
+            val isFumble = (context.passingResult == PassingType.FUMBLED)
+            return when (hasSafePass && isSafePassEligible && isFumble) {
+                true -> listOf(ConfirmWhenReady, CancelWhenReady)
+                false -> listOf(ContinueWhenReady)
+            }
+        }
+
+        override fun applyAction(action: GameAction, state: Game, rules: Rules): Command {
+            val context = state.getContext<PassContext>()
+            val ball = state.currentBall()
+            val useSafePass = (action == Confirm)
+
+            return if (useSafePass) {
+                compositeCommandOf(
+                    ReportSkillUsed(context.thrower, SkillType.SAFE_PASS),
+                    SetBallState.carried(ball, context.thrower),
+                    SetContext(context.copy(useSafePass = true)),
+                    ExitProcedure()
+                )
+            } else {
+                GotoNode(ResolveFumbledPass)
+            }
+        }
+    }
+
     /**
      * If the pass is fumbled, the ball will bounce from the thrower's location
      * and a turnover happens. Regardless of who, if any, catches the ball.

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/bb2025/procedures/actions/pass/PassStep.kt

@@ -2,6 +2,9 @@ package com.jervisffb.engine.rules.bb2025.procedures.actions.pass
 
 import com.jervisffb.engine.actions.Cancel
 import com.jervisffb.engine.actions.CancelWhenReady
+import com.jervisffb.engine.actions.Confirm
+import com.jervisffb.engine.actions.ConfirmWhenReady
+import com.jervisffb.engine.actions.ContinueWhenReady
 import com.jervisffb.engine.actions.FieldSquareSelected
 import com.jervisffb.engine.actions.GameAction
 import com.jervisffb.engine.actions.GameActionDescriptor
@@ -17,6 +20,7 @@ import com.jervisffb.engine.commands.context.RemoveContext
 import com.jervisffb.engine.commands.context.SetContext
 import com.jervisffb.engine.commands.fsm.ExitProcedure
 import com.jervisffb.engine.commands.fsm.GotoNode
+import com.jervisffb.engine.ext.d6
 import com.jervisffb.engine.fsm.ActionNode
 import com.jervisffb.engine.fsm.ComputationNode
 import com.jervisffb.engine.fsm.Node
@@ -29,6 +33,8 @@ import com.jervisffb.engine.model.Team
 import com.jervisffb.engine.model.TurnOver
 import com.jervisffb.engine.model.context.assertContext
 import com.jervisffb.engine.model.context.getContext
+import com.jervisffb.engine.model.isSkillAvailable
+import com.jervisffb.engine.reports.ReportSkillUsed
 import com.jervisffb.engine.reports.ReportStartingPass
 import com.jervisffb.engine.rules.Rules
 import com.jervisffb.engine.rules.common.procedures.Bounce
@@ -40,6 +46,7 @@ import com.jervisffb.engine.rules.common.procedures.ThrowInContext
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassAction
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassContext
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassingType
+import com.jervisffb.engine.rules.common.skills.SkillType
 import com.jervisffb.engine.rules.common.tables.Range
 import com.jervisffb.engine.rules.common.tables.Weather
 import com.jervisffb.engine.utils.INVALID_GAME_STATE
@@ -98,7 +105,7 @@ object PassStep: Procedure() {
                                     range = distance
                                 )
                             ),
-                            SetBallState.Companion.accurateThrow(ball), // Until proven otherwise. Should we invent a new type?
+                            SetBallState.accurateThrow(ball), // Until proven otherwise. Should we invent a new type?
                             SetBallLocation(ball, newLocation),
                             GotoNode(TestForAccuracy)
                         )
@@ -115,7 +122,7 @@ object PassStep: Procedure() {
             return when (val result = context.passingResult) {
                 PassingType.ACCURATE -> GotoNode(ResolveAccuratePass)
                 PassingType.INACCURATE -> GotoNode(ResolveInaccuratePass)
-                PassingType.FUMBLED -> GotoNode(ResolveFumbledPass)
+                PassingType.FUMBLED -> GotoNode(ChooseToUseSafePass)
                 else -> INVALID_GAME_STATE("Unsupported passing result: $result")
             }
         }
@@ -162,7 +169,7 @@ object PassStep: Procedure() {
             val ball = state.currentBall()
             return if (context.outOfBoundsAt != null) {
                 compositeCommandOf(
-                    SetBallState.Companion.outOfBounds(ball, context.outOfBoundsAt),
+                    SetBallState.outOfBounds(ball, context.outOfBoundsAt),
                     SetBallLocation(ball, context.landsAt!!),
                     SetContext(passContext.copy(target = context.landsAt)),
                     RemoveContext<ScatterRollContext>(),
@@ -180,6 +187,41 @@ object PassStep: Procedure() {
         }
     }
 
+    object ChooseToUseSafePass: ActionNode() {
+        override fun actionOwner(state: Game, rules: Rules): Team {
+            return state.getContext<PassContext>().thrower.team
+        }
+
+        override fun getAvailableActions(state: Game, rules: Rules): List<GameActionDescriptor> {
+            val context = state.getContext<PassContext>()
+            val player = context.thrower
+            val hasSafePass = player.isSkillAvailable(SkillType.SAFE_PASS)
+            val isSafePassEligible = (context.passingRoll?.result == 1.d6)
+            val isFumble = (context.passingResult == PassingType.FUMBLED)
+            return when (hasSafePass && isSafePassEligible && isFumble) {
+                true -> listOf(ConfirmWhenReady, CancelWhenReady)
+                false -> listOf(ContinueWhenReady)
+            }
+        }
+
+        override fun applyAction(action: GameAction, state: Game, rules: Rules): Command {
+            val context = state.getContext<PassContext>()
+            val ball = state.currentBall()
+            val useSafePass = (action == Confirm)
+
+            return if (useSafePass) {
+                compositeCommandOf(
+                    ReportSkillUsed(context.thrower, SkillType.SAFE_PASS),
+                    SetBallState.carried(ball, context.thrower),
+                    SetContext(context.copy(useSafePass = true)),
+                    ExitProcedure()
+                )
+            } else {
+                GotoNode(ResolveFumbledPass)
+            }
+        }
+    }
+
     /**
      * If the pass is fumbled, the ball will bounce from the thrower's location
      * and a turnover happens. Regardless of who, if any, catches the ball.

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/bb2025/skills/DirtyPlayer.kt

@@ -10,7 +10,7 @@ import com.jervisffb.engine.rules.common.skills.SkillType
 /**
  * Represents the "Dirty Player" skill.
  *
- * See page XXX in the BB2025 rulebook.
+ * See page 127 in the BB2025 rulebook.
  */
 class DirtyPlayer(
     override val player: Player,

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/bb2025/skills/HailMaryPass.kt

@@ -10,7 +10,7 @@ import com.jervisffb.engine.rules.common.skills.SkillType
 /**
  * Representation of the Hail Mary Pass (Active) skill.
  *
- * See page XXX in the BB2025 rulebook.
+ * See page 129 in the BB2025 rulebook.
  */
 class HailMaryPass(
     override val player: Player,