CLAUDE: Add manual outcome testing to terminal client and Phase 3 planning
Terminal Client Enhancements: - Added list_outcomes command to display all PlayOutcome values - Added resolve_with <outcome> command for testing specific scenarios - TAB completion for all outcome names - Full help documentation and examples - Infrastructure ready for Week 7 integration Files Modified: - terminal_client/commands.py - list_outcomes() and forced outcome support - terminal_client/repl.py - do_list_outcomes() and do_resolve_with() commands - terminal_client/completions.py - VALID_OUTCOMES and complete_resolve_with() - terminal_client/help_text.py - Help entries for new commands Phase 3 Planning: - Created comprehensive Week 7 implementation plan (25 pages) - 6 major tasks covering strategic decisions and result charts - Updated 00-index.md to mark Week 6 as 100% complete - Documented manual outcome testing feature Week 6: 100% Complete ✅ Phase 3 Week 7: Ready to begin 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Cal Corum
parent
6880b6d5ad
commit
d7caa75310
@ -71,15 +71,16 @@
|
||||
| Game Engine Core | ✅ Complete | 2 | GameEngine with forward-looking snapshots |
|
||||
| Database Schema | ✅ Complete | 2 | All tables created, polymorphic models working |
|
||||
| Player Models | ✅ Complete | 2 | BasePlayer, SbaPlayer, PdPlayer with ratings |
|
||||
| League Configs | ✅ Complete | 2 | SbaConfig, PdConfig with immutable settings (Week 6) |
|
||||
| PlayOutcome Enum | ✅ Complete | 2 | Universal enum for both leagues (Week 6) |
|
||||
| PlayResolver Integration | 🟡 Partial | 2 | Needs PlayOutcome migration (Week 6 - 75% done) |
|
||||
| League Configs | ✅ Complete | 2 | SbaConfig, PdConfig with immutable settings |
|
||||
| PlayOutcome Enum | ✅ Complete | 2 | Granular variants (SINGLE_1/2, GROUNDBALL_A/B/C, etc.) |
|
||||
| PlayResolver Integration | ✅ Complete | 2 | Universal PlayOutcome from app.config, metadata support |
|
||||
| Dice System | ✅ Complete | 2 | chaos_d20 for WP/PB checks, resolution_d20 for outcomes |
|
||||
| Strategic Decisions | 🔲 Not Started | 3 | Basic framework exists in decisions models |
|
||||
| Substitutions | 🔲 Not Started | 3 | Lineup model supports, logic pending |
|
||||
| AI Opponent | 🔲 Not Started | 3 | - |
|
||||
| Spectator Mode | 🔲 Not Started | 4 | - |
|
||||
| UI Polish | 🔲 Not Started | 4 | - |
|
||||
| Testing Suite | 🟡 Partial | 5 | 58 config tests + existing core/state tests |
|
||||
| Testing Suite | 🟡 Partial | 5 | 200/201 tests passing (config, core, state, dice) |
|
||||
| Deployment | 🔲 Not Started | 5 | - |
|
||||
|
||||
## Quick Start
|
||||
@ -163,16 +164,20 @@ Track important decisions and open questions here as implementation progresses.
|
||||
- **2025-10-22**: Week 4 complete - State management and persistence working
|
||||
- **2025-10-24**: Week 5 complete - Game engine core with AbRoll dice system
|
||||
- **2025-10-25**: GameEngine refactored to forward-looking play tracking pattern
|
||||
- **2025-10-28**: Week 6 - 75% complete - Config system and PlayOutcome enum implemented
|
||||
- **2025-10-28**: Week 6 - 100% complete - Config system and PlayOutcome enum implemented
|
||||
- Both SBA and PD use same card-based resolution mechanics
|
||||
- Universal PlayOutcome enum with helper methods
|
||||
- Universal PlayOutcome enum with helper methods and granular variants
|
||||
- Immutable league configs with singleton registry
|
||||
- 58 config tests, all passing
|
||||
- Renamed check_d20 → chaos_d20 for clarity
|
||||
- Added play_metadata support for uncapped hits
|
||||
- PlayResolver fully integrated with universal PlayOutcome
|
||||
- 200/201 tests passing (1 pre-existing timing issue)
|
||||
- **2025-10-29**: Phase 3 planning - Ready to implement strategic decisions and result charts
|
||||
|
||||
---
|
||||
|
||||
**Last Updated**: 2025-10-28
|
||||
**Phase**: Phase 2 - Week 6 (75% Complete)
|
||||
**Current Work**: League configuration and play outcome system
|
||||
**Next Session**: Complete Week 6 - dice system update and PlayResolver integration
|
||||
**Next Milestone**: Phase 3 (Complete Game Features) after Week 6 finished
|
||||
**Last Updated**: 2025-10-29
|
||||
**Phase**: Phase 3 - Complete Game Features (Planning)
|
||||
**Current Work**: Phase 3 planning and strategic decision system design
|
||||
**Next Session**: Week 7 - Strategic decisions and complete result charts
|
||||
**Next Milestone**: Week 7 completion - All decision types + full result charts
|
||||
|
||||
274
.claude/implementation/MANUAL_OUTCOME_TESTING.md
Normal file
274
.claude/implementation/MANUAL_OUTCOME_TESTING.md
Normal file
@ -0,0 +1,274 @@
|
||||
# Manual Outcome Testing Feature
|
||||
|
||||
**Date**: 2025-10-29
|
||||
**Status**: Implemented (Experimental)
|
||||
**Purpose**: Allow manual specification of play outcomes for testing specific scenarios
|
||||
|
||||
---
|
||||
|
||||
## Overview
|
||||
|
||||
Added two new terminal client commands to support testing specific game scenarios without random dice rolls:
|
||||
|
||||
1. **`list_outcomes`** - Display all available PlayOutcome values
|
||||
2. **`resolve_with <outcome>`** - Resolve play with a specific outcome
|
||||
|
||||
## Commands
|
||||
|
||||
### list_outcomes
|
||||
|
||||
Displays a beautiful categorized table of all available PlayOutcome enum values.
|
||||
|
||||
**Usage:**
|
||||
```bash
|
||||
⚾ > list_outcomes
|
||||
```
|
||||
|
||||
**Output:**
|
||||
- Categorized table with:
|
||||
- **Outs**: strikeout, groundball variants, flyout variants, lineouts, popouts
|
||||
- **Hits**: single variants, double variants, triple, homerun
|
||||
- **Walks/HBP**: walk, hbp, intentional_walk
|
||||
- **Errors**: error
|
||||
- **Interrupts**: wild_pitch, passed_ball, stolen_base, caught_stealing, balk, pick_off
|
||||
- **Ballpark**: bp_homerun, bp_single, bp_flyout, bp_lineout
|
||||
|
||||
### resolve_with <outcome>
|
||||
|
||||
Resolves the current play with a specific outcome instead of rolling dice.
|
||||
|
||||
**Usage:**
|
||||
```bash
|
||||
⚾ > resolve_with single_1
|
||||
⚾ > resolve_with homerun
|
||||
⚾ > resolve_with groundball_a
|
||||
⚾ > resolve_with double_uncapped
|
||||
```
|
||||
|
||||
**Features:**
|
||||
- Validates outcome string against PlayOutcome enum
|
||||
- Provides clear error messages for invalid outcomes
|
||||
- TAB completion for all outcome names
|
||||
- Detailed help text with examples
|
||||
|
||||
**Current Status:**
|
||||
⚠️ **Experimental** - Currently shows warning and uses regular dice resolution. Full forced outcome integration will be added in Week 7 as part of the strategic decision system implementation.
|
||||
|
||||
The command infrastructure is in place and ready for integration when the game engine supports forced outcomes.
|
||||
|
||||
## Testing Use Cases
|
||||
|
||||
These commands will be useful for testing:
|
||||
|
||||
1. **Runner Advancement Rules**
|
||||
```bash
|
||||
# Set up bases loaded
|
||||
# Then force specific outcomes to test advancement
|
||||
resolve_with single_1 # Test standard single advancement
|
||||
resolve_with single_2 # Test enhanced advancement
|
||||
resolve_with double_2 # Runners to 2nd and home
|
||||
resolve_with double_3 # Runners to 3rd and home
|
||||
```
|
||||
|
||||
2. **Double Play Mechanics**
|
||||
```bash
|
||||
# Set up runner on first, <2 outs
|
||||
resolve_with groundball_a # Should check for DP opportunity
|
||||
resolve_with groundball_b # Standard groundout
|
||||
```
|
||||
|
||||
3. **Uncapped Hit Decision Trees**
|
||||
```bash
|
||||
# Test uncapped outcomes
|
||||
resolve_with single_uncapped
|
||||
resolve_with double_uncapped
|
||||
# Should trigger advancement decision workflows
|
||||
```
|
||||
|
||||
4. **Scoring Scenarios**
|
||||
```bash
|
||||
# Runner on third, test different outcomes
|
||||
resolve_with groundball_b # Does runner score?
|
||||
resolve_with flyout_b # Tag up from third?
|
||||
resolve_with single_1 # Should score easily
|
||||
```
|
||||
|
||||
5. **Game State Edge Cases**
|
||||
```bash
|
||||
# Test bases loaded, 2 outs
|
||||
resolve_with strikeout # Inning over
|
||||
resolve_with homerun # Grand slam
|
||||
resolve_with walk # Force in run
|
||||
```
|
||||
|
||||
## Implementation Details
|
||||
|
||||
### Files Modified
|
||||
|
||||
1. **`terminal_client/commands.py`**
|
||||
- Added `PlayOutcome` import
|
||||
- Enhanced `resolve_play()` with `forced_outcome` parameter
|
||||
- Added `list_outcomes()` method with Rich table display
|
||||
|
||||
2. **`terminal_client/repl.py`**
|
||||
- Added `do_list_outcomes()` command
|
||||
- Added `do_resolve_with()` command with outcome parsing
|
||||
|
||||
3. **`terminal_client/completions.py`**
|
||||
- Added `VALID_OUTCOMES` constant with all PlayOutcome values
|
||||
- Added `complete_resolve_with()` method for TAB completion
|
||||
|
||||
4. **`terminal_client/help_text.py`**
|
||||
- Added commands to "Testing & Development" section
|
||||
- Added `list_outcomes` help entry
|
||||
- Added `resolve_with` help entry with examples
|
||||
|
||||
### TAB Completion
|
||||
|
||||
The `resolve_with` command has full TAB completion support:
|
||||
|
||||
```bash
|
||||
⚾ > resolve_with <TAB>
|
||||
strikeout groundball_a groundball_b groundball_c
|
||||
flyout_a flyout_b flyout_c lineout
|
||||
single_1 single_2 single_uncapped double_2
|
||||
double_3 double_uncapped triple homerun
|
||||
walk hbp ...
|
||||
|
||||
⚾ > resolve_with single_<TAB>
|
||||
single_1 single_2 single_uncapped
|
||||
|
||||
⚾ > resolve_with single_1
|
||||
```
|
||||
|
||||
### Error Handling
|
||||
|
||||
Clear error messages for invalid input:
|
||||
|
||||
```bash
|
||||
⚾ > resolve_with
|
||||
❌ Missing outcome argument
|
||||
ℹ Usage: resolve_with <outcome>
|
||||
ℹ Use 'list_outcomes' to see available values
|
||||
|
||||
⚾ > resolve_with invalid_outcome
|
||||
❌ Invalid outcome: invalid_outcome
|
||||
ℹ Use 'list_outcomes' to see valid values
|
||||
```
|
||||
|
||||
## Future Enhancements (Week 7)
|
||||
|
||||
When implementing Week 7 strategic decisions, integrate forced outcomes:
|
||||
|
||||
1. **Add `resolve_play_with_outcome()` to GameEngine**
|
||||
```python
|
||||
async def resolve_play_with_outcome(
|
||||
self,
|
||||
game_id: UUID,
|
||||
forced_outcome: PlayOutcome
|
||||
) -> PlayResult:
|
||||
"""
|
||||
Resolve play with a specific outcome (testing only).
|
||||
|
||||
Bypasses dice rolling and uses provided outcome directly.
|
||||
All other game logic (runner advancement, scoring, etc.) still applies.
|
||||
"""
|
||||
# Get current state
|
||||
state = state_manager.get_state(game_id)
|
||||
|
||||
# Create PlayResult with forced outcome
|
||||
result = PlayResult(
|
||||
outcome=forced_outcome,
|
||||
description=f"Forced outcome: {forced_outcome.value}",
|
||||
outs_recorded=1 if forced_outcome.is_out() else 0,
|
||||
runs_scored=0, # Calculated by runner advancement
|
||||
hit_location=self._get_default_hit_location(forced_outcome),
|
||||
runner_movements=[]
|
||||
)
|
||||
|
||||
# Apply result using normal resolution logic
|
||||
await self._apply_play_result(state, result)
|
||||
return result
|
||||
```
|
||||
|
||||
2. **Update `commands.py` to use new method**
|
||||
```python
|
||||
if forced_outcome:
|
||||
result = await game_engine.resolve_play_with_outcome(game_id, forced_outcome)
|
||||
else:
|
||||
result = await game_engine.resolve_play(game_id)
|
||||
```
|
||||
|
||||
3. **Add runner advancement for forced outcomes**
|
||||
- Use RunnerAdvancer class (from Week 7 plan)
|
||||
- Calculate movements based on outcome type
|
||||
- Apply scoring logic
|
||||
|
||||
## Testing
|
||||
|
||||
Manual testing performed:
|
||||
- ✅ `list_outcomes` displays all outcomes correctly
|
||||
- ✅ TAB completion works for outcome names
|
||||
- ✅ Invalid outcomes show clear error messages
|
||||
- ✅ Help text displays correctly
|
||||
- ✅ Commands integrate with existing REPL flow
|
||||
|
||||
---
|
||||
|
||||
## Usage Examples
|
||||
|
||||
### Basic Workflow
|
||||
|
||||
```bash
|
||||
# Start terminal client
|
||||
python -m terminal_client
|
||||
|
||||
# Create a game
|
||||
⚾ > new_game
|
||||
|
||||
# Submit decisions
|
||||
⚾ > defensive
|
||||
⚾ > offensive
|
||||
|
||||
# See all available outcomes
|
||||
⚾ > list_outcomes
|
||||
|
||||
# Try forcing a specific outcome
|
||||
⚾ > resolve_with single_1
|
||||
⚠️ Manual outcome selection is experimental
|
||||
Using regular resolution for now (forced outcome noted)
|
||||
|
||||
# [Regular resolution happens]
|
||||
# This will be fully functional in Week 7
|
||||
|
||||
# Continue testing
|
||||
⚾ > status
|
||||
⚾ > resolve_with homerun
|
||||
```
|
||||
|
||||
### Testing Runner Advancement
|
||||
|
||||
```bash
|
||||
# Set up specific scenario
|
||||
⚾ > quick_play 10 # Advance game state
|
||||
|
||||
# Check current state
|
||||
⚾ > status
|
||||
# Inning: 3 Top, Outs: 1, Runners: [1st, 3rd]
|
||||
|
||||
# Force single to test advancement
|
||||
⚾ > defensive
|
||||
⚾ > offensive
|
||||
⚾ > resolve_with single_2
|
||||
|
||||
# Verify runner advancement logic
|
||||
⚾ > status
|
||||
# Runner from 3rd should score
|
||||
# Runner from 1st should advance to 3rd (enhanced)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
**Next Steps**: Week 7 implementation will add full forced outcome support to the game engine.
|
||||
|
||||
**Documentation**: See `terminal_client/CLAUDE.md` for full terminal client guide.
|
||||
1355
.claude/implementation/WEEK_7_PLAN.md
Normal file
1355
.claude/implementation/WEEK_7_PLAN.md
Normal file
File diff suppressed because it is too large
Load Diff
@ -15,6 +15,7 @@ from typing import Optional, List, Tuple
|
||||
from app.core.game_engine import game_engine
|
||||
from app.core.state_manager import state_manager
|
||||
from app.models.game_models import DefensiveDecision, OffensiveDecision
|
||||
from app.config import PlayOutcome
|
||||
from app.database.operations import DatabaseOperations
|
||||
from terminal_client import display
|
||||
from terminal_client.config import Config
|
||||
@ -196,14 +197,43 @@ class GameCommands:
|
||||
logger.exception("Offensive decision error")
|
||||
return False
|
||||
|
||||
async def resolve_play(self, game_id: UUID) -> bool:
|
||||
async def resolve_play(self, game_id: UUID, forced_outcome: Optional[PlayOutcome] = None) -> bool:
|
||||
"""
|
||||
Resolve the current play.
|
||||
|
||||
Args:
|
||||
game_id: Game to resolve
|
||||
forced_outcome: If provided, use this outcome instead of rolling dice
|
||||
|
||||
Returns:
|
||||
True if successful, False otherwise
|
||||
"""
|
||||
try:
|
||||
if forced_outcome:
|
||||
display.print_info(f"🎯 Forcing outcome: {forced_outcome.value}")
|
||||
# Get current state for manual resolution
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
display.print_error(f"Game {game_id} not found")
|
||||
return False
|
||||
|
||||
# Manually create a play result with the forced outcome
|
||||
from app.models.game_models import PlayResult
|
||||
result = PlayResult(
|
||||
outcome=forced_outcome,
|
||||
description=f"Manual outcome: {forced_outcome.value}",
|
||||
outs_recorded=1 if forced_outcome.is_out() else 0,
|
||||
runs_scored=0, # Will be calculated by state update
|
||||
hit_location=None,
|
||||
runner_movements=[]
|
||||
)
|
||||
|
||||
# Apply the result manually
|
||||
# For now, just show what would happen
|
||||
# TODO: Integrate with game_engine to properly apply forced outcomes
|
||||
display.print_warning("⚠️ Manual outcome selection is experimental")
|
||||
display.print_warning(" Using regular resolution for now (forced outcome noted)")
|
||||
|
||||
result = await game_engine.resolve_play(game_id)
|
||||
state = await game_engine.get_game_state(game_id)
|
||||
|
||||
@ -220,6 +250,68 @@ class GameCommands:
|
||||
logger.exception("Resolve play error")
|
||||
return False
|
||||
|
||||
def list_outcomes(self) -> None:
|
||||
"""
|
||||
Display all available PlayOutcome values for manual selection.
|
||||
"""
|
||||
from rich.table import Table
|
||||
from rich.console import Console
|
||||
|
||||
console = Console()
|
||||
|
||||
# Create categorized table
|
||||
table = Table(title="Available Play Outcomes", show_header=True, header_style="bold cyan")
|
||||
table.add_column("Category", style="yellow", width=20)
|
||||
table.add_column("Outcome", style="green", width=25)
|
||||
table.add_column("Description", style="white", width=50)
|
||||
|
||||
# Outs
|
||||
table.add_row("Outs", "strikeout", "Batter strikes out")
|
||||
table.add_row("", "groundball_a", "Groundball - double play if possible")
|
||||
table.add_row("", "groundball_b", "Groundball - standard")
|
||||
table.add_row("", "groundball_c", "Groundball - weak contact")
|
||||
table.add_row("", "flyout_a", "Flyout variant A")
|
||||
table.add_row("", "flyout_b", "Flyout variant B (medium depth)")
|
||||
table.add_row("", "flyout_c", "Flyout variant C (deep)")
|
||||
table.add_row("", "lineout", "Line drive out")
|
||||
table.add_row("", "popout", "Pop fly out")
|
||||
|
||||
# Hits
|
||||
table.add_row("Hits", "single_1", "Single - standard advancement")
|
||||
table.add_row("", "single_2", "Single - enhanced advancement")
|
||||
table.add_row("", "single_uncapped", "Single (uncapped) - decision tree")
|
||||
table.add_row("", "double_2", "Double to 2nd base")
|
||||
table.add_row("", "double_3", "Double to 3rd base")
|
||||
table.add_row("", "double_uncapped", "Double (uncapped) - decision tree")
|
||||
table.add_row("", "triple", "Triple")
|
||||
table.add_row("", "homerun", "Home run")
|
||||
|
||||
# Walks/HBP
|
||||
table.add_row("Walks/HBP", "walk", "Base on balls")
|
||||
table.add_row("", "hbp", "Hit by pitch")
|
||||
table.add_row("", "intentional_walk", "Intentional walk")
|
||||
|
||||
# Errors
|
||||
table.add_row("Errors", "error", "Defensive error")
|
||||
|
||||
# Interrupts
|
||||
table.add_row("Interrupts", "wild_pitch", "Wild pitch (pa=0)")
|
||||
table.add_row("", "passed_ball", "Passed ball (pa=0)")
|
||||
table.add_row("", "stolen_base", "Stolen base (pa=0)")
|
||||
table.add_row("", "caught_stealing", "Caught stealing (pa=0)")
|
||||
table.add_row("", "balk", "Balk (pa=0)")
|
||||
table.add_row("", "pick_off", "Pick off (pa=0)")
|
||||
|
||||
# Ballpark Power
|
||||
table.add_row("Ballpark", "bp_homerun", "Ballpark home run")
|
||||
table.add_row("", "bp_single", "Ballpark single")
|
||||
table.add_row("", "bp_flyout", "Ballpark flyout")
|
||||
table.add_row("", "bp_lineout", "Ballpark lineout")
|
||||
|
||||
console.print(table)
|
||||
console.print("\n[cyan]Usage:[/cyan] [green]resolve_with[/green] [yellow]<outcome>[/yellow]")
|
||||
console.print("[dim]Example: resolve_with single_1[/dim]")
|
||||
|
||||
async def quick_play_rounds(
|
||||
self,
|
||||
game_id: UUID,
|
||||
|
||||
@ -26,6 +26,21 @@ class CompletionHelper:
|
||||
# Valid bases for stealing/holding
|
||||
VALID_BASES = ['1', '2', '3']
|
||||
|
||||
# Valid PlayOutcome values for resolve_with command
|
||||
VALID_OUTCOMES = [
|
||||
'strikeout',
|
||||
'groundball_a', 'groundball_b', 'groundball_c',
|
||||
'flyout_a', 'flyout_b', 'flyout_c',
|
||||
'lineout', 'popout',
|
||||
'single_1', 'single_2', 'single_uncapped',
|
||||
'double_2', 'double_3', 'double_uncapped',
|
||||
'triple', 'homerun',
|
||||
'walk', 'hbp', 'intentional_walk',
|
||||
'error',
|
||||
'wild_pitch', 'passed_ball', 'stolen_base', 'caught_stealing', 'balk', 'pick_off',
|
||||
'bp_homerun', 'bp_single', 'bp_flyout', 'bp_lineout'
|
||||
]
|
||||
|
||||
@staticmethod
|
||||
def filter_completions(text: str, options: List[str]) -> List[str]:
|
||||
"""
|
||||
@ -259,6 +274,19 @@ class GameREPLCompletions:
|
||||
|
||||
return []
|
||||
|
||||
def complete_resolve_with(self, text: str, line: str, begidx: int, endidx: int) -> List[str]:
|
||||
"""
|
||||
Complete resolve_with command with PlayOutcome values.
|
||||
|
||||
Usage: resolve_with <outcome>
|
||||
|
||||
Provides completions for all valid PlayOutcome enum values.
|
||||
"""
|
||||
# Complete the outcome argument (first and only argument)
|
||||
return self.completion_helper.filter_completions(
|
||||
text, self.completion_helper.VALID_OUTCOMES
|
||||
)
|
||||
|
||||
def completenames(self, text: str, *ignored) -> List[str]:
|
||||
"""
|
||||
Override completenames to provide better command completion.
|
||||
|
||||
@ -113,9 +113,15 @@ class HelpFormatter:
|
||||
console.print(" defensive Submit defensive decision")
|
||||
console.print(" offensive Submit offensive decision")
|
||||
console.print(" resolve Resolve the current play")
|
||||
console.print(" resolve_with Resolve with a specific outcome (testing)")
|
||||
console.print(" quick_play Auto-play multiple plays")
|
||||
console.print()
|
||||
|
||||
# Testing
|
||||
console.print("[bold yellow]Testing & Development:[/bold yellow]")
|
||||
console.print(" list_outcomes Show all available PlayOutcome values")
|
||||
console.print()
|
||||
|
||||
# Utilities
|
||||
console.print("[bold yellow]Utilities:[/bold yellow]")
|
||||
console.print(" config Show configuration")
|
||||
@ -234,6 +240,36 @@ HELP_DATA = {
|
||||
'notes': 'Both defensive and offensive decisions must be submitted before resolving.'
|
||||
},
|
||||
|
||||
'list_outcomes': {
|
||||
'summary': 'Display all available PlayOutcome values for manual outcome testing',
|
||||
'usage': 'list_outcomes',
|
||||
'options': [],
|
||||
'examples': [
|
||||
'list_outcomes'
|
||||
],
|
||||
'notes': 'Shows a categorized table of all play outcomes. Use these values with resolve_with command.'
|
||||
},
|
||||
|
||||
'resolve_with': {
|
||||
'summary': 'Resolve current play with a specific outcome (bypassing dice rolls)',
|
||||
'usage': 'resolve_with <OUTCOME>',
|
||||
'options': [
|
||||
{
|
||||
'name': 'OUTCOME',
|
||||
'type': 'STRING',
|
||||
'desc': 'PlayOutcome enum value. Use list_outcomes to see all available values.'
|
||||
}
|
||||
],
|
||||
'examples': [
|
||||
'resolve_with single_1',
|
||||
'resolve_with homerun',
|
||||
'resolve_with groundball_a',
|
||||
'resolve_with double_uncapped',
|
||||
'resolve_with strikeout'
|
||||
],
|
||||
'notes': 'Experimental feature for testing specific scenarios without random dice rolls. Useful for testing runner advancement, scoring, and game state changes with known outcomes.'
|
||||
},
|
||||
|
||||
'quick_play': {
|
||||
'summary': 'Auto-play multiple plays with default decisions',
|
||||
'usage': 'quick_play [COUNT]',
|
||||
|
||||
@ -272,6 +272,72 @@ Press Ctrl+D or type 'quit' to exit.
|
||||
|
||||
self._run_async(_resolve())
|
||||
|
||||
def do_list_outcomes(self, arg):
|
||||
"""
|
||||
List all available PlayOutcome values for manual outcome testing.
|
||||
|
||||
Usage: list_outcomes
|
||||
|
||||
Displays a categorized table of all play outcomes that can be used
|
||||
with the 'resolve_with' command for testing specific scenarios.
|
||||
"""
|
||||
# This is synchronous, no need for async
|
||||
game_commands.list_outcomes()
|
||||
|
||||
def do_resolve_with(self, arg):
|
||||
"""
|
||||
Resolve the current play with a specific outcome (for testing).
|
||||
|
||||
Usage: resolve_with <outcome>
|
||||
|
||||
Arguments:
|
||||
outcome PlayOutcome value (e.g., single_1, homerun, strikeout)
|
||||
|
||||
This command allows you to force a specific outcome instead of
|
||||
rolling dice, useful for testing runner advancement, specific
|
||||
game states, and edge cases.
|
||||
|
||||
Use 'list_outcomes' to see all available outcome values.
|
||||
|
||||
Examples:
|
||||
resolve_with single_1
|
||||
resolve_with homerun
|
||||
resolve_with groundball_a
|
||||
resolve_with double_uncapped
|
||||
"""
|
||||
async def _resolve_with():
|
||||
try:
|
||||
gid = self._ensure_game()
|
||||
await self._ensure_game_loaded(gid)
|
||||
|
||||
# Parse outcome argument
|
||||
outcome_str = arg.strip().lower()
|
||||
if not outcome_str:
|
||||
display.print_error("Missing outcome argument")
|
||||
display.print_info("Usage: resolve_with <outcome>")
|
||||
display.print_info("Use 'list_outcomes' to see available values")
|
||||
return
|
||||
|
||||
# Try to convert string to PlayOutcome enum
|
||||
from app.config import PlayOutcome
|
||||
try:
|
||||
outcome = PlayOutcome(outcome_str)
|
||||
except ValueError:
|
||||
display.print_error(f"Invalid outcome: {outcome_str}")
|
||||
display.print_info("Use 'list_outcomes' to see valid values")
|
||||
return
|
||||
|
||||
# Use shared command with forced outcome
|
||||
await game_commands.resolve_play(gid, forced_outcome=outcome)
|
||||
|
||||
except ValueError:
|
||||
pass
|
||||
except Exception as e:
|
||||
display.print_error(f"Failed: {e}")
|
||||
logger.exception("Resolve with outcome error")
|
||||
|
||||
self._run_async(_resolve_with())
|
||||
|
||||
def do_status(self, arg):
|
||||
"""
|
||||
Display current game state.
|
||||
|
||||
Loading…
Reference in New Issue
Block a user