CLAUDE: Implement uncapped hit decision UI + backend bugfixes (Issue #7)
Frontend: Full 5-phase interactive wizard for uncapped hit decisions (lead advance, defensive throw, trail advance, throw target, safe/out) with mobile-first design, offense/defense role switching, and auto- clearing on workflow completion. Backend fixes: - Remove nested asyncio.Lock acquisition causing deadlocks in all submit_uncapped_* methods and initiate_uncapped_hit (non-re-entrant) - Preserve pending_manual_roll during interactive workflows - Add league_id to all dice_system.roll_d20() calls - Extract D20Roll.roll int for state serialization - Fix batter-runner not advancing when non-targeted in throw - Fix rollback_plays not recalculating scores from remaining plays Files: 10 modified, 1 new (UncappedHitWizard.vue) Tests: 2481/2481 passing Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Cal Corum
parent
ffcbe248bd
commit
fa3fadd14c
@ -932,11 +932,13 @@ class GameEngine:
|
||||
# Check if SPD is in any column - if so, pre-roll d20
|
||||
spd_d20 = None
|
||||
if "SPD" in chart_row:
|
||||
spd_d20 = dice_system.roll_d20(
|
||||
spd_d20_result = dice_system.roll_d20(
|
||||
league_id=state.league_id,
|
||||
game_id=game_id,
|
||||
team_id=state.get_fielding_team_id(),
|
||||
player_id=None,
|
||||
)
|
||||
spd_d20 = spd_d20_result.roll if hasattr(spd_d20_result, 'roll') else spd_d20_result
|
||||
|
||||
# Get defender at this position
|
||||
defender = state.get_defender_for_position(position, state_manager)
|
||||
@ -1157,8 +1159,10 @@ class GameEngine:
|
||||
outcome: SINGLE_UNCAPPED or DOUBLE_UNCAPPED
|
||||
hit_location: Outfield position (LF, CF, RF)
|
||||
ab_roll: The at-bat roll for audit trail
|
||||
|
||||
Note: Caller must hold the game lock (called from resolve_manual_play
|
||||
which runs inside the handler's game_lock context).
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1288,8 +1292,9 @@ class GameEngine:
|
||||
|
||||
If NO: fallback to standard SI*/DO** advancement, finalize immediately.
|
||||
If YES: transition to awaiting_uncapped_defensive_throw.
|
||||
|
||||
Caller must hold the game lock (acquired by WebSocket handler).
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1351,8 +1356,9 @@ class GameEngine:
|
||||
If NO: lead runner safe, standard advancement, finalize.
|
||||
If YES and trail runner exists: transition to awaiting_uncapped_trail_advance.
|
||||
If YES and no trail: roll d20, transition to awaiting_uncapped_safe_out.
|
||||
|
||||
Caller must hold the game lock (acquired by WebSocket handler).
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1385,11 +1391,12 @@ class GameEngine:
|
||||
if not has_trail:
|
||||
# No trail runner → roll d20 for lead runner speed check
|
||||
d20 = dice_system.roll_d20(
|
||||
league_id=state.league_id,
|
||||
game_id=game_id,
|
||||
team_id=state.get_fielding_team_id(),
|
||||
player_id=None,
|
||||
)
|
||||
pending.speed_check_d20 = d20
|
||||
pending.speed_check_d20 = d20.roll if hasattr(d20, 'roll') else d20
|
||||
pending.speed_check_runner = "lead"
|
||||
state.decision_phase = "awaiting_uncapped_safe_out"
|
||||
state.pending_decision = "uncapped_safe_out"
|
||||
@ -1407,7 +1414,7 @@ class GameEngine:
|
||||
phase="awaiting_uncapped_safe_out",
|
||||
timeout_seconds=self.DECISION_TIMEOUT,
|
||||
data={
|
||||
"d20_roll": d20,
|
||||
"d20_roll": d20.roll if hasattr(d20, 'roll') else d20,
|
||||
"runner": "lead",
|
||||
"runner_base": pending.lead_runner_base,
|
||||
"target_base": pending.lead_target_base,
|
||||
@ -1450,8 +1457,9 @@ class GameEngine:
|
||||
|
||||
If NO: roll d20 for lead runner only, transition to awaiting_uncapped_safe_out.
|
||||
If YES: transition to awaiting_uncapped_throw_target.
|
||||
|
||||
Caller must hold the game lock (acquired by WebSocket handler).
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1471,11 +1479,12 @@ class GameEngine:
|
||||
if not advance:
|
||||
# Trail declines → roll d20 for lead runner
|
||||
d20 = dice_system.roll_d20(
|
||||
league_id=state.league_id,
|
||||
game_id=game_id,
|
||||
team_id=state.get_fielding_team_id(),
|
||||
player_id=None,
|
||||
)
|
||||
pending.speed_check_d20 = d20
|
||||
pending.speed_check_d20 = d20.roll if hasattr(d20, 'roll') else d20
|
||||
pending.speed_check_runner = "lead"
|
||||
state.decision_phase = "awaiting_uncapped_safe_out"
|
||||
state.pending_decision = "uncapped_safe_out"
|
||||
@ -1492,7 +1501,7 @@ class GameEngine:
|
||||
phase="awaiting_uncapped_safe_out",
|
||||
timeout_seconds=self.DECISION_TIMEOUT,
|
||||
data={
|
||||
"d20_roll": d20,
|
||||
"d20_roll": d20.roll if hasattr(d20, 'roll') else d20,
|
||||
"runner": "lead",
|
||||
"runner_base": pending.lead_runner_base,
|
||||
"target_base": pending.lead_target_base,
|
||||
@ -1537,8 +1546,9 @@ class GameEngine:
|
||||
|
||||
LEAD: trail auto-advances, roll d20 for lead → awaiting_uncapped_safe_out.
|
||||
TRAIL: lead auto-advances, roll d20 for trail → awaiting_uncapped_safe_out.
|
||||
|
||||
Caller must hold the game lock (acquired by WebSocket handler).
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1560,11 +1570,12 @@ class GameEngine:
|
||||
|
||||
# Roll d20 for the targeted runner
|
||||
d20 = dice_system.roll_d20(
|
||||
league_id=state.league_id,
|
||||
game_id=game_id,
|
||||
team_id=state.get_fielding_team_id(),
|
||||
player_id=None,
|
||||
)
|
||||
pending.speed_check_d20 = d20
|
||||
pending.speed_check_d20 = d20.roll if hasattr(d20, 'roll') else d20
|
||||
pending.speed_check_runner = target
|
||||
|
||||
state.decision_phase = "awaiting_uncapped_safe_out"
|
||||
@ -1592,7 +1603,7 @@ class GameEngine:
|
||||
phase="awaiting_uncapped_safe_out",
|
||||
timeout_seconds=self.DECISION_TIMEOUT,
|
||||
data={
|
||||
"d20_roll": d20,
|
||||
"d20_roll": d20.roll if hasattr(d20, 'roll') else d20,
|
||||
"runner": target,
|
||||
"runner_base": runner_base,
|
||||
"target_base": target_base,
|
||||
@ -1609,11 +1620,12 @@ class GameEngine:
|
||||
|
||||
Finalizes the uncapped hit play with the accumulated decisions.
|
||||
|
||||
Caller must hold the game lock (acquired by WebSocket handler).
|
||||
|
||||
Args:
|
||||
game_id: Game ID
|
||||
result: "safe" or "out"
|
||||
"""
|
||||
async with state_manager.game_lock(game_id):
|
||||
state = state_manager.get_state(game_id)
|
||||
if not state:
|
||||
raise ValueError(f"Game {game_id} not found")
|
||||
@ -1860,25 +1872,27 @@ class GameEngine:
|
||||
)
|
||||
outs_recorded += 1
|
||||
|
||||
# If trail runner is R1 and R1 attempted advance, batter-runner
|
||||
# auto-advances regardless of R1's outcome
|
||||
# Determine batter's final base position
|
||||
batter_base = pending.batter_base
|
||||
if (
|
||||
pending.trail_runner_base == 1
|
||||
and pending.trail_advance
|
||||
and pending.trail_runner_base is not None
|
||||
):
|
||||
# Batter auto-advances one extra base
|
||||
batter_base = min(pending.batter_base + 1, 3)
|
||||
elif (
|
||||
pending.trail_runner_base == 0
|
||||
and checked_runner == "trail"
|
||||
):
|
||||
# Trail IS the batter - result already handled above
|
||||
if pending.trail_runner_base == 0:
|
||||
# Trail IS the batter-runner
|
||||
if checked_runner == "trail":
|
||||
# Defense threw at batter-runner
|
||||
if is_safe and pending.trail_target_base:
|
||||
batter_base = pending.trail_target_base
|
||||
elif not is_safe:
|
||||
batter_base = None # batter is out (handled by outs_recorded)
|
||||
elif pending.trail_advance and pending.throw_target is not None:
|
||||
# Batter attempted advance, defense threw at lead instead
|
||||
# Batter auto-advances to target (non-targeted runner is safe)
|
||||
batter_base = pending.trail_target_base
|
||||
elif (
|
||||
pending.trail_runner_base == 1
|
||||
and pending.trail_advance
|
||||
):
|
||||
# Trail is R1 (not batter) and R1 attempted advance
|
||||
# Batter auto-advances one extra base
|
||||
batter_base = min(pending.batter_base + 1, 3)
|
||||
|
||||
outcome = (
|
||||
PlayOutcome.SINGLE_UNCAPPED
|
||||
@ -1922,8 +1936,9 @@ class GameEngine:
|
||||
|
||||
Clears pending state, calls _finalize_play for DB write and state update.
|
||||
"""
|
||||
# Clear pending uncapped hit
|
||||
# Clear pending uncapped hit and the manual roll (one-time use)
|
||||
state.pending_uncapped_hit = None
|
||||
state.pending_manual_roll = None
|
||||
state.pending_decision = None
|
||||
state.decision_phase = "idle"
|
||||
|
||||
@ -2417,11 +2432,42 @@ class GameEngine:
|
||||
# Note: We don't delete dice rolls from the rolls table - they're kept for auditing
|
||||
# and don't affect game state reconstruction
|
||||
|
||||
# 5. Clear in-memory roll tracking for this game
|
||||
# 5. Recalculate scores from remaining plays and update games table.
|
||||
# recover_game() reads scores from the games table, which are stale after
|
||||
# play deletion. We must update them before recovery.
|
||||
remaining_plays = await self.db_ops.get_plays(game_id)
|
||||
home_score = 0
|
||||
away_score = 0
|
||||
for play in remaining_plays:
|
||||
if play.half == "top":
|
||||
away_score += play.runs_scored
|
||||
else:
|
||||
home_score += play.runs_scored
|
||||
|
||||
if remaining_plays:
|
||||
last_play = remaining_plays[-1]
|
||||
current_inning = last_play.inning
|
||||
current_half = last_play.half
|
||||
else:
|
||||
current_inning = 1
|
||||
current_half = "top"
|
||||
|
||||
logger.info(
|
||||
f"Recalculated scores after rollback: home={home_score}, away={away_score}"
|
||||
)
|
||||
await self.db_ops.update_game_state(
|
||||
game_id=game_id,
|
||||
inning=current_inning,
|
||||
half=current_half,
|
||||
home_score=home_score,
|
||||
away_score=away_score,
|
||||
)
|
||||
|
||||
# 6. Clear in-memory roll tracking for this game
|
||||
if game_id in self._rolls_this_inning:
|
||||
del self._rolls_this_inning[game_id]
|
||||
|
||||
# 6. Recover game state by replaying remaining plays
|
||||
# 7. Recover game state by replaying remaining plays
|
||||
logger.info(f"Recovering game state for {game_id}")
|
||||
new_state = await state_manager.recover_game(game_id)
|
||||
|
||||
|
||||
@ -560,7 +560,18 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
# Using the old state reference would overwrite those updates!
|
||||
state = state_manager.get_state(game_id)
|
||||
if state:
|
||||
# Clear pending roll only AFTER successful validation (one-time use)
|
||||
# Clear pending roll only if NOT entering an interactive workflow.
|
||||
# Uncapped hit and x-check workflows need pending_manual_roll
|
||||
# to build their final PlayResult when decisions complete.
|
||||
interactive_decision_phases = {
|
||||
"awaiting_x_check_result",
|
||||
"awaiting_uncapped_lead_advance",
|
||||
"awaiting_uncapped_defensive_throw",
|
||||
"awaiting_uncapped_trail_advance",
|
||||
"awaiting_uncapped_throw_target",
|
||||
"awaiting_uncapped_safe_out",
|
||||
}
|
||||
if state.decision_phase not in interactive_decision_phases:
|
||||
state.pending_manual_roll = None
|
||||
state_manager.update_state(game_id, state)
|
||||
except GameValidationError as e:
|
||||
@ -604,6 +615,30 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
},
|
||||
)
|
||||
|
||||
# Check if the outcome initiated an interactive workflow (x-check or uncapped hit).
|
||||
# If so, skip play_resolved broadcast - the play isn't actually resolved yet.
|
||||
# The decision_required event and game_state_update will drive the UI instead.
|
||||
interactive_phases = {
|
||||
"awaiting_x_check_result",
|
||||
"awaiting_uncapped_lead_advance",
|
||||
"awaiting_uncapped_defensive_throw",
|
||||
"awaiting_uncapped_trail_advance",
|
||||
"awaiting_uncapped_throw_target",
|
||||
"awaiting_uncapped_safe_out",
|
||||
}
|
||||
updated_state = state_manager.get_state(game_id)
|
||||
if updated_state and updated_state.decision_phase in interactive_phases:
|
||||
logger.info(
|
||||
f"Manual outcome initiated interactive workflow ({updated_state.decision_phase}) "
|
||||
f"for game {game_id} - skipping play_resolved, broadcasting state update"
|
||||
)
|
||||
await manager.broadcast_to_game(
|
||||
str(game_id),
|
||||
"game_state_update",
|
||||
updated_state.model_dump(mode="json"),
|
||||
)
|
||||
return
|
||||
|
||||
# Build play result data
|
||||
play_result_data = {
|
||||
"game_id": str(game_id),
|
||||
@ -2119,6 +2154,7 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
await manager.emit_to_user(sid, "error", {"message": "Missing or invalid 'advance' (bool)"})
|
||||
return
|
||||
|
||||
async with state_manager.game_lock(game_id):
|
||||
await game_engine.submit_uncapped_lead_advance(game_id, advance)
|
||||
|
||||
# Broadcast updated state
|
||||
@ -2131,6 +2167,9 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
except ValueError as e:
|
||||
logger.warning(f"Uncapped lead advance validation failed: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": str(e)})
|
||||
except asyncio.TimeoutError:
|
||||
logger.error(f"Lock timeout in submit_uncapped_lead_advance for game {game_id}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Server busy - please try again"})
|
||||
except DatabaseError as e:
|
||||
logger.error(f"Database error in submit_uncapped_lead_advance: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Database error - please retry"})
|
||||
@ -2177,6 +2216,7 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
await manager.emit_to_user(sid, "error", {"message": "Missing or invalid 'will_throw' (bool)"})
|
||||
return
|
||||
|
||||
async with state_manager.game_lock(game_id):
|
||||
await game_engine.submit_uncapped_defensive_throw(game_id, will_throw)
|
||||
|
||||
state = state_manager.get_state(game_id)
|
||||
@ -2188,6 +2228,9 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
except ValueError as e:
|
||||
logger.warning(f"Uncapped defensive throw validation failed: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": str(e)})
|
||||
except asyncio.TimeoutError:
|
||||
logger.error(f"Lock timeout in submit_uncapped_defensive_throw for game {game_id}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Server busy - please try again"})
|
||||
except DatabaseError as e:
|
||||
logger.error(f"Database error in submit_uncapped_defensive_throw: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Database error - please retry"})
|
||||
@ -2234,6 +2277,7 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
await manager.emit_to_user(sid, "error", {"message": "Missing or invalid 'advance' (bool)"})
|
||||
return
|
||||
|
||||
async with state_manager.game_lock(game_id):
|
||||
await game_engine.submit_uncapped_trail_advance(game_id, advance)
|
||||
|
||||
state = state_manager.get_state(game_id)
|
||||
@ -2245,6 +2289,9 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
except ValueError as e:
|
||||
logger.warning(f"Uncapped trail advance validation failed: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": str(e)})
|
||||
except asyncio.TimeoutError:
|
||||
logger.error(f"Lock timeout in submit_uncapped_trail_advance for game {game_id}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Server busy - please try again"})
|
||||
except DatabaseError as e:
|
||||
logger.error(f"Database error in submit_uncapped_trail_advance: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Database error - please retry"})
|
||||
@ -2292,6 +2339,7 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
)
|
||||
return
|
||||
|
||||
async with state_manager.game_lock(game_id):
|
||||
await game_engine.submit_uncapped_throw_target(game_id, target)
|
||||
|
||||
state = state_manager.get_state(game_id)
|
||||
@ -2303,6 +2351,9 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
except ValueError as e:
|
||||
logger.warning(f"Uncapped throw target validation failed: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": str(e)})
|
||||
except asyncio.TimeoutError:
|
||||
logger.error(f"Lock timeout in submit_uncapped_throw_target for game {game_id}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Server busy - please try again"})
|
||||
except DatabaseError as e:
|
||||
logger.error(f"Database error in submit_uncapped_throw_target: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Database error - please retry"})
|
||||
@ -2350,6 +2401,7 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
)
|
||||
return
|
||||
|
||||
async with state_manager.game_lock(game_id):
|
||||
await game_engine.submit_uncapped_safe_out(game_id, result)
|
||||
|
||||
state = state_manager.get_state(game_id)
|
||||
@ -2361,6 +2413,9 @@ def register_handlers(sio: AsyncServer, manager: ConnectionManager) -> None:
|
||||
except ValueError as e:
|
||||
logger.warning(f"Uncapped safe/out validation failed: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": str(e)})
|
||||
except asyncio.TimeoutError:
|
||||
logger.error(f"Lock timeout in submit_uncapped_safe_out for game {game_id}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Server busy - please try again"})
|
||||
except DatabaseError as e:
|
||||
logger.error(f"Database error in submit_uncapped_safe_out: {e}")
|
||||
await manager.emit_to_user(sid, "error", {"message": "Database error - please retry"})
|
||||
|
||||
@ -113,9 +113,15 @@
|
||||
:outs="gameState?.outs ?? 0"
|
||||
:has-runners="!!(gameState?.on_first || gameState?.on_second || gameState?.on_third)"
|
||||
:dice-color="diceColor"
|
||||
:user-team-id="myTeamId"
|
||||
@roll-dice="handleRollDice"
|
||||
@submit-outcome="handleSubmitOutcome"
|
||||
@dismiss-result="handleDismissResult"
|
||||
@submit-uncapped-lead-advance="handleUncappedLeadAdvance"
|
||||
@submit-uncapped-defensive-throw="handleUncappedDefensiveThrow"
|
||||
@submit-uncapped-trail-advance="handleUncappedTrailAdvance"
|
||||
@submit-uncapped-throw-target="handleUncappedThrowTarget"
|
||||
@submit-uncapped-safe-out="handleUncappedSafeOut"
|
||||
/>
|
||||
|
||||
<!-- Play-by-Play Feed (below gameplay on mobile) -->
|
||||
@ -183,9 +189,15 @@
|
||||
:outs="gameState?.outs ?? 0"
|
||||
:has-runners="!!(gameState?.on_first || gameState?.on_second || gameState?.on_third)"
|
||||
:dice-color="diceColor"
|
||||
:user-team-id="myTeamId"
|
||||
@roll-dice="handleRollDice"
|
||||
@submit-outcome="handleSubmitOutcome"
|
||||
@dismiss-result="handleDismissResult"
|
||||
@submit-uncapped-lead-advance="handleUncappedLeadAdvance"
|
||||
@submit-uncapped-defensive-throw="handleUncappedDefensiveThrow"
|
||||
@submit-uncapped-trail-advance="handleUncappedTrailAdvance"
|
||||
@submit-uncapped-throw-target="handleUncappedThrowTarget"
|
||||
@submit-uncapped-safe-out="handleUncappedSafeOut"
|
||||
/>
|
||||
</div>
|
||||
|
||||
@ -447,18 +459,27 @@ const connectionStatus = ref<'connecting' | 'connected' | 'disconnected'>('conne
|
||||
|
||||
// Determine which team the user controls
|
||||
// For demo/testing: user controls whichever team needs to act
|
||||
const DEFENSIVE_PHASES = [
|
||||
'awaiting_defensive',
|
||||
'awaiting_uncapped_defensive_throw',
|
||||
'awaiting_uncapped_throw_target',
|
||||
]
|
||||
|
||||
const myTeamId = computed(() => {
|
||||
if (!gameState.value) return null
|
||||
|
||||
const phase = gameState.value.decision_phase
|
||||
const isDefensivePhase = DEFENSIVE_PHASES.includes(phase)
|
||||
|
||||
// Return the team that currently needs to make a decision
|
||||
if (gameState.value.half === 'top') {
|
||||
// Top: away bats, home fields
|
||||
return gameState.value.decision_phase === 'awaiting_defensive'
|
||||
return isDefensivePhase
|
||||
? gameState.value.home_team_id
|
||||
: gameState.value.away_team_id
|
||||
} else {
|
||||
// Bottom: home bats, away fields
|
||||
return gameState.value.decision_phase === 'awaiting_defensive'
|
||||
return isDefensivePhase
|
||||
? gameState.value.away_team_id
|
||||
: gameState.value.home_team_id
|
||||
}
|
||||
@ -576,6 +597,11 @@ const showGameplay = computed(() => {
|
||||
return true
|
||||
}
|
||||
|
||||
// Show for uncapped hit decisions (both teams see the wizard)
|
||||
if (gameStore.needsUncappedDecision) {
|
||||
return true
|
||||
}
|
||||
|
||||
return gameState.value?.status === 'active' &&
|
||||
isMyTurn.value &&
|
||||
!needsDefensiveDecision.value &&
|
||||
@ -656,6 +682,32 @@ const handleStealAttemptsSubmit = (attempts: number[]) => {
|
||||
gameStore.setPendingStealAttempts(attempts)
|
||||
}
|
||||
|
||||
// Methods - Uncapped Hit Decision Tree
|
||||
const handleUncappedLeadAdvance = (advance: boolean) => {
|
||||
console.log('[GamePlay] Uncapped lead advance:', advance)
|
||||
actions.submitUncappedLeadAdvance(advance)
|
||||
}
|
||||
|
||||
const handleUncappedDefensiveThrow = (willThrow: boolean) => {
|
||||
console.log('[GamePlay] Uncapped defensive throw:', willThrow)
|
||||
actions.submitUncappedDefensiveThrow(willThrow)
|
||||
}
|
||||
|
||||
const handleUncappedTrailAdvance = (advance: boolean) => {
|
||||
console.log('[GamePlay] Uncapped trail advance:', advance)
|
||||
actions.submitUncappedTrailAdvance(advance)
|
||||
}
|
||||
|
||||
const handleUncappedThrowTarget = (target: 'lead' | 'trail') => {
|
||||
console.log('[GamePlay] Uncapped throw target:', target)
|
||||
actions.submitUncappedThrowTarget(target)
|
||||
}
|
||||
|
||||
const handleUncappedSafeOut = (result: 'safe' | 'out') => {
|
||||
console.log('[GamePlay] Uncapped safe/out:', result)
|
||||
actions.submitUncappedSafeOut(result)
|
||||
}
|
||||
|
||||
const handleToggleHold = (base: number) => {
|
||||
defensiveSetup.toggleHold(base)
|
||||
}
|
||||
|
||||
@ -78,6 +78,21 @@
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- State: Uncapped Hit Pending -->
|
||||
<div v-else-if="workflowState === 'uncapped_hit_pending'" class="state-uncapped-hit">
|
||||
<UncappedHitWizard
|
||||
:phase="currentUncappedPhase!"
|
||||
:data="uncappedHitData"
|
||||
:readonly="!isUncappedInteractive"
|
||||
:pending-uncapped-hit="pendingUncappedHit"
|
||||
@submit-lead-advance="handleUncappedLeadAdvance"
|
||||
@submit-defensive-throw="handleUncappedDefensiveThrow"
|
||||
@submit-trail-advance="handleUncappedTrailAdvance"
|
||||
@submit-throw-target="handleUncappedThrowTarget"
|
||||
@submit-safe-out="handleUncappedSafeOut"
|
||||
/>
|
||||
</div>
|
||||
|
||||
<!-- State: X-Check Result Pending -->
|
||||
<div v-else-if="workflowState === 'x_check_result_pending'" class="state-x-check">
|
||||
<div v-if="!isXCheckInteractive" class="state-message">
|
||||
@ -119,12 +134,13 @@
|
||||
|
||||
<script setup lang="ts">
|
||||
import { ref, computed } from 'vue'
|
||||
import type { RollData, PlayResult, PlayOutcome, XCheckData } from '~/types'
|
||||
import type { RollData, PlayResult, PlayOutcome, XCheckData, DecisionPhase, UncappedHitData } from '~/types'
|
||||
import { useGameStore } from '~/store/game'
|
||||
import DiceRoller from './DiceRoller.vue'
|
||||
import OutcomeWizard from './OutcomeWizard.vue'
|
||||
import PlayResultDisplay from './PlayResult.vue'
|
||||
import XCheckWizard from './XCheckWizard.vue'
|
||||
import UncappedHitWizard from './UncappedHitWizard.vue'
|
||||
|
||||
interface Props {
|
||||
gameId: string
|
||||
@ -153,6 +169,11 @@ const emit = defineEmits<{
|
||||
submitOutcome: [{ outcome: PlayOutcome; hitLocation?: string }]
|
||||
dismissResult: []
|
||||
submitXCheckResult: [{ resultCode: string; errorResult: string }]
|
||||
submitUncappedLeadAdvance: [advance: boolean]
|
||||
submitUncappedDefensiveThrow: [willThrow: boolean]
|
||||
submitUncappedTrailAdvance: [advance: boolean]
|
||||
submitUncappedThrowTarget: [target: 'lead' | 'trail']
|
||||
submitUncappedSafeOut: [result: 'safe' | 'out']
|
||||
}>()
|
||||
|
||||
// Store access
|
||||
@ -165,6 +186,41 @@ const isSubmitting = ref(false)
|
||||
// X-Check data from store
|
||||
const xCheckData = computed(() => gameStore.xCheckData)
|
||||
|
||||
// Uncapped hit data from store
|
||||
const uncappedHitData = computed(() => gameStore.uncappedHitData)
|
||||
const pendingUncappedHit = computed(() => {
|
||||
const hit = gameStore.gameState?.pending_uncapped_hit
|
||||
return (hit ?? null) as import('~/types').PendingUncappedHit | null
|
||||
})
|
||||
|
||||
// Current uncapped hit phase
|
||||
const currentUncappedPhase = computed<DecisionPhase | null>(() => {
|
||||
if (gameStore.needsUncappedLeadAdvance) return 'awaiting_uncapped_lead_advance'
|
||||
if (gameStore.needsUncappedDefensiveThrow) return 'awaiting_uncapped_defensive_throw'
|
||||
if (gameStore.needsUncappedTrailAdvance) return 'awaiting_uncapped_trail_advance'
|
||||
if (gameStore.needsUncappedThrowTarget) return 'awaiting_uncapped_throw_target'
|
||||
if (gameStore.needsUncappedSafeOut) return 'awaiting_uncapped_safe_out'
|
||||
return null
|
||||
})
|
||||
|
||||
// Offensive phases: user's team must be the batting team
|
||||
// Defensive phases: user's team must be the fielding team
|
||||
const UNCAPPED_OFFENSIVE_PHASES: DecisionPhase[] = [
|
||||
'awaiting_uncapped_lead_advance',
|
||||
'awaiting_uncapped_trail_advance',
|
||||
'awaiting_uncapped_safe_out',
|
||||
]
|
||||
|
||||
const isUncappedInteractive = computed(() => {
|
||||
if (!currentUncappedPhase.value || !props.userTeamId || !gameStore.gameState) return false
|
||||
const isOffensivePhase = UNCAPPED_OFFENSIVE_PHASES.includes(currentUncappedPhase.value)
|
||||
if (isOffensivePhase) {
|
||||
return props.userTeamId === gameStore.battingTeamId
|
||||
} else {
|
||||
return props.userTeamId === gameStore.fieldingTeamId
|
||||
}
|
||||
})
|
||||
|
||||
// Determine if current user should have interactive mode
|
||||
// Uses active_team_id from x-check data (set by backend to indicate which team should interact)
|
||||
const isXCheckInteractive = computed(() => {
|
||||
@ -174,7 +230,7 @@ const isXCheckInteractive = computed(() => {
|
||||
})
|
||||
|
||||
// Workflow state computation
|
||||
type WorkflowState = 'idle' | 'ready_to_roll' | 'rolled' | 'submitted' | 'result' | 'x_check_result_pending'
|
||||
type WorkflowState = 'idle' | 'ready_to_roll' | 'rolled' | 'submitted' | 'result' | 'uncapped_hit_pending' | 'x_check_result_pending'
|
||||
|
||||
const workflowState = computed<WorkflowState>(() => {
|
||||
// Show result if we have one
|
||||
@ -182,6 +238,11 @@ const workflowState = computed<WorkflowState>(() => {
|
||||
return 'result'
|
||||
}
|
||||
|
||||
// Show uncapped hit wizard if in any uncapped phase
|
||||
if (gameStore.needsUncappedDecision) {
|
||||
return 'uncapped_hit_pending'
|
||||
}
|
||||
|
||||
// Show x-check result selection if awaiting
|
||||
if (gameStore.needsXCheckResult && xCheckData.value) {
|
||||
return 'x_check_result_pending'
|
||||
@ -210,6 +271,7 @@ const workflowState = computed<WorkflowState>(() => {
|
||||
const statusClass = computed(() => {
|
||||
if (error.value) return 'status-error'
|
||||
if (workflowState.value === 'result') return 'status-success'
|
||||
if (workflowState.value === 'uncapped_hit_pending') return 'status-active'
|
||||
if (workflowState.value === 'x_check_result_pending') return 'status-active'
|
||||
if (workflowState.value === 'submitted') return 'status-processing'
|
||||
if (workflowState.value === 'rolled') return 'status-active'
|
||||
@ -220,6 +282,9 @@ const statusClass = computed(() => {
|
||||
const statusText = computed(() => {
|
||||
if (error.value) return 'Error'
|
||||
if (workflowState.value === 'result') return 'Play Complete'
|
||||
if (workflowState.value === 'uncapped_hit_pending') {
|
||||
return isUncappedInteractive.value ? 'Uncapped Hit Decision' : 'Waiting for Decision'
|
||||
}
|
||||
if (workflowState.value === 'x_check_result_pending') {
|
||||
return isXCheckInteractive.value ? 'Select X-Check Result' : 'Waiting for Defense'
|
||||
}
|
||||
@ -258,6 +323,26 @@ const handleDismissResult = () => {
|
||||
emit('dismissResult')
|
||||
}
|
||||
|
||||
const handleUncappedLeadAdvance = (advance: boolean) => {
|
||||
emit('submitUncappedLeadAdvance', advance)
|
||||
}
|
||||
|
||||
const handleUncappedDefensiveThrow = (willThrow: boolean) => {
|
||||
emit('submitUncappedDefensiveThrow', willThrow)
|
||||
}
|
||||
|
||||
const handleUncappedTrailAdvance = (advance: boolean) => {
|
||||
emit('submitUncappedTrailAdvance', advance)
|
||||
}
|
||||
|
||||
const handleUncappedThrowTarget = (target: 'lead' | 'trail') => {
|
||||
emit('submitUncappedThrowTarget', target)
|
||||
}
|
||||
|
||||
const handleUncappedSafeOut = (result: 'safe' | 'out') => {
|
||||
emit('submitUncappedSafeOut', result)
|
||||
}
|
||||
|
||||
const handleXCheckSubmit = (payload: { resultCode: string; errorResult: string }) => {
|
||||
error.value = null
|
||||
isSubmitting.value = true
|
||||
@ -358,6 +443,11 @@ const handleXCheckSubmit = (payload: { resultCode: string; errorResult: string }
|
||||
@apply space-y-6;
|
||||
}
|
||||
|
||||
/* State: Uncapped Hit */
|
||||
.state-uncapped-hit {
|
||||
@apply space-y-4;
|
||||
}
|
||||
|
||||
/* State: X-Check */
|
||||
.state-x-check {
|
||||
@apply space-y-4;
|
||||
|
||||
536
frontend-sba/components/Gameplay/UncappedHitWizard.vue
Normal file
536
frontend-sba/components/Gameplay/UncappedHitWizard.vue
Normal file
@ -0,0 +1,536 @@
|
||||
<template>
|
||||
<div class="uncapped-wizard" :class="{ 'read-only': readonly }">
|
||||
<!-- Header -->
|
||||
<div class="wizard-header">
|
||||
<div class="hit-badge" :class="hitBadgeClass">
|
||||
{{ hitTypeLabel }}
|
||||
</div>
|
||||
<div v-if="hitLocation" class="hit-location">
|
||||
to {{ hitLocation }}
|
||||
</div>
|
||||
<p v-if="readonly" class="waiting-message">
|
||||
Waiting for {{ isDefensivePhase ? 'defense' : 'offense' }} to decide...
|
||||
</p>
|
||||
</div>
|
||||
|
||||
<!-- Auto-scoring runners info -->
|
||||
<div v-if="autoRunnersDisplay.length > 0" class="auto-runners">
|
||||
<div v-for="(info, idx) in autoRunnersDisplay" :key="idx" class="auto-runner-line">
|
||||
<svg class="w-4 h-4 text-green-600" fill="currentColor" viewBox="0 0 20 20">
|
||||
<path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"/>
|
||||
</svg>
|
||||
<span>{{ info }}</span>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Phase 1: Lead Runner Advance (OFFENSE) -->
|
||||
<div v-if="phase === 'awaiting_uncapped_lead_advance'" class="phase-content">
|
||||
<div class="phase-label offense-label">Offense Decides</div>
|
||||
<div class="runner-info">
|
||||
<span class="runner-name">{{ leadRunnerName }}</span>
|
||||
<span class="runner-movement">{{ baseLabel(leadData?.lead_runner_base) }} → {{ baseLabel(leadData?.lead_target_base) }}</span>
|
||||
</div>
|
||||
<div class="decision-buttons">
|
||||
<button
|
||||
class="decision-btn advance-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitLeadAdvance', true)"
|
||||
>
|
||||
Advance
|
||||
</button>
|
||||
<button
|
||||
class="decision-btn hold-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitLeadAdvance', false)"
|
||||
>
|
||||
Hold
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Phase 2: Defensive Throw (DEFENSE) -->
|
||||
<div v-else-if="phase === 'awaiting_uncapped_defensive_throw'" class="phase-content">
|
||||
<div class="phase-label defense-label">Defense Decides</div>
|
||||
<div class="runner-info">
|
||||
<span class="runner-name">{{ leadRunnerNameFromThrow }}</span>
|
||||
<span class="runner-movement">attempting {{ baseLabel(throwData?.lead_target_base) }}</span>
|
||||
</div>
|
||||
<div class="decision-buttons">
|
||||
<button
|
||||
class="decision-btn throw-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitDefensiveThrow', true)"
|
||||
>
|
||||
Throw
|
||||
</button>
|
||||
<button
|
||||
class="decision-btn letgo-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitDefensiveThrow', false)"
|
||||
>
|
||||
Let it Go
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Phase 3: Trail Runner Advance (OFFENSE) -->
|
||||
<div v-else-if="phase === 'awaiting_uncapped_trail_advance'" class="phase-content">
|
||||
<div class="phase-label offense-label">Offense Decides</div>
|
||||
<div class="runner-info">
|
||||
<span class="runner-name">{{ trailRunnerName }}</span>
|
||||
<span class="runner-movement">{{ baseLabel(trailData?.trail_runner_base) }} → {{ baseLabel(trailData?.trail_target_base) }}</span>
|
||||
</div>
|
||||
<div class="decision-buttons">
|
||||
<button
|
||||
class="decision-btn advance-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitTrailAdvance', true)"
|
||||
>
|
||||
Advance
|
||||
</button>
|
||||
<button
|
||||
class="decision-btn hold-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitTrailAdvance', false)"
|
||||
>
|
||||
Hold
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Phase 4: Throw Target (DEFENSE) -->
|
||||
<div v-else-if="phase === 'awaiting_uncapped_throw_target'" class="phase-content">
|
||||
<div class="phase-label defense-label">Defense Decides</div>
|
||||
<p class="phase-description">Both runners are advancing. Choose your throw target:</p>
|
||||
<div class="target-options">
|
||||
<button
|
||||
class="target-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitThrowTarget', 'lead')"
|
||||
>
|
||||
<div class="target-label">Lead Runner</div>
|
||||
<div class="target-detail">
|
||||
{{ leadRunnerNameFromTarget }} → {{ baseLabel(targetData?.lead_target_base) }}
|
||||
</div>
|
||||
</button>
|
||||
<button
|
||||
class="target-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitThrowTarget', 'trail')"
|
||||
>
|
||||
<div class="target-label">Trail Runner</div>
|
||||
<div class="target-detail">
|
||||
{{ trailRunnerNameFromTarget }} → {{ baseLabel(targetData?.trail_target_base) }}
|
||||
</div>
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<!-- Phase 5: Safe/Out Result (OFFENSE) -->
|
||||
<div v-else-if="phase === 'awaiting_uncapped_safe_out'" class="phase-content">
|
||||
<div class="phase-label offense-label">Offense Decides</div>
|
||||
<div class="d20-display">
|
||||
<div class="d20-label">Speed Check d20</div>
|
||||
<div class="d20-value">{{ safeOutData?.d20_roll }}</div>
|
||||
</div>
|
||||
<div class="runner-info">
|
||||
<span class="runner-name">{{ safeOutRunnerName }}</span>
|
||||
<span class="runner-movement">
|
||||
{{ safeOutData?.runner === 'lead' ? 'Lead' : 'Trail' }} runner → {{ baseLabel(safeOutData?.target_base) }}
|
||||
</span>
|
||||
</div>
|
||||
<p class="phase-description">Check runner's speed rating on card vs d20 roll.</p>
|
||||
<div class="decision-buttons">
|
||||
<button
|
||||
class="decision-btn safe-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitSafeOut', 'safe')"
|
||||
>
|
||||
SAFE
|
||||
</button>
|
||||
<button
|
||||
class="decision-btn out-btn"
|
||||
:disabled="readonly"
|
||||
@click="$emit('submitSafeOut', 'out')"
|
||||
>
|
||||
OUT
|
||||
</button>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
</template>
|
||||
|
||||
<script setup lang="ts">
|
||||
import { computed } from 'vue'
|
||||
import type {
|
||||
DecisionPhase,
|
||||
UncappedLeadAdvanceData,
|
||||
UncappedDefensiveThrowData,
|
||||
UncappedTrailAdvanceData,
|
||||
UncappedThrowTargetData,
|
||||
UncappedSafeOutData,
|
||||
UncappedHitData,
|
||||
PendingUncappedHit,
|
||||
} from '~/types'
|
||||
import { useGameStore } from '~/store/game'
|
||||
|
||||
interface Props {
|
||||
phase: DecisionPhase
|
||||
data: UncappedHitData | null
|
||||
readonly: boolean
|
||||
pendingUncappedHit: PendingUncappedHit | null
|
||||
}
|
||||
|
||||
const props = defineProps<Props>()
|
||||
|
||||
defineEmits<{
|
||||
submitLeadAdvance: [advance: boolean]
|
||||
submitDefensiveThrow: [willThrow: boolean]
|
||||
submitTrailAdvance: [advance: boolean]
|
||||
submitThrowTarget: [target: 'lead' | 'trail']
|
||||
submitSafeOut: [result: 'safe' | 'out']
|
||||
}>()
|
||||
|
||||
const gameStore = useGameStore()
|
||||
|
||||
// Defensive phases (defense decides)
|
||||
const DEFENSIVE_PHASES: DecisionPhase[] = [
|
||||
'awaiting_uncapped_defensive_throw',
|
||||
'awaiting_uncapped_throw_target',
|
||||
]
|
||||
|
||||
const isDefensivePhase = computed(() => DEFENSIVE_PHASES.includes(props.phase))
|
||||
|
||||
// Typed data accessors per phase
|
||||
const leadData = computed(() => {
|
||||
if (props.phase === 'awaiting_uncapped_lead_advance') {
|
||||
return props.data as UncappedLeadAdvanceData | null
|
||||
}
|
||||
return null
|
||||
})
|
||||
|
||||
const throwData = computed(() => {
|
||||
if (props.phase === 'awaiting_uncapped_defensive_throw') {
|
||||
return props.data as UncappedDefensiveThrowData | null
|
||||
}
|
||||
return null
|
||||
})
|
||||
|
||||
const trailData = computed(() => {
|
||||
if (props.phase === 'awaiting_uncapped_trail_advance') {
|
||||
return props.data as UncappedTrailAdvanceData | null
|
||||
}
|
||||
return null
|
||||
})
|
||||
|
||||
const targetData = computed(() => {
|
||||
if (props.phase === 'awaiting_uncapped_throw_target') {
|
||||
return props.data as UncappedThrowTargetData | null
|
||||
}
|
||||
return null
|
||||
})
|
||||
|
||||
const safeOutData = computed(() => {
|
||||
if (props.phase === 'awaiting_uncapped_safe_out') {
|
||||
return props.data as UncappedSafeOutData | null
|
||||
}
|
||||
return null
|
||||
})
|
||||
|
||||
// Hit type from phase data or pending state
|
||||
const hitType = computed(() => {
|
||||
if (leadData.value) return leadData.value.hit_type
|
||||
return props.pendingUncappedHit?.hit_type ?? ''
|
||||
})
|
||||
|
||||
const hitLocation = computed(() => {
|
||||
const loc = leadData.value?.hit_location
|
||||
?? throwData.value?.hit_location
|
||||
?? trailData.value?.hit_location
|
||||
?? targetData.value?.hit_location
|
||||
?? safeOutData.value?.hit_location
|
||||
?? props.pendingUncappedHit?.hit_location
|
||||
return loc ?? ''
|
||||
})
|
||||
|
||||
const hitTypeLabel = computed(() => {
|
||||
const ht = hitType.value
|
||||
if (ht === 'single' || ht === 'single_uncapped') return 'SINGLE UNCAPPED'
|
||||
if (ht === 'double' || ht === 'double_uncapped') return 'DOUBLE UNCAPPED'
|
||||
return 'UNCAPPED HIT'
|
||||
})
|
||||
|
||||
const hitBadgeClass = computed(() => {
|
||||
const ht = hitType.value
|
||||
if (ht === 'single' || ht === 'single_uncapped') return 'badge-single'
|
||||
return 'badge-double'
|
||||
})
|
||||
|
||||
// Auto-scoring runners display (from phase 1 data or pending state)
|
||||
const autoRunnersDisplay = computed(() => {
|
||||
const autos = leadData.value?.auto_runners ?? props.pendingUncappedHit?.auto_runners ?? []
|
||||
return autos.map((runner) => {
|
||||
const from = runner[0]
|
||||
const to = runner[1]
|
||||
const lid = runner[2]
|
||||
const player = lid != null ? gameStore.findPlayerInLineup(lid) : undefined
|
||||
const name = player?.player?.name ?? `#${lid ?? '?'}`
|
||||
if (to === 4) return `${name} scores automatically`
|
||||
return `${name}: ${baseLabel(from)} → ${baseLabel(to)} automatically`
|
||||
})
|
||||
})
|
||||
|
||||
// Player name lookups
|
||||
const leadRunnerName = computed(() => {
|
||||
const lid = leadData.value?.lead_runner_lineup_id
|
||||
if (!lid) return 'Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
const leadRunnerNameFromThrow = computed(() => {
|
||||
const lid = throwData.value?.lead_runner_lineup_id
|
||||
if (!lid) return 'Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
const trailRunnerName = computed(() => {
|
||||
const lid = trailData.value?.trail_runner_lineup_id
|
||||
if (!lid) return 'Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
const leadRunnerNameFromTarget = computed(() => {
|
||||
const lid = targetData.value?.lead_runner_lineup_id
|
||||
if (!lid) return 'Lead Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
const trailRunnerNameFromTarget = computed(() => {
|
||||
const lid = targetData.value?.trail_runner_lineup_id
|
||||
if (!lid) return 'Trail Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
const safeOutRunnerName = computed(() => {
|
||||
const lid = safeOutData.value?.runner_lineup_id
|
||||
if (!lid) return 'Runner'
|
||||
const player = gameStore.findPlayerInLineup(lid)
|
||||
return player?.player?.name ?? `#${lid}`
|
||||
})
|
||||
|
||||
// Base label helper
|
||||
function baseLabel(base: number | undefined | null): string {
|
||||
if (base === undefined || base === null) return '?'
|
||||
if (base === 0) return 'Home'
|
||||
if (base === 4) return 'Home'
|
||||
return `${base}B`
|
||||
}
|
||||
</script>
|
||||
|
||||
<style scoped>
|
||||
.uncapped-wizard {
|
||||
@apply bg-white rounded-lg shadow-lg p-6 space-y-5 max-w-4xl mx-auto;
|
||||
}
|
||||
|
||||
.uncapped-wizard.read-only {
|
||||
@apply opacity-75;
|
||||
}
|
||||
|
||||
/* Header */
|
||||
.wizard-header {
|
||||
@apply text-center pb-4 border-b border-gray-200 space-y-2;
|
||||
}
|
||||
|
||||
.hit-badge {
|
||||
@apply inline-block px-4 py-1 rounded-full text-sm font-bold uppercase tracking-wide;
|
||||
}
|
||||
|
||||
.badge-single {
|
||||
@apply bg-green-100 text-green-800;
|
||||
}
|
||||
|
||||
.badge-double {
|
||||
@apply bg-blue-100 text-blue-800;
|
||||
}
|
||||
|
||||
.hit-location {
|
||||
@apply text-sm text-gray-600 font-medium;
|
||||
}
|
||||
|
||||
.waiting-message {
|
||||
@apply mt-2 text-sm text-orange-600 font-medium;
|
||||
}
|
||||
|
||||
/* Auto runners */
|
||||
.auto-runners {
|
||||
@apply bg-green-50 border border-green-200 rounded-lg p-3 space-y-1;
|
||||
}
|
||||
|
||||
.auto-runner-line {
|
||||
@apply flex items-center gap-2 text-sm text-green-800;
|
||||
}
|
||||
|
||||
/* Phase content */
|
||||
.phase-content {
|
||||
@apply space-y-4;
|
||||
}
|
||||
|
||||
.phase-label {
|
||||
@apply text-xs font-bold uppercase tracking-wider text-center py-1 rounded;
|
||||
}
|
||||
|
||||
.offense-label {
|
||||
@apply bg-blue-100 text-blue-800;
|
||||
}
|
||||
|
||||
.defense-label {
|
||||
@apply bg-red-100 text-red-800;
|
||||
}
|
||||
|
||||
.phase-description {
|
||||
@apply text-sm text-gray-600 text-center;
|
||||
}
|
||||
|
||||
/* Runner info */
|
||||
.runner-info {
|
||||
@apply flex flex-col items-center gap-1;
|
||||
}
|
||||
|
||||
.runner-name {
|
||||
@apply text-lg font-bold text-gray-900;
|
||||
}
|
||||
|
||||
.runner-movement {
|
||||
@apply text-sm text-gray-600;
|
||||
}
|
||||
|
||||
/* Decision buttons */
|
||||
.decision-buttons {
|
||||
@apply grid grid-cols-2 gap-3;
|
||||
}
|
||||
|
||||
.decision-btn {
|
||||
@apply px-6 py-4 font-bold text-lg rounded-lg transition-colors disabled:opacity-50 disabled:cursor-not-allowed;
|
||||
}
|
||||
|
||||
.advance-btn {
|
||||
@apply bg-green-600 text-white hover:bg-green-700;
|
||||
}
|
||||
|
||||
.hold-btn {
|
||||
@apply bg-gray-300 text-gray-800 hover:bg-gray-400;
|
||||
}
|
||||
|
||||
.throw-btn {
|
||||
@apply bg-red-600 text-white hover:bg-red-700;
|
||||
}
|
||||
|
||||
.letgo-btn {
|
||||
@apply bg-gray-300 text-gray-800 hover:bg-gray-400;
|
||||
}
|
||||
|
||||
.safe-btn {
|
||||
@apply bg-green-600 text-white hover:bg-green-700;
|
||||
}
|
||||
|
||||
.out-btn {
|
||||
@apply bg-red-600 text-white hover:bg-red-700;
|
||||
}
|
||||
|
||||
/* Target options (phase 4) */
|
||||
.target-options {
|
||||
@apply grid grid-cols-1 sm:grid-cols-2 gap-3;
|
||||
}
|
||||
|
||||
.target-btn {
|
||||
@apply flex flex-col items-center p-5 border-2 border-gray-300 rounded-lg hover:border-red-500 hover:bg-red-50 transition-all cursor-pointer disabled:cursor-not-allowed disabled:opacity-50;
|
||||
}
|
||||
|
||||
.target-label {
|
||||
@apply text-lg font-bold text-gray-900 mb-1;
|
||||
}
|
||||
|
||||
.target-detail {
|
||||
@apply text-sm text-gray-600;
|
||||
}
|
||||
|
||||
/* D20 display (phase 5) */
|
||||
.d20-display {
|
||||
@apply text-center;
|
||||
}
|
||||
|
||||
.d20-label {
|
||||
@apply text-sm font-medium text-gray-600 mb-2;
|
||||
}
|
||||
|
||||
.d20-value {
|
||||
@apply text-4xl font-bold rounded-lg px-6 py-3 shadow-md bg-blue-100 text-blue-900 inline-block;
|
||||
}
|
||||
|
||||
/* Mobile responsive */
|
||||
@media (max-width: 640px) {
|
||||
.uncapped-wizard {
|
||||
@apply p-4 space-y-4;
|
||||
}
|
||||
|
||||
.decision-buttons {
|
||||
@apply grid-cols-1;
|
||||
}
|
||||
|
||||
.decision-btn {
|
||||
@apply w-full;
|
||||
}
|
||||
}
|
||||
|
||||
/* Dark mode */
|
||||
@media (prefers-color-scheme: dark) {
|
||||
.uncapped-wizard {
|
||||
@apply bg-gray-800;
|
||||
}
|
||||
|
||||
.wizard-header {
|
||||
@apply border-gray-600;
|
||||
}
|
||||
|
||||
.hit-location {
|
||||
@apply text-gray-400;
|
||||
}
|
||||
|
||||
.auto-runners {
|
||||
@apply bg-green-900/30 border-green-700;
|
||||
}
|
||||
|
||||
.auto-runner-line {
|
||||
@apply text-green-300;
|
||||
}
|
||||
|
||||
.runner-name {
|
||||
@apply text-gray-100;
|
||||
}
|
||||
|
||||
.runner-movement {
|
||||
@apply text-gray-400;
|
||||
}
|
||||
|
||||
.phase-description {
|
||||
@apply text-gray-400;
|
||||
}
|
||||
|
||||
.target-btn {
|
||||
@apply border-gray-600 hover:border-red-400 hover:bg-red-900/30;
|
||||
}
|
||||
|
||||
.target-label {
|
||||
@apply text-gray-100;
|
||||
}
|
||||
|
||||
.target-detail {
|
||||
@apply text-gray-400;
|
||||
}
|
||||
}
|
||||
</style>
|
||||
@ -243,6 +243,90 @@ export function useGameActions(gameId?: string) {
|
||||
uiStore.showInfo('Submitting speed check result...', 2000)
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Uncapped Hit Decision Tree
|
||||
// ============================================================================
|
||||
|
||||
/**
|
||||
* Submit lead runner advance decision (offensive player)
|
||||
*/
|
||||
function submitUncappedLeadAdvance(advance: boolean) {
|
||||
if (!validateConnection()) return
|
||||
|
||||
console.log('[GameActions] Submitting uncapped lead advance:', advance)
|
||||
|
||||
socket.value!.emit('submit_uncapped_lead_advance', {
|
||||
game_id: currentGameId.value!,
|
||||
advance,
|
||||
})
|
||||
|
||||
uiStore.showInfo('Submitting lead runner decision...', 2000)
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit defensive throw decision (defensive player)
|
||||
*/
|
||||
function submitUncappedDefensiveThrow(willThrow: boolean) {
|
||||
if (!validateConnection()) return
|
||||
|
||||
console.log('[GameActions] Submitting uncapped defensive throw:', willThrow)
|
||||
|
||||
socket.value!.emit('submit_uncapped_defensive_throw', {
|
||||
game_id: currentGameId.value!,
|
||||
will_throw: willThrow,
|
||||
})
|
||||
|
||||
uiStore.showInfo('Submitting throw decision...', 2000)
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit trail runner advance decision (offensive player)
|
||||
*/
|
||||
function submitUncappedTrailAdvance(advance: boolean) {
|
||||
if (!validateConnection()) return
|
||||
|
||||
console.log('[GameActions] Submitting uncapped trail advance:', advance)
|
||||
|
||||
socket.value!.emit('submit_uncapped_trail_advance', {
|
||||
game_id: currentGameId.value!,
|
||||
advance,
|
||||
})
|
||||
|
||||
uiStore.showInfo('Submitting trail runner decision...', 2000)
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit throw target selection (defensive player)
|
||||
*/
|
||||
function submitUncappedThrowTarget(target: 'lead' | 'trail') {
|
||||
if (!validateConnection()) return
|
||||
|
||||
console.log('[GameActions] Submitting uncapped throw target:', target)
|
||||
|
||||
socket.value!.emit('submit_uncapped_throw_target', {
|
||||
game_id: currentGameId.value!,
|
||||
target,
|
||||
})
|
||||
|
||||
uiStore.showInfo('Submitting throw target...', 2000)
|
||||
}
|
||||
|
||||
/**
|
||||
* Submit safe/out result (offensive player)
|
||||
*/
|
||||
function submitUncappedSafeOut(result: 'safe' | 'out') {
|
||||
if (!validateConnection()) return
|
||||
|
||||
console.log('[GameActions] Submitting uncapped safe/out:', result)
|
||||
|
||||
socket.value!.emit('submit_uncapped_safe_out', {
|
||||
game_id: currentGameId.value!,
|
||||
result,
|
||||
})
|
||||
|
||||
uiStore.showInfo('Submitting speed check result...', 2000)
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Substitution Actions
|
||||
// ============================================================================
|
||||
@ -449,6 +533,13 @@ export function useGameActions(gameId?: string) {
|
||||
submitDecideThrow,
|
||||
submitDecideResult,
|
||||
|
||||
// Uncapped hit decision tree
|
||||
submitUncappedLeadAdvance,
|
||||
submitUncappedDefensiveThrow,
|
||||
submitUncappedTrailAdvance,
|
||||
submitUncappedThrowTarget,
|
||||
submitUncappedSafeOut,
|
||||
|
||||
// Substitutions
|
||||
submitSubstitution,
|
||||
|
||||
|
||||
@ -470,6 +470,16 @@ export function useWebSocket() {
|
||||
console.log('[WebSocket] Full gameState:', JSON.stringify(gameState, null, 2).slice(0, 500))
|
||||
gameStore.setGameState(gameState)
|
||||
console.log('[WebSocket] After setGameState, store current_batter:', gameStore.currentBatter)
|
||||
|
||||
// Clear interactive workflow data when the workflow has completed
|
||||
if (!gameState.pending_uncapped_hit && gameStore.uncappedHitData) {
|
||||
gameStore.clearUncappedHitData()
|
||||
gameStore.clearDecisionPrompt()
|
||||
}
|
||||
if (!gameState.pending_x_check && gameStore.xCheckData) {
|
||||
gameStore.clearXCheckData()
|
||||
gameStore.clearDecisionPrompt()
|
||||
}
|
||||
})
|
||||
|
||||
state.socketInstance.on('game_state_sync', (data) => {
|
||||
@ -497,22 +507,39 @@ export function useWebSocket() {
|
||||
// ========================================
|
||||
|
||||
state.socketInstance.on('decision_required', (prompt) => {
|
||||
console.log('[WebSocket] Decision required:', prompt.phase, 'type:', prompt.type)
|
||||
console.log('[WebSocket] Decision required:', prompt.phase)
|
||||
gameStore.setDecisionPrompt(prompt)
|
||||
|
||||
// Handle x-check specific decision types
|
||||
if (prompt.type === 'x_check_result' && prompt.data) {
|
||||
// Route phase-specific data to appropriate store slots
|
||||
if (prompt.data) {
|
||||
switch (prompt.phase) {
|
||||
// X-Check phases
|
||||
case 'awaiting_x_check_result':
|
||||
console.log('[WebSocket] X-Check result decision, position:', prompt.data.position)
|
||||
gameStore.setXCheckData(prompt.data)
|
||||
} else if (prompt.type === 'decide_advance' && prompt.data) {
|
||||
gameStore.setXCheckData(prompt.data as any)
|
||||
break
|
||||
case 'awaiting_decide_advance':
|
||||
console.log('[WebSocket] DECIDE advance decision')
|
||||
gameStore.setDecideData(prompt.data)
|
||||
} else if (prompt.type === 'decide_throw' && prompt.data) {
|
||||
gameStore.setDecideData(prompt.data as any)
|
||||
break
|
||||
case 'awaiting_decide_throw':
|
||||
console.log('[WebSocket] DECIDE throw decision')
|
||||
gameStore.setDecideData(prompt.data)
|
||||
} else if (prompt.type === 'decide_speed_check' && prompt.data) {
|
||||
gameStore.setDecideData(prompt.data as any)
|
||||
break
|
||||
case 'awaiting_decide_result':
|
||||
console.log('[WebSocket] DECIDE speed check decision')
|
||||
gameStore.setDecideData(prompt.data)
|
||||
gameStore.setDecideData(prompt.data as any)
|
||||
break
|
||||
// Uncapped hit phases
|
||||
case 'awaiting_uncapped_lead_advance':
|
||||
case 'awaiting_uncapped_defensive_throw':
|
||||
case 'awaiting_uncapped_trail_advance':
|
||||
case 'awaiting_uncapped_throw_target':
|
||||
case 'awaiting_uncapped_safe_out':
|
||||
console.log('[WebSocket] Uncapped hit decision:', prompt.phase)
|
||||
gameStore.setUncappedHitData(prompt.data as any)
|
||||
break
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
@ -604,6 +631,7 @@ export function useWebSocket() {
|
||||
gameStore.clearPendingDecisions()
|
||||
gameStore.clearXCheckData()
|
||||
gameStore.clearDecideData()
|
||||
gameStore.clearUncappedHitData()
|
||||
|
||||
uiStore.showSuccess(data.description, 5000)
|
||||
})
|
||||
|
||||
@ -20,6 +20,7 @@ import type {
|
||||
DecideAdvanceData,
|
||||
DecideThrowData,
|
||||
DecideSpeedCheckData,
|
||||
UncappedHitData,
|
||||
} from '~/types'
|
||||
|
||||
export const useGameStore = defineStore('game', () => {
|
||||
@ -44,6 +45,9 @@ export const useGameStore = defineStore('game', () => {
|
||||
const xCheckData = ref<XCheckData | null>(null)
|
||||
const decideData = ref<DecideAdvanceData | DecideThrowData | DecideSpeedCheckData | null>(null)
|
||||
|
||||
// Uncapped hit workflow state
|
||||
const uncappedHitData = ref<UncappedHitData | null>(null)
|
||||
|
||||
// Decision state (local pending decisions before submission)
|
||||
const pendingDefensiveSetup = ref<DefensiveDecision | null>(null)
|
||||
const pendingOffensiveDecision = ref<Omit<OffensiveDecision, 'steal_attempts'> | null>(null)
|
||||
@ -156,6 +160,39 @@ export const useGameStore = defineStore('game', () => {
|
||||
gameState.value?.decision_phase === 'awaiting_decide_result'
|
||||
})
|
||||
|
||||
const needsUncappedLeadAdvance = computed(() => {
|
||||
return currentDecisionPrompt.value?.phase === 'awaiting_uncapped_lead_advance' ||
|
||||
gameState.value?.decision_phase === 'awaiting_uncapped_lead_advance'
|
||||
})
|
||||
|
||||
const needsUncappedDefensiveThrow = computed(() => {
|
||||
return currentDecisionPrompt.value?.phase === 'awaiting_uncapped_defensive_throw' ||
|
||||
gameState.value?.decision_phase === 'awaiting_uncapped_defensive_throw'
|
||||
})
|
||||
|
||||
const needsUncappedTrailAdvance = computed(() => {
|
||||
return currentDecisionPrompt.value?.phase === 'awaiting_uncapped_trail_advance' ||
|
||||
gameState.value?.decision_phase === 'awaiting_uncapped_trail_advance'
|
||||
})
|
||||
|
||||
const needsUncappedThrowTarget = computed(() => {
|
||||
return currentDecisionPrompt.value?.phase === 'awaiting_uncapped_throw_target' ||
|
||||
gameState.value?.decision_phase === 'awaiting_uncapped_throw_target'
|
||||
})
|
||||
|
||||
const needsUncappedSafeOut = computed(() => {
|
||||
return currentDecisionPrompt.value?.phase === 'awaiting_uncapped_safe_out' ||
|
||||
gameState.value?.decision_phase === 'awaiting_uncapped_safe_out'
|
||||
})
|
||||
|
||||
const needsUncappedDecision = computed(() => {
|
||||
return needsUncappedLeadAdvance.value ||
|
||||
needsUncappedDefensiveThrow.value ||
|
||||
needsUncappedTrailAdvance.value ||
|
||||
needsUncappedThrowTarget.value ||
|
||||
needsUncappedSafeOut.value
|
||||
})
|
||||
|
||||
const canRollDice = computed(() => {
|
||||
return gameState.value?.decision_phase === 'resolution' && !pendingRoll.value
|
||||
})
|
||||
@ -388,6 +425,20 @@ export const useGameStore = defineStore('game', () => {
|
||||
decideData.value = null
|
||||
}
|
||||
|
||||
/**
|
||||
* Set uncapped hit data (from decision_required event)
|
||||
*/
|
||||
function setUncappedHitData(data: UncappedHitData | null) {
|
||||
uncappedHitData.value = data
|
||||
}
|
||||
|
||||
/**
|
||||
* Clear uncapped hit data after resolution
|
||||
*/
|
||||
function clearUncappedHitData() {
|
||||
uncappedHitData.value = null
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset game store (when leaving game)
|
||||
*/
|
||||
@ -409,6 +460,7 @@ export const useGameStore = defineStore('game', () => {
|
||||
decisionHistory.value = []
|
||||
xCheckData.value = null
|
||||
decideData.value = null
|
||||
uncappedHitData.value = null
|
||||
}
|
||||
|
||||
/**
|
||||
@ -464,6 +516,7 @@ export const useGameStore = defineStore('game', () => {
|
||||
decisionHistory: readonly(decisionHistory),
|
||||
xCheckData: readonly(xCheckData),
|
||||
decideData: readonly(decideData),
|
||||
uncappedHitData: readonly(uncappedHitData),
|
||||
|
||||
// Getters
|
||||
gameId,
|
||||
@ -496,6 +549,12 @@ export const useGameStore = defineStore('game', () => {
|
||||
needsDecideAdvance,
|
||||
needsDecideThrow,
|
||||
needsDecideResult,
|
||||
needsUncappedLeadAdvance,
|
||||
needsUncappedDefensiveThrow,
|
||||
needsUncappedTrailAdvance,
|
||||
needsUncappedThrowTarget,
|
||||
needsUncappedSafeOut,
|
||||
needsUncappedDecision,
|
||||
canRollDice,
|
||||
canSubmitOutcome,
|
||||
recentPlays,
|
||||
@ -526,6 +585,8 @@ export const useGameStore = defineStore('game', () => {
|
||||
clearXCheckData,
|
||||
setDecideData,
|
||||
clearDecideData,
|
||||
setUncappedHitData,
|
||||
clearUncappedHitData,
|
||||
resetGame,
|
||||
getActiveLineup,
|
||||
getBenchPlayers,
|
||||
|
||||
@ -49,6 +49,12 @@ export type DecisionPhase =
|
||||
| 'awaiting_decide_advance'
|
||||
| 'awaiting_decide_throw'
|
||||
| 'awaiting_decide_result'
|
||||
// Uncapped hit decision tree phases
|
||||
| 'awaiting_uncapped_lead_advance'
|
||||
| 'awaiting_uncapped_defensive_throw'
|
||||
| 'awaiting_uncapped_trail_advance'
|
||||
| 'awaiting_uncapped_throw_target'
|
||||
| 'awaiting_uncapped_safe_out'
|
||||
|
||||
/**
|
||||
* Lineup player state - represents a player in the game
|
||||
@ -138,6 +144,9 @@ export interface GameState {
|
||||
// Interactive x-check workflow
|
||||
pending_x_check: PendingXCheck | null
|
||||
|
||||
// Uncapped hit decision tree
|
||||
pending_uncapped_hit: PendingUncappedHit | null
|
||||
|
||||
// Play history
|
||||
play_count: number
|
||||
last_play_result: string | null
|
||||
@ -314,6 +323,7 @@ export interface DecisionPrompt {
|
||||
timeout_seconds: number
|
||||
options?: string[]
|
||||
message?: string
|
||||
data?: Record<string, unknown>
|
||||
}
|
||||
|
||||
/**
|
||||
@ -440,3 +450,98 @@ export interface PendingXCheck {
|
||||
decide_throw: string | null
|
||||
decide_d20: number | null
|
||||
}
|
||||
|
||||
/**
|
||||
* Pending Uncapped Hit State (on GameState)
|
||||
* Persisted for reconnection recovery.
|
||||
* Backend: PendingUncappedHit (game_models.py)
|
||||
*/
|
||||
export interface PendingUncappedHit {
|
||||
hit_type: string
|
||||
hit_location: string
|
||||
lead_runner_base: number
|
||||
lead_runner_lineup_id: number
|
||||
lead_target_base: number
|
||||
auto_runners: number[][]
|
||||
lead_advance: boolean | null
|
||||
will_throw: boolean | null
|
||||
trail_runner_base: number | null
|
||||
trail_runner_lineup_id: number | null
|
||||
trail_target_base: number | null
|
||||
trail_advance: boolean | null
|
||||
throw_target: string | null
|
||||
d20_roll: number | null
|
||||
safe_out_result: string | null
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 1: Lead runner advance decision data
|
||||
* Sent with awaiting_uncapped_lead_advance
|
||||
*/
|
||||
export interface UncappedLeadAdvanceData {
|
||||
hit_type: string
|
||||
hit_location: string
|
||||
lead_runner_base: number
|
||||
lead_runner_lineup_id: number
|
||||
lead_target_base: number
|
||||
auto_runners: number[][]
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 2: Defensive throw decision data
|
||||
* Sent with awaiting_uncapped_defensive_throw
|
||||
*/
|
||||
export interface UncappedDefensiveThrowData {
|
||||
lead_runner_base: number
|
||||
lead_target_base: number
|
||||
lead_runner_lineup_id: number
|
||||
hit_location: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 3: Trail runner advance decision data
|
||||
* Sent with awaiting_uncapped_trail_advance
|
||||
*/
|
||||
export interface UncappedTrailAdvanceData {
|
||||
trail_runner_base: number
|
||||
trail_target_base: number
|
||||
trail_runner_lineup_id: number
|
||||
hit_location: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 4: Throw target selection data
|
||||
* Sent with awaiting_uncapped_throw_target
|
||||
*/
|
||||
export interface UncappedThrowTargetData {
|
||||
lead_runner_base: number
|
||||
lead_target_base: number
|
||||
lead_runner_lineup_id: number
|
||||
trail_runner_base: number
|
||||
trail_target_base: number
|
||||
trail_runner_lineup_id: number
|
||||
hit_location: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Phase 5: Safe/out resolution data
|
||||
* Sent with awaiting_uncapped_safe_out
|
||||
*/
|
||||
export interface UncappedSafeOutData {
|
||||
d20_roll: number
|
||||
runner: string
|
||||
runner_base: number
|
||||
target_base: number
|
||||
runner_lineup_id: number
|
||||
hit_location: string
|
||||
}
|
||||
|
||||
/**
|
||||
* Union of all uncapped hit phase data types
|
||||
*/
|
||||
export type UncappedHitData =
|
||||
| UncappedLeadAdvanceData
|
||||
| UncappedDefensiveThrowData
|
||||
| UncappedTrailAdvanceData
|
||||
| UncappedThrowTargetData
|
||||
| UncappedSafeOutData
|
||||
|
||||
@ -36,6 +36,14 @@ export type {
|
||||
DecideThrowData,
|
||||
DecideSpeedCheckData,
|
||||
PendingXCheck,
|
||||
// Uncapped hit workflow types
|
||||
PendingUncappedHit,
|
||||
UncappedLeadAdvanceData,
|
||||
UncappedDefensiveThrowData,
|
||||
UncappedTrailAdvanceData,
|
||||
UncappedThrowTargetData,
|
||||
UncappedSafeOutData,
|
||||
UncappedHitData,
|
||||
} from './game'
|
||||
|
||||
// Player types
|
||||
@ -76,6 +84,12 @@ export type {
|
||||
SubmitDecideAdvanceRequest,
|
||||
SubmitDecideThrowRequest,
|
||||
SubmitDecideResultRequest,
|
||||
// Uncapped hit workflow request types
|
||||
SubmitUncappedLeadAdvanceRequest,
|
||||
SubmitUncappedDefensiveThrowRequest,
|
||||
SubmitUncappedTrailAdvanceRequest,
|
||||
SubmitUncappedThrowTargetRequest,
|
||||
SubmitUncappedSafeOutRequest,
|
||||
// Event types
|
||||
ConnectedEvent,
|
||||
GameJoinedEvent,
|
||||
|
||||
@ -58,6 +58,13 @@ export interface ClientToServerEvents {
|
||||
submit_decide_throw: (data: SubmitDecideThrowRequest) => void
|
||||
submit_decide_result: (data: SubmitDecideResultRequest) => void
|
||||
|
||||
// Uncapped hit decision tree
|
||||
submit_uncapped_lead_advance: (data: SubmitUncappedLeadAdvanceRequest) => void
|
||||
submit_uncapped_defensive_throw: (data: SubmitUncappedDefensiveThrowRequest) => void
|
||||
submit_uncapped_trail_advance: (data: SubmitUncappedTrailAdvanceRequest) => void
|
||||
submit_uncapped_throw_target: (data: SubmitUncappedThrowTargetRequest) => void
|
||||
submit_uncapped_safe_out: (data: SubmitUncappedSafeOutRequest) => void
|
||||
|
||||
// Substitutions
|
||||
request_pinch_hitter: (data: PinchHitterRequest) => void
|
||||
request_defensive_replacement: (data: DefensiveReplacementRequest) => void
|
||||
@ -394,3 +401,28 @@ export interface SubmitDecideResultRequest {
|
||||
game_id: string
|
||||
outcome: 'safe' | 'out'
|
||||
}
|
||||
|
||||
export interface SubmitUncappedLeadAdvanceRequest {
|
||||
game_id: string
|
||||
advance: boolean
|
||||
}
|
||||
|
||||
export interface SubmitUncappedDefensiveThrowRequest {
|
||||
game_id: string
|
||||
will_throw: boolean
|
||||
}
|
||||
|
||||
export interface SubmitUncappedTrailAdvanceRequest {
|
||||
game_id: string
|
||||
advance: boolean
|
||||
}
|
||||
|
||||
export interface SubmitUncappedThrowTargetRequest {
|
||||
game_id: string
|
||||
target: 'lead' | 'trail'
|
||||
}
|
||||
|
||||
export interface SubmitUncappedSafeOutRequest {
|
||||
game_id: string
|
||||
result: 'safe' | 'out'
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user