Add support for "Tackle" skill

- Add UI controls for handling automatic use of Tackle on blocks and during dodge
- Added Action Wheel and other UI controls for selecting to use Tackle or Not
- Improved Game status messages around Tackle

Author: cmelchior

docs/bb2025/todo-skills-bb2025.md

@@ -37,6 +37,7 @@ a test class in `modules/jervis-engine/src/commonTest/kotlin/dk/ilios/jervis/bb2
 - [ ] Jump Up
 - [ ] Leap
 - [ ] Safe Pair of Hands
+  - [ ] Does not work against Strip Ball (NAF)
 - [ ] Sidestep
 - [ ] Sprint
 - [x] Sure Feet
@@ -100,8 +101,13 @@ a test class in `modules/jervis-engine/src/commonTest/kotlin/dk/ilios/jervis/bb2
 - [ ] Pro
 - [ ] Steady Footing
 - [ ] Strip Ball
+  - [ ] Does not work against Stand Firm (Fumbbl)
+  - [ ] No score, if ball is stripped when pushed into end zone
 - [ ] Sure Hands
-- [ ] Tackle
+- [x] Tackle
+  - [x] Prevent use of Dodge skill when dodging away
+  - [x] Only use Tackle if other player has Dodge
+  - [x] Defender does not count as having dodge during a Block
 - [ ] Taunt
 - [ ] Wrestle
 
@@ -204,6 +210,7 @@ a test class in `modules/jervis-engine/src/commonTest/kotlin/dk/ilios/jervis/bb2
 - [ ] Mighty Blow
 - [ ] Multiple Block
     - [ ] During Multiple Block: Scoring Turnovers will win over End-Turn turnovers.
+    - [ ] Tackle on both blocks
 - [ ] Stand Firm
 - [ ] Strong Arm
 - [ ] Thick Skull
@@ -217,8 +224,8 @@ a test class in `modules/jervis-engine/src/commonTest/kotlin/dk/ilios/jervis/bb2
 - [ ] Bombardier
   - [ ] Accurate skill works
   - [ ] Cannoneer skill works
-- [ ] Bone Armor*
-- [ ] Bone Fury*
+  - [ ] Safe Pass skills works
+  - [ ] Hail Mary Pass works
 - [ ] Bone Head*
 - [ ] Blood Lust (X+)*
 - [ ] Breathe Fire

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/model/context/DodgeRollContext.kt

@@ -16,6 +16,7 @@ data class DodgeRollContext(
     val targetSquare: FieldCoordinate,
     val roll: D6DieRoll? = null,
     val rollModifiers: List<DiceModifier> = emptyList(),
+    val useTackle: Player? = null,
     val isSuccess: Boolean = true,
 ): ProcedureContext {
     fun copyAndAddModifier(twoHeads: DiceModifier): DodgeRollContext {

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

@@ -5,6 +5,8 @@ import com.jervisffb.engine.model.Player
 import com.jervisffb.engine.model.RerollSourceId
 import com.jervisffb.engine.model.SkillId
 import com.jervisffb.engine.model.SkillKeyword
+import com.jervisffb.engine.model.context.DodgeRollContext
+import com.jervisffb.engine.model.context.getContextOrNull
 import com.jervisffb.engine.rules.DiceRollType
 import com.jervisffb.engine.rules.common.procedures.DieRoll
 import com.jervisffb.engine.rules.common.skills.D6StandardSkillReroll
@@ -41,6 +43,7 @@ class Dodge(
     )
 
     override fun canReroll(state: Game, type: DiceRollType, value: List<DieRoll<*>>, wasSuccess: Boolean?): Boolean {
-        return type == DiceRollType.DODGE
+        val context = state.getContextOrNull<DodgeRollContext>()
+        return (type == DiceRollType.DODGE) && (context?.useTackle == null)
     }
 }

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/common/procedures/actions/block/Stumble.kt

@@ -10,6 +10,7 @@ import com.jervisffb.engine.actions.GameAction
 import com.jervisffb.engine.actions.GameActionDescriptor
 import com.jervisffb.engine.commands.Command
 import com.jervisffb.engine.commands.SetPlayerState
+import com.jervisffb.engine.commands.buildCompositeCommand
 import com.jervisffb.engine.commands.compositeCommandOf
 import com.jervisffb.engine.commands.context.RemoveContext
 import com.jervisffb.engine.commands.context.SetContext
@@ -26,6 +27,7 @@ import com.jervisffb.engine.model.context.StumbleContext
 import com.jervisffb.engine.model.context.assertContext
 import com.jervisffb.engine.model.context.getContext
 import com.jervisffb.engine.model.hasSkill
+import com.jervisffb.engine.reports.ReportSkillUsed
 import com.jervisffb.engine.reports.ReportStumbleResult
 import com.jervisffb.engine.rules.Rules
 import com.jervisffb.engine.rules.common.procedures.tables.injury.KnockedDown
@@ -35,7 +37,9 @@ import com.jervisffb.engine.utils.INVALID_ACTION
 
 /**
  * Resolve a Stumble when selected on a block die.
- * See page 57 in the rulebook.
+ *
+ * See page 57 in the BB2020 rulebook.
+ * See page 62 in the BB2025 rulebook.
  */
 object Stumble: Procedure() {
     override val initialNode: Node = ChooseToUseTackle
@@ -62,24 +66,26 @@ object Stumble: Procedure() {
         override fun actionOwner(state: Game, rules: Rules): Team = state.getContext<StumbleContext>().attacker.team
         override fun getAvailableActions(state: Game, rules: Rules): List<GameActionDescriptor> {
             val stumbleContext = state.getContext<StumbleContext>()
-            return if (stumbleContext.attacker.hasSkill(SkillType.TACKLE)) {
+            val attackerHasTackle = stumbleContext.attacker.hasSkill(SkillType.TACKLE)
+            val defenderHasDodge = stumbleContext.defender.hasSkill(SkillType.DODGE)
+            return if (attackerHasTackle && defenderHasDodge) {
                 listOf(ConfirmWhenReady, CancelWhenReady)
             } else {
                 listOf(ContinueWhenReady)
             }
         }
         override fun applyAction(action: GameAction, state: Game, rules: Rules): Command {
-            val useTackle = when (action) {
-                Confirm -> true
-                Cancel,
-                Continue -> false
-                else -> INVALID_ACTION(action)
-            }
+            val useTackle = (action == Confirm)
             val updatedContext = state.getContext<StumbleContext>().copy(attackerUsesTackle = useTackle)
-            return compositeCommandOf(
-                SetContext(updatedContext),
-                if (useTackle) GotoNode(ResolvePush) else GotoNode(ChooseToUseDodge)
-            )
+            return buildCompositeCommand {
+                add(SetContext(updatedContext))
+                if (useTackle) {
+                    add(ReportSkillUsed(updatedContext.attacker, SkillType.TACKLE))
+                    add(GotoNode(ResolvePush))
+                } else {
+                    add(GotoNode(ChooseToUseDodge))
+                }
+            }
         }
     }
 

modules/jervis-engine/src/commonMain/kotlin/com/jervisffb/engine/rules/common/procedures/actions/move/DodgeRoll.kt

@@ -68,15 +68,16 @@ import com.jervisffb.engine.utils.calculateAvailableRerollsFor
  *      a. -1 for each marking player in the target field.
  *      b. Stunty* (Ignore all -1 marked modifiers in the target field).
  *      c. Titchy* (+1).
- * 2. Choose optional modifiers. These apply to both roll and reroll.
+ * 3. Choose optional modifiers. These apply to both roll and reroll.
  *      a. Two Heads (+1).
  *      b. Break Tackle (+1/+2 in 2020, +1/+2/+3 in 2025).
  *      c. Prehensile Tail (-1).
  *      d. Diving Tackle (-2, and user prone).
- * 4. Choose to Reroll or not.
- * 5. If Reroll. Choose optional modifiers with negative consequences for the user.
+ * 4. Choose to use Tackle or not.
+ * 5. Choose to Reroll or not.
+ * 6. If Reroll. Choose optional modifiers with negative consequences for the user.
  *      a. Diving Tackle
- * 6. Calculate the final result.
+ * 7. Calculate the final result.
  *
  * Designer's Commentary (BB2020):
  * It is possible to wait using Diving Tackle until the reroll has been made.
@@ -330,11 +331,58 @@ object DodgeRoll: Procedure() {
             val success = testAgainstAgility(context.player, context.roll!!.result, context.rollModifiers)
             return compositeCommandOf(
                 SetContext(context.copy(isSuccess = success)),
-                if (afterReroll) ExitProcedure() else GotoNode(ChooseReRollSource)
+                if (afterReroll) ExitProcedure() else GotoNode(ChooseToUseTackle)
             )
         }
     }
 
+    object ChooseToUseTackle: ActionNode() {
+        override fun actionOwner(state: Game, rules: Rules): Team {
+            return state.getContext<DodgeRollContext>().player.team.otherTeam()
+        }
+
+        override fun getAvailableActions(state: Game, rules: Rules): List<GameActionDescriptor> {
+            val context = state.getContext<DodgeRollContext>()
+            val dodgingPlayerHasDodge = context.player.isSkillAvailable(SkillType.DODGE)
+            val playersWithTackle = context.startingSquare.getSurroundingCoordinates(rules, distance = 1, includeOutOfBounds = false).mapNotNull {
+                val player = state.field[it].player
+                if (player != null && player.isSkillAvailable(SkillType.TACKLE)) {
+                    player
+                } else {
+                    null
+                }
+            }
+
+            return if (dodgingPlayerHasDodge && playersWithTackle.isNotEmpty()) {
+                listOf(SelectPlayer.fromPlayers(playersWithTackle), CancelWhenReady)
+            } else {
+                listOf(ContinueWhenReady)
+            }
+        }
+
+        override fun applyAction(
+            action: GameAction,
+            state: Game,
+            rules: Rules
+        ): Command {
+            val context = state.getContext<DodgeRollContext>()
+            return when (action) {
+                is PlayerSelected -> {
+                    val tacklePlayer = action.getPlayer(state)
+                    compositeCommandOf(
+                        ReportSkillUsed(tacklePlayer, SkillType.TACKLE),
+                        SetContext(context.copy(useTackle = tacklePlayer)),
+                        GotoNode(ChooseReRollSource)
+                    )
+                }
+                Cancel, Continue -> {
+                    GotoNode(ChooseReRollSource)
+                }
+                else -> INVALID_ACTION(action)
+            }
+        }
+    }
+
     /**
      * Choose where a reroll should come from (if any). This can be skills, team rerolls, special cards
      * or other sources.

modules/jervis-engine/src/commonTest/kotlin/com/jervisffb/test/bb2025/skills/TackleTests.kt

@@ -0,0 +1,129 @@
+package com.jervisffb.test.bb2025.skills
+
+import com.jervisffb.engine.actions.BlockTypeSelected
+import com.jervisffb.engine.actions.Cancel
+import com.jervisffb.engine.actions.Confirm
+import com.jervisffb.engine.actions.DirectionSelected
+import com.jervisffb.engine.actions.EndAction
+import com.jervisffb.engine.actions.NoRerollSelected
+import com.jervisffb.engine.actions.PlayerActionSelected
+import com.jervisffb.engine.actions.PlayerSelected
+import com.jervisffb.engine.actions.SelectRerollOption
+import com.jervisffb.engine.ext.d6
+import com.jervisffb.engine.ext.dblock
+import com.jervisffb.engine.ext.playerId
+import com.jervisffb.engine.model.Direction
+import com.jervisffb.engine.model.PlayerState
+import com.jervisffb.engine.model.locations.FieldCoordinate
+import com.jervisffb.engine.rules.bb2025.skills.Dodge
+import com.jervisffb.engine.rules.bb2025.skills.Tackle
+import com.jervisffb.engine.rules.common.actions.BlockType
+import com.jervisffb.engine.rules.common.actions.PlayerStandardActionType
+import com.jervisffb.engine.rules.common.skills.RegularTeamReroll
+import com.jervisffb.engine.rules.common.skills.SkillType
+import com.jervisffb.test.JervisGameBB2025Test
+import com.jervisffb.test.activatePlayer
+import com.jervisffb.test.ext.rollForward
+import com.jervisffb.test.moveTo
+import com.jervisffb.test.utils.SelectSingleBlockDieResult
+import com.jervisffb.test.utils.SelectTeamReroll
+import kotlin.test.BeforeTest
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+/**
+ * Class testing usage of the [Tackle] skill.
+ */
+class TackleTests: JervisGameBB2025Test() {
+
+    @BeforeTest
+    override fun setUp() {
+        super.setUp()
+        startDefaultGame()
+    }
+
+    @Test
+    fun useTackleOnDodgingAway() {
+        homeTeam["H1".playerId].addSkill(SkillType.TACKLE)
+        awayTeam["A1".playerId].addSkill(SkillType.DODGE)
+        controller.rollForward(
+            *activatePlayer("A1", PlayerStandardActionType.MOVE),
+            *moveTo(14, 5),
+            1.d6, // Fail Dodge
+            PlayerSelected("H1".playerId), // Use Tackle to prevent Dodge reroll
+        )
+        assertTrue(controller.getAvailableActions().get<SelectRerollOption>().options.none { it.getRerollSource(state) is Dodge })
+        controller.rollForward(
+            SelectTeamReroll<RegularTeamReroll>(),
+            6.d6,
+            EndAction,
+        )
+        assertEquals(PlayerState.STANDING, awayTeam["A1".playerId].state)
+    }
+
+    @Test
+    fun doNotUseTackleIfNotNeededOnDodge() {
+        homeTeam["H1".playerId].addSkill(SkillType.TACKLE)
+        controller.rollForward(
+            *activatePlayer("A1", PlayerStandardActionType.MOVE),
+            *moveTo(14, 5),
+            1.d6, // Fail Dodge
+        )
+        // Dodge reroll is not available
+        assertFalse(controller.getAvailableActions().get<SelectRerollOption>().options.any { it.getRerollSource(state) is Dodge })
+        controller.rollForward(
+            SelectTeamReroll<RegularTeamReroll>(),
+            6.d6,
+            EndAction,
+        )
+        assertEquals(PlayerState.STANDING, awayTeam["A1".playerId].state)
+    }
+
+    @Test
+    fun useTackleOnBlock() {
+        homeTeam["H1".playerId].addSkill(SkillType.DODGE)
+        awayTeam["A1".playerId].addSkill(SkillType.TACKLE)
+        val attacker = state.getPlayerById("A1".playerId)
+        val defender = state.getPlayerById("H1".playerId)
+        controller.rollForward(
+            PlayerSelected(attacker.id),
+            PlayerActionSelected(PlayerStandardActionType.BLOCK),
+            PlayerSelected(defender.id),
+            BlockTypeSelected(BlockType.STANDARD),
+            5.dblock, // Stumble result
+            NoRerollSelected(),
+            SelectSingleBlockDieResult(),
+            Confirm, // Use Tackle
+            DirectionSelected(Direction.UP_LEFT),
+            Cancel // Do not follow up
+        )
+        assertEquals(FieldCoordinate(13, 5), attacker.location)
+        assertEquals(PlayerState.STANDING, attacker.state)
+        assertEquals(FieldCoordinate(11, 4), defender.location)
+        assertEquals(PlayerState.KNOCKED_DOWN, defender.state)
+    }
+
+    @Test
+    fun doNotUseTackleIfNotNeededOnBlock() {
+        awayTeam["A1".playerId].addSkill(SkillType.TACKLE)
+        val attacker = state.getPlayerById("A1".playerId)
+        val defender = state.getPlayerById("H1".playerId)
+        controller.rollForward(
+            PlayerSelected(attacker.id),
+            PlayerActionSelected(PlayerStandardActionType.BLOCK),
+            PlayerSelected(defender.id),
+            BlockTypeSelected(BlockType.STANDARD),
+            5.dblock, // Stumble result
+            NoRerollSelected(),
+            SelectSingleBlockDieResult(),
+            DirectionSelected(Direction.UP_LEFT),
+            Cancel // Do not follow up
+        )
+        assertEquals(FieldCoordinate(13, 5), attacker.location)
+        assertEquals(PlayerState.STANDING, attacker.state)
+        assertEquals(FieldCoordinate(11, 4), defender.location)
+        assertEquals(PlayerState.KNOCKED_DOWN, defender.state)
+    }
+}

modules/jervis-ui/src/commonMain/kotlin/com/jervisffb/ui/game/state/ManualActionProvider.kt

@@ -54,7 +54,9 @@ import com.jervisffb.engine.rules.common.procedures.TheKickOff
 import com.jervisffb.engine.rules.common.procedures.actions.blitz.BlitzAction
 import com.jervisffb.engine.rules.common.procedures.actions.block.BlockAction
 import com.jervisffb.engine.rules.common.procedures.actions.block.PushStepInitialMoveSequence
+import com.jervisffb.engine.rules.common.procedures.actions.block.Stumble
 import com.jervisffb.engine.rules.common.procedures.actions.block.standard.StandardBlockChooseResult
+import com.jervisffb.engine.rules.common.procedures.actions.move.DodgeRoll
 import com.jervisffb.engine.rules.common.procedures.actions.move.JumpStep
 import com.jervisffb.engine.rules.common.procedures.actions.pass.PassContext
 import com.jervisffb.engine.rules.common.procedures.tables.injury.ArmourRoll
@@ -574,6 +576,16 @@ open class ManualActionProvider(
             }
         }
 
+        if (menuViewModel.isFeatureEnabled(Feature.ALWAYS_USE_TACKLE_ON_DODGE) && (currentNode == DodgeRoll.ChooseToUseTackle)) {
+            // Always select the first available player to use Tackle
+            val selectedPlayer = availableActions.get<SelectPlayer>().players.first()
+            return PlayerSelected(selectedPlayer)
+        }
+
+        if (menuViewModel.isFeatureEnabled(Feature.ALWAYS_USE_TACKLE_ON_STUMBLE) && (currentNode == Stumble.ChooseToUseTackle)) {
+            return Confirm
+        }
+
         return null
     }
 

modules/jervis-ui/src/commonMain/kotlin/com/jervisffb/ui/game/state/decorators/CancelDecorator.kt

@@ -7,6 +7,7 @@ import com.jervisffb.engine.model.Game
 import com.jervisffb.engine.model.Team
 import com.jervisffb.engine.rules.bb2025.procedures.actions.pass.InterceptionStep
 import com.jervisffb.engine.rules.bb2025.procedures.skills.UseShadowingStep
+import com.jervisffb.engine.rules.common.procedures.actions.move.DodgeRoll
 import com.jervisffb.ui.game.UiSnapshotAccumulator
 import com.jervisffb.ui.game.state.ManualActionProvider
 
@@ -17,7 +18,9 @@ object CancelDecorator : FieldActionDecorator<CancelWhenReady> {
 
     private val nodesToDecorate = setOf(
         UseShadowingStep.CheckIfShadowingIsAvailable,
-        InterceptionStep.SelectPlayerForInterception
+        InterceptionStep.SelectPlayerForInterception,
+        DodgeRoll.ChooseToUseTackle,
+        DodgeRoll.ChooseToUsePrehensileTail
     )
 
     override fun isApplicable(state: Game, request: ActionRequest): Boolean {
@@ -35,6 +38,8 @@ object CancelDecorator : FieldActionDecorator<CancelWhenReady> {
         val title = when (state.stack.currentNode()) {
             UseShadowingStep.CheckIfShadowingIsAvailable -> "Do not use Shadowing"
             InterceptionStep.SelectPlayerForInterception -> "Do not intercept"
+            DodgeRoll.ChooseToUseTackle -> "Do not use Tackle"
+            DodgeRoll.ChooseToUsePrehensileTail -> "Do not use Prehensile Tail"
             else -> error("Unsupported node: ${state.stack.currentNode()}")
         }
         acc.updateGameStatus {