itdominator
409680b94a
* Move common ball recording, scoring, and turn-switching logic into `BaseMode` * Add hooks for mode-specific ball handling and turn behavior * Simplify 8-ball and 9-ball modes to use `LastBallMode` * Update Snooker to use the new ball-processing hooks * Remove duplicated scoring and turn-management code
138 lines
3.5 KiB
GDScript
138 lines
3.5 KiB
GDScript
class_name BaseMode extends Node
|
|
# NOTE: The ball's queue_free is called higher up and after game mode handles
|
|
# the ball. Never call it in a given game mode. A game mode should handle
|
|
# these signals to handle game related rules regarding ball sinks.
|
|
|
|
|
|
var turn_count: int = 1
|
|
var player_1_points: int = 0
|
|
var player_2_points: int = 0
|
|
|
|
# NOTE: Kinda a super tracker of balls. Not all entries
|
|
# generated are used depending on the game type.
|
|
var ball_states: Dictionary = {}
|
|
|
|
# NOTE: Used to track handoff logic and is cleared after eah switch accordingly.
|
|
var balls_sunk: Array = []
|
|
var balls_reaped: Array = []
|
|
|
|
# NOTE: Kinda a super tracker of the state of a ball.
|
|
# Not all entries are used depending on the game type.
|
|
var BALL_STATE: Dictionary = {
|
|
"turn": 0,
|
|
"player": "",
|
|
"sunk": false,
|
|
"reaped": false,
|
|
"is_foul": false,
|
|
"points": 0,
|
|
}
|
|
|
|
|
|
func _process_reaped_balls(player: String) -> void:
|
|
for ball_name in balls_reaped:
|
|
_add_points(player, -ball_states[ball_name]["points"])
|
|
|
|
balls_reaped.clear()
|
|
|
|
func _process_sunk_balls(player: String) -> void:
|
|
for ball_name in balls_sunk:
|
|
_add_points(player, ball_states[ball_name]["points"])
|
|
|
|
balls_sunk.clear()
|
|
|
|
func _record_ball(
|
|
ball: Node3D,
|
|
state_key: String,
|
|
tracker: Array
|
|
) -> void:
|
|
tracker.append(ball.name)
|
|
|
|
ball_states[ball.name]["turn"] = turn_count
|
|
ball_states[ball.name]["player"] = get_player()
|
|
ball_states[ball.name][state_key] = true
|
|
|
|
func _add_points(player: String, amount: int) -> void:
|
|
if player == "Player 1":
|
|
player_1_points += amount
|
|
else:
|
|
player_2_points += amount
|
|
|
|
|
|
func get_player() -> String:
|
|
return (
|
|
"Player 1"
|
|
if Globals.game_data.client1 ==
|
|
Globals.multiplayer_data.current_turn_player_id
|
|
else
|
|
"Player 2"
|
|
)
|
|
|
|
# NOTE: Override when a mode doesn't awards points for sunk balls.
|
|
func score_sunk_balls() -> bool:
|
|
return true
|
|
|
|
# NOTE: Override when a mode shouldn't keep the player's turn after a legal sink.
|
|
func keep_turn_after_sink() -> bool:
|
|
return true
|
|
|
|
# NOTE: Override when a modehas extra processing such as
|
|
# checking if solid or striped ball.
|
|
func on_ball_reaped(_ball: Node3D) -> void:
|
|
pass
|
|
|
|
# NOTE: Override when a modehas extra processing such as
|
|
# checking if solid or striped ball.
|
|
func on_ball_sunk(_ball: Node3D) -> void:
|
|
pass
|
|
|
|
|
|
func reap_ball(ball: Node3D) -> void:
|
|
_record_ball(ball, "reaped", balls_reaped)
|
|
on_ball_reaped(ball)
|
|
|
|
func process_ball(ball: Node3D) -> void:
|
|
_record_ball(ball, "sunk", balls_sunk)
|
|
on_ball_sunk(ball)
|
|
|
|
func generate_ball_states() -> Dictionary:
|
|
var state: Dictionary = {}
|
|
|
|
for i: int in range(1, 16):
|
|
var ball_name = "%02d_ball" % i
|
|
state[ball_name] = BALL_STATE.duplicate_deep()
|
|
state[ball_name]["points"] = i
|
|
|
|
return state
|
|
|
|
func handle_switch_user() -> void:
|
|
push_warning("Balls reaped: ", balls_reaped.size() )
|
|
push_warning("Balls sunk: ", balls_sunk.size() )
|
|
|
|
var player: String = get_player()
|
|
var no_sunk_balls: bool = balls_sunk.is_empty()
|
|
|
|
_process_reaped_balls(player)
|
|
if score_sunk_balls():
|
|
_process_sunk_balls(player)
|
|
|
|
if ball_states_finalized():
|
|
process_win_condition()
|
|
return
|
|
|
|
if no_sunk_balls or not keep_turn_after_sink():
|
|
Globals.game_state.switch_active_player()
|
|
|
|
turn_count += 1
|
|
|
|
func ball_states_finalized() -> bool:
|
|
for ball_state in ball_states.values():
|
|
if ball_state["reaped"] or ball_state["sunk"]:
|
|
continue
|
|
|
|
return false
|
|
|
|
return true
|
|
|
|
func process_win_condition() -> void:
|
|
assert(false, "This method needs to be overridden...")
|