PyCeas Roadmap: Toward a Working Prototype

[ultimateownsz]

Overview

This roadmap focuses on implementing primary mechanics to create a playable prototype of PyCeas. The development leverages complimentary Pygame-ce libraries to accelerate iteration. The final goal is to integrate the game with browser playability, potentially hosting it on platforms like itch.io.

Guiding Philosophy

• Main Theme: Each phase builds upon prior work, creating a cohesive and functional prototype.
• Iterative developement: Use existing libraries to test ideas quickly, and refine or replace them with custom solutions if needed.
• Collaboration: Making sure that tasks are modular and well-documented for easy contributions.

---

Phase 1: Core Mechanics - Movement and Dice Roll

User stories:

• As a player, I want to roll dice to determine how far I can move my ship so that my movement feels smooth
• As a player, I want my ship to move across the map based on the dice roll result
• As a developer, I want a turn system that allows switching between players so that gameplay can alternate seamlessly.

Tasks

• Implement a basic turn counter:
  • Track whose turn it is (Player 1, Player 2, etc.)
  • Display the current player on the HUD using pygame-gui
  • Loop through players so the turn cycles back to the first player after all players have moved.
• Turn system with dice roll:
  • Add a button for rolling a dice (random.randint())
  • Display the dice result on screen using pygame-gui
  • Assign the dice result as movement points for the active player
  • Prevent the dice roll button from being active during another player's turn.
• Basic ship movement:
  • Replace the red square placeholder with a ship sprite for each player
  • Enable the ship to move across a tiled map based on dice results
  • Deduct movement points as the ship moves tile by tile
  • Prevent movement when the dice value reaches zero or when it's another player's turn

Libraries

• Pygame: For game loop, events, and sprite handling (ship movement)
• Pygame-gui: For UI component like the Roll dice button, turn display, and dice results

Acceptance criteria

• A Roll Dice button generates a dice result and updates the movement points for the current player
• Each player's ship moves across the map, limited by their dice roll values
• The turn counter updates dynamically, displaying the current player on the HUD
• Turns alternate seamlessly between players, resetting movement points for the active player

Challenges

• If the map grows larger or includes more players, additional logic will be needed to manage state efficently
• You may need to design a visual cue (like tile highlights) to indicate valid movement options. (the game has some sort of thing already, but very basic)

---

Phase 2: Map enhancements

User stories

• As a player, I want to explore a large map smoothly and efficiently to feel immersed in the gameplay.
• As a developer, I want to assess if a scrolling system improves performance and user experience.
• As a player, I want visual cues to understand where I can move during my turn.

Tasks

Refactor camera system

• Optimize the current pygame camera group implementation to improve scrolling performance
• Investigate lag causes by mouse interactions and optimize event handling during map navigation
• Add boundary constraints to prevent the camera from scrolling beyond the map edges

Evaluate scrolling system

• Analyze the current game loop to determine if adding a scrolling system is beneficial
• Prototype a scrolling system using:
  - Pygame camera group: test out if we can use a scrolling system to zoom in and out the map
  - Pyscroll: Test it's capabilities to manage scrolling and viewport management for large tiled maps.
• Compare scrolling performance and complexity with the current static map setup

Integrate scrolling (if beneficial)

• Add dynamic scrolling to follow the player as they move across the map.
• Implement boundary constraints to prevent scrolling beyond map edges
• Test the intergration for lag or stuttering issues during movement

Dynamic movement indicators

• Highlight accesible tiles dynamically based on movement points (from dice rolls)
• Add overlays or colored borders to improve player navigation
• Ensure the highlights update as movement points change or obstacles appear

Ship sprite (update)

• Scale the sprite appropriately and ensure smooth movement across the map (current is 1 pixel, ship sprites are larger so we need to test what works best)

Tiled map enhancements

• Refactor the existing map to:
  • Add larger navigable areas
  • Introduce dynamic objects like obstacles or interactive elements
• Test and optimize tile rendering for smooth performance, especially with scrolling.

Libraries

• pytmx: For improving the existing tiled map
• pyscroll or custom solution: For smooth map scrolling and viewport management
• Pygame camera group: As the baseline for prototyping scrolling functionality.

Acceptance criteria

1. Scrolling evaluation:

• A clear decision is made on whether scrolling improves gameplay and performance
• If integrated, scrolling follows the player smoothly, with no stuttering or lag
• Boundary constraints prevent scrolling beyond map limits

2. Dynamic movement indicators:

• Tiled the player can move to are clearly highlighted during their turn
• Highlights dynamically update based on dice rolls or other factors.

3. Ship sprite update:

• The ship is represented by a larger, visually distinct sprite
• Movement across tiles alignes with the new sprite's dimensions

4. Tiled map enhancements:

• The map includes dynamic objects and larger areas for exploration
• Rendering performance is maintained or improved after enhancements

---

Phase 3: Virtual book and inventory system

User stories

• As a player, I want a virtual book to manage my inventory and quests so that I can track my progress easily.
• As a player, I want my inventory to display items dynamically with icons and decriptions.

Tasks

• Virtual Book
  - Design a multi-tab interface using pygame-gui:
  - Inventory tab for items.
  - Placeholder tabs for quests and player stats
• Inventory system
  • Integrate the existing inventory prototype with item icons and descriptions
  • Add basic interaction (.e.g.. clicking an item displays details)

Libraries

• pygame-gui: For UI components (multi tab book, inventory layout)
• Pygame's sprite system: To manage and display item icons

Acceptance criteria

• Virtual book that opens with a key press (I or B)
• Tabs for inventory, quests, and stats are functional
• Inventory displays items dynamically with icons and descriptions

---

Phase 3.5: Improve dice roll mechanics with cards

User stories

• As a player, I want cards to modify my dice rolls so that I can strategize better
• As a player, I want to choose a card before rolling the dice ro influence the outcome
• As a player, I want to build and manage a deck of cards to create diverse dice roll strategies.

Tasks

Card system

• Create cards with effects:
  • Examples (here is community input valuable):
    • +1 to dice roll
    • Re-roll once
    • Double movement if the roll is even
    • Gain a bonus resource for rolling a 6
  • Store cards as data structures (dictionaries or classes) with attrributes like:
    • Name
    • Effect
    • Description
• Deck building:
  • Allow players to add or remove cards from their personal deck.
  • Start each player with a basic deck of cards
• Card selection before roll:
  • Display available cards to the active player
  • Allow the player to select one card to use before rolling the dice
    Dice modification
• Apply the selected card's effect:
  • Modify the dice roll based on the selected card rules
  • Update the HUD to display both the original roll and modified result
  • Deduct the selected card from the player's hand after use

Libraries

• pygame-gui: for creating the card selection UI and deck management interface (this could be integrated into the Virtual book, or a system apart from this)
• random module: For random roll results
• Custom card logic: To handle card effects dynamically (e.g. modifiers, condional outcomes)

Acceptance criteria

1. Card system

• Cards are displayed in the player's hand (inventory)
• Each card has a clear description
• Players can manage their decks by adding or removing cards

2. Card selection:

• At the start of their turn, players can select one card to play before rolling the dice.
• Only one card can be used per turn

3. Dice modification:

• The selected cards modifies the dice roll outcome based on its effect
• Both the original and modified dice roll results are displayed on the HUD
• Cards with single-use effects are removed from the playe's inventory after being used.

---

Phase 4: Future libraries for exploration

Future libraries for exploration

• Pymunk: A physics engine to add advanced gameplay mechanics, such as:
  • Collisions (e.g., ships colliding with obstacles or each other).
  • Ship combat mechanics (e.g., projectile physics for cannon battles).
• Pygbag: To package PySeas for browser-based playability:
  • Enables feedback collection from a broader audience on platforms like Itch.io.
  • Facilitates easy distribution without requiring installation.
• Pygame-menu: To implement start menus, settings screens, and other UI elements outside of gameplay.

This phase can be implemented earlier in the roadmap to gather player feedback on the core gameplay flow.