In this technical blog, I'll walk you through creating "Echoes of Code," a 2D top-down puzzle game where you solve puzzles by collaborating with echoes of your past actions. I'll focus on the key components and concepts to keep this a quick 5-minute read.
Setting Up the Development Environment
Installing WSL on Windows
- Enable WSL: Open PowerShell as Administrator and run:([DEV Community][1])
wsl --install - Restart your computer and complete the Linux distribution setup.
Setting Up Python and PyGame
# Install Python and dependencies sudo apt install python3 python3-pip python3-dev -y sudo apt install python3-pygame -y # Install PyGame pip3 install pygame Installing Amazon Q CLI
# Install AWS CLI first curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip" unzip awscliv2.zip sudo ./aws/install # Configure AWS aws configure # Install Amazon Q CLI curl -Lo "/tmp/q-cli.deb" "https://d3l58w4xvhud7h.cloudfront.net/linux/amd64/latest/q-cli.deb" sudo dpkg -i /tmp/q-cli.deb # Login q login Game Design and Concept
"Echoes of Code" features a software engineer trapped in a glitched digital world. Every 10 seconds, time resets, and your past actions are replayed by ghost clones called "echoes." You must use these echoes strategically to solve puzzles.
Implementation Highlights
Time Loop System
The core of the game is the TimerManager class that handles the time loop mechanics:
class TimerManager: def __init__(self, loop_duration: float, max_loops: int): self.loop_duration = loop_duration self.max_loops = max_loops self.start_time = time.time() self.current_loop = 1 def get_loop_time(self) -> float: """Get time elapsed in the current loop""" return self.get_elapsed_time() % self.loop_duration def should_reset_loop(self) -> bool: return self.get_loop_time() >= self.loop_duration def reset_loop(self): self.current_loop += 1 Action Recording and Replay
The Player class records actions, while the Echo class replays them:
# In Player class def record_action(self, action_type: str, time_stamp: float): self.actions.append(Action(action_type, (self.x, self.y), time_stamp, self.current_direction)) # In Echo class def update(self, current_time: float, game_objects: List): if self.current_action_index < len(self.actions): next_action = self.actions[self.current_action_index] if current_time >= next_action.time_stamp: if next_action.action_type == "move": self.x, self.y = next_action.position self.current_direction = next_action.direction elif next_action.action_type == "interact": self.interact_with_objects(game_objects) self.current_action_index += 1 Interactive Game Objects
The game includes various interactive elements:
# Example of the PressurePlate class class PressurePlate: def update(self, players: List[Player]): self.is_active = False plate_rect = pygame.Rect(self.x, self.y, self.width, self.height) for player in players: player_rect = pygame.Rect(player.x, player.y, player.width, player.height) if plate_rect.colliderect(player_rect): self.is_active = True break Loop Reset Logic
When a loop resets, we create a new echo and reset the player:
def reset_loop(self): # Create a new echo from the current player echo_colors = [PURPLE, YELLOW, CYAN, RED, GREEN] echo_color = echo_colors[min(len(self.echoes), len(echo_colors) - 1)] self.echoes.append(Echo(self.player, echo_color, self.timer_manager.current_loop)) # Reset player position current_level = self.level_manager.get_current_level() self.player.x, self.player.y = current_level.player_start # Clear player actions for the new loop self.player.actions = [] # Increment loop counter self.timer_manager.reset_loop() Level Design
Levels are created using the Level class, which manages all game objects:
def create_levels(self): # Level 1: Simple pressure plate and gate level1 = Level(1, (100, 300), 3) # Player starts at (100, 300), 3 loops max # Add walls (border) level1.add_wall(0, 0, SCREEN_WIDTH, 20) # Top level1.add_wall(0, SCREEN_HEIGHT - 20, SCREEN_WIDTH, 20) # Bottom # Add pressure plate level1.add_pressure_plate(300, 200, 1) # Controls gate with ID 1 # Add gate level1.add_gate(400, 400, 20, 100, 1) # Gate with ID 1 # Add exit level1.set_exit(700, 300) Main Game Loop
The Game class ties everything together:
def run(self): running = True while running: running = self.handle_events() self.update() self.draw() self.clock.tick(FPS) Development Challenges
Echo Replay Timing: Ensuring echoes replayed actions at the exact same time they were recorded.
Collision Detection: Making sure players and echoes interacted correctly with game objects.
Loop Reset Logic: Managing the state transition when a loop resets, especially ensuring all objects reset properly.
Future Enhancements
The game can be expanded with:
Additional Levels: More complex puzzles requiring multiple echoes to solve.
Mini Terminal: Implementing a system where players can write simple logic commands.
Enemies: Adding entities that track and interact with echoes.
Visual Timeline: Creating a replay system to show all actions at the end of each level.
Running the Game
To run the game:
cd ~/echoes_of_code python3 echoes_of_code.py Conclusion
Building "Echoes of Code" demonstrates how a unique game mechanic like time loops can create engaging puzzle gameplay. The modular code structure makes it easy to expand with new levels and features. By leveraging WSL for development and Amazon Q CLI for assistance, I was able to streamline the development process and focus on implementing the core game mechanics.
If you're interested in time-based puzzle games or want to explore PyGame development, I encourage you to try out "Echoes of Code" and even extend it with your own ideas!
Top comments (0)