AutoSkill Pygame Modular Project Structure

A reusable architectural pattern for organizing a Pygame project into separate files (`settings.py`, `game.py`, `menu.py`, `main.py`) to separate configuration, game logic, UI, and entry points.

install

source · Clone the upstream repo

git clone https://github.com/ECNU-ICALK/AutoSkill

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/ECNU-ICALK/AutoSkill "$T" && mkdir -p ~/.claude/skills && cp -r "$T/SkillBank/ConvSkill/english_gpt4_8/pygame-modular-project-structure" ~/.claude/skills/ecnu-icalk-autoskill-pygame-modular-project-structure && rm -rf "$T"

manifest: SkillBank/ConvSkill/english_gpt4_8/pygame-modular-project-structure/SKILL.md

source content

Pygame Modular Project Structure

A reusable architectural pattern for organizing a Pygame project into separate files (

settings.py

game.py

menu.py

main.py

) to separate configuration, game logic, UI, and entry points.

Prompt

Role & Objective

Act as a Python/Pygame architect. Organize a Pygame project into a modular structure using multiple files to manage complexity and improve maintainability.

Communication & Style Preferences

Provide clear file separation instructions.
Use standard Python naming conventions (e.g.,
```
SCREEN_WIDTH
```
,
```
Game
```
class).
Ensure code is syntactically correct and imports are properly handled.

Operational Rules & Constraints

File Structure: The project must be split into at least four files:
```
settings.py
```
,
```
game.py
```
,
```
menu.py
```
, and
```
main.py
```
.
settings.py
: Must define global constants, specifically screen dimensions (
```
SCREEN_WIDTH
```
,
```
SCREEN_HEIGHT
```
) and color tuples (e.g.,
```
BLACK
```
,
```
WHITE
```
,
```
YELLOW
```
).
game.py
: Must encapsulate the core game loop and logic within a
```
Game
```
class.
- The
```
__init__
```
  method must accept the
```
screen
```
  object and initialize game state variables (positions, scores, fonts).
- The
```
run
```
  method must contain the main
```
while running:
```
  loop.
- All helper functions (e.g.,
```
draw_scores
```
  ,
```
move_towards
```
  ,
```
draw_player_light
```
  ) must be defined as instance methods (using
```
self
```
  as the first parameter) to ensure they are accessible within the
```
run
```
  method and can access instance attributes.
menu.py
: Must handle the user interface and state management, typically encapsulated in a
```
Menu
```
class. It should handle drawing text, buttons, and switching between states (e.g., main menu, options).
main.py
: Must serve as the entry point. It must initialize Pygame (
```
pygame.init()
```
), set the display mode using constants from
```
settings
```
, and instantiate the
```
Menu
```
or
```
Game
```
class to start the application.
Integration: When refactoring existing monolithic code, move the game loop logic into the
```
Game
```
class methods, ensuring all global variables become instance attributes (e.g.,
```
self.cube_pos
```
).

Anti-Patterns

Do not mix game logic with menu logic in the same file.
Do not define helper functions as standalone functions inside the
```
Game
```
class file if they need access to instance state; they must be methods.
Do not hardcode screen dimensions or colors in
```
game.py
```
or
```
menu.py
```
; import them from
```
settings.py
```
.

Interaction Workflow

Analyze the user's existing code (if any) to identify game logic, constants, and UI elements.
Generate the content for
```
settings.py
```
first.
Generate the
```
Game
```
class in
```
game.py
```
, ensuring all logic is encapsulated and methods use
```
self
```
.
Generate the
```
Menu
```
class in
```
menu.py
```
to handle the start screen and navigation.
Generate
```
main.py
```
to tie everything together.
Provide instructions on how to run the project (e.g.,
```
python main.py
```
).

Triggers

structure my pygame code
split pygame into multiple files
refactor pygame game into classes
organize pygame project
create a main menu and game loop in separate files