Development Mode Module

This module defines the DevelopmentMode class, responsible for handling the game state where a player can manage their owned properties. This includes building houses/hotels, selling buildings, mortgaging/unmortgaging properties, and selling properties back to the bank. It provides both visual feedback on the board (highlighting developable properties) and a dedicated UI panel when a specific property is selected.

High-Level Design

Use Case Diagram

Illustrates the primary actions a player can perform when development mode is active.

State Diagram

Shows the states related to the DevelopmentMode being active and whether a property UI is displayed. Note that this also influences the main Game.state.

$@startuml [*] --> Inactive : Initial State state Active { [*] --> BrowsingProperties : Mode Activated BrowsingProperties : Player can click owned properties\nDraws flashing stars BrowsingProperties --> PropertySelected : Player clicks own property PropertySelected : Displays Development UI Panel\nHandles UI button clicks/keys PropertySelected --> BrowsingProperties : Player clicks "Close" button or outside UI PropertySelected --> BrowsingProperties : Action performed (e.g., build, mortgage) PropertySelected --> Inactive : Player sells last property BrowsingProperties --> Inactive : Player ends turn / Mode deactivated externally } Active --> Inactive : Deactivate called / Player turn ends note right of Active When Active, the main Game state is typically "DEVELOPMENT". end note @enduml$

Detailed Design

Class Diagram

Details the DevelopmentMode class and its primary interactions.

$@startuml class DevelopmentMode { - game: Game - game_actions: GameActions - screen: pygame.Surface - font: pygame.font.Font - small_font: pygame.font.Font - tiny_font: pygame.font.Font - is_active: bool - buttons: dict(str, pygame.Rect) - last_star_flash_time: int - show_property_stars: bool + activate(player: dict): bool + can_develop_ai(player: dict): bool + deactivate() + draw(mouse_pos: tuple) + handle_click(pos: tuple): any + handle_key(event: pygame.Event): any - _draw_property_stars() - _draw_star(x: int, y: int) - _draw_development_ui(property_data: dict, mouse_pos: tuple) - _draw_button(button_rect: pygame.Rect, text: str, mouse_pos: tuple, active: bool, color: tuple) } note right of DevelopmentMode::handle_key Keyboard shortcuts (1-4, ESC) only apply to human players when a property UI is open. end note DevelopmentMode ..> "1" Game : uses DevelopmentMode ..> "1" GameActions : uses DevelopmentMode ..> GameLogic : uses DevelopmentMode ..> GameBoard : uses DevelopmentMode ..> pygame : uses DevelopmentMode ..> math : uses note "Implied classes/data structures used" as N3 class Game { + screen: pygame.Surface + font: pygame.font.Font + small_font: pygame.font.Font + tiny_font: pygame.font.Font + logic: GameLogic + board: GameBoard + selected_property: dict + state: str + lap_count: dict } class GameActions { + start_auction(property: dict) } class GameLogic { + properties: dict(str, dict) + players: list(dict) + current_player_index: int + can_build_house(prop: dict, player: dict): tuple(bool, str) + can_build_hotel(prop: dict, player: dict): tuple(bool, str) + build_house(prop: dict, player: dict): bool + build_hotel(prop: dict, player: dict): bool + sell_house(prop: dict, player: dict): bool + sell_hotel(prop: dict, player: dict): bool + mortgage_property(prop: dict, player: dict): bool + unmortgage_property(prop: dict, player: dict): bool + calculate_space_rent(prop: dict, player: dict): int } note "Property data stored as dict(str, dict)" as N1 GameLogic::properties .. N1 note "Player data stored as list(dict)" as N2 GameLogic::players .. N2 class GameBoard { + add_message(msg: str) + update_ownership(properties: dict) + property_clicked(pos: tuple): int + get_property_position(index: int): tuple(int, int) } @enduml$

Activity Diagram: Handling Clicks

Shows the logical flow within the handle_click method.

Sequence Diagrams

Activating Development and Selecting a Property (Human Player)

Shows how a human player enters development mode and selects a property.

actor Player
participant "dev_mode:DevelopmentMode" as DevMode
participant "game:Game" as Game
participant "logic:GameLogic" as Logic
participant "board:GameBoard" as Board

activate DevMode
note over DevMode: Assume activation check passed (lap count >= 1, owns properties)
DevMode -> Game : selected_property = None
Game --> DevMode
DevMode -> Game : board.add_message("Click a property to develop")
Game --> DevMode

Player -> DevMode : handle_click(pos)
DevMode -> Board : property_clicked(pos)
Board --> DevMode : space_index or None
opt space_index is not None
DevMode -> Logic : properties(index)
Logic --> DevMode : prop_data
alt prop_data.owner == current_player
DevMode -> Game : selected_property = prop_data
Game --> DevMode
DevMode -> Game : state = "DEVELOPMENT"
Game --> DevMode
else
DevMode -> Board : add_message("Owned by {owner}")
Board --> DevMode
end
end
DevMode --> Player : return False
deactivate DevMode — Sequence Diagram: Activate and Select Property

Performing an Action (e.g., Build House via UI)

Illustrates the process when a player clicks a button in the development UI.

Checking if AI Can Develop

Shows the sequence for the can_develop_ai check.

participant "Caller" as Caller
participant "DevMode" as DevMode
participant "Game" as Game
participant "Logic" as Logic

Caller -> DevMode : can_develop_ai(player_dict)
activate DevMode

DevMode -> Game : get lap_count(player_name)
Game --> DevMode : lap_count

alt lap_count < 1
DevMode --> Caller : return False
else has completed lap
DevMode -> Logic : get properties
Logic --> DevMode : all_properties

DevMode -> DevMode : Filter owned_properties

alt no owned properties
DevMode --> Caller : return False
else has properties
loop for each property
DevMode -> Logic : can_build_house(prop, player)
Logic --> DevMode : can_build_house result

DevMode -> Logic : can_build_hotel(prop, player)
Logic --> DevMode : can_build_hotel result

DevMode -> DevMode : Check other conditions

alt can perform any action
DevMode --> Caller : return True
break
end
end

DevMode --> Caller : return False
end
end

deactivate DevMode — Sequence Diagram: can_develop_ai Check

Mortgage/Unmortgage Action (UI Click)

Illustrates handling the mortgage button click in the UI.

actor Player
participant "DevMode" as DevMode
participant "Game" as Game
participant "Logic" as Logic
participant "Board" as Board

Player -> DevMode : handle_click(pos)
activate DevMode

DevMode -> DevMode : Check button collision

alt mortgage button clicked
DevMode -> Game : get is_mortgaged
Game --> DevMode : mortgage status

alt property is mortgaged
DevMode -> Logic : unmortgage_property(prop, player)
Logic --> DevMode : result

alt successful
DevMode -> Board : add_message("Unmortgaged")
end
else not mortgaged
DevMode -> Logic : mortgage_property(prop, player)
Logic --> DevMode : result

alt successful
DevMode -> Board : add_message("Mortgaged")
end
end

alt action successful
DevMode -> Board : update_ownership()
end
end

DevMode --> Player : return False
deactivate DevMode — Sequence Diagram: Mortgage/Unmortgage Action

Key Classes Overview

DevelopmentMode: Orchestrates the development phase. It activates/deactivates the mode, handles player input (clicks on board/UI, keyboard shortcuts for humans), draws visual cues (stars on properties) and the detailed property management UI panel. It relies heavily on GameLogic to validate actions and update game state, and on GameBoard for visual updates and user messages. It interacts with the main Game object to access shared resources and state like the selected property.