Space Command

Prompt

PROJECT: SPACE COMMAND — TACTICAL SCI-FI SOLITAIRE GAME

Project Vision

Build an original, fully playable browser-based strategy game that combines traditional Klondike Solitaire with futuristic military command, resource management and tactical survival.

The core idea is to transform every familiar card move into a meaningful strategic decision.

Instead of simply arranging cards until the deck is cleared, players must manage a fictional space command station while defending against increasingly dangerous enemy forces.

The game should reward patience, planning, intelligent card selection and calculated risk.

Create a complete gaming experience with an original science-fiction identity, immersive interface, reliable gameplay rules, meaningful progression and responsive controls.

The game must be achievable through iterative AI-assisted development using Lovable.

Do not create a static prototype where controls only appear functional. Build a playable experience from the opening screen to the final victory or defeat state.

1. Cinematic Game Homepage

Design an immersive science-fiction game menu inspired by the atmosphere of a futuristic military command center.

Use near-black backgrounds, distressed metal textures, illuminated tactical controls, detailed original illustrations and subtle atmospheric effects.

Create an original game logo with bold typography.

Display two primary game modes:

Prologue — First Command

A beginner-friendly campaign introducing the rules, tactical systems and player objectives.

Skirmish

A complete tactical solitaire session featuring randomized card arrangements and enemy encounters.

Include options for settings, sound controls, gameplay instructions and returning to the main menu.

Use restrained transitions that reinforce the game's military command atmosphere.

Ensure the menu is functional on both desktop and mobile browsers.

2. Complete Klondike Solitaire Engine

Implement a reliable Klondike solitaire system using standard playing-card rules.

Generate a complete 52-card deck.

Shuffle the deck using an appropriate randomization algorithm.

Deal seven tableau columns with increasing card counts.

Only the top card of each tableau column should initially be visible.

Create four foundation piles and a stock and waste area.

Support valid card movements including:

- Moving cards between tableau columns.
- Building tableau sequences in alternating colors.
- Moving eligible cards to foundations.
- Revealing hidden cards.
- Drawing cards from the stock.
- Moving cards from the waste.
- Moving valid card sequences.
- Placing kings in empty tableau columns.

Validate every move before updating game state.

Prevent illegal moves, duplicated cards, missing cards and inconsistent deck states.

Implement a clear method for detecting when the solitaire portion has been completed.

Support appropriate undo functionality without creating resource exploits.

3. Tactical Resource System

Connect solitaire actions to a fictional spaceship's command infrastructure.

Introduce three primary strategic resources:

Energy

Required to operate defensive systems and activate special abilities.

Shields

Protect the player's command station from incoming enemy attacks.

Command Points

Represent limited tactical authority used to activate powerful actions.

Define transparent rules for gaining or spending each resource.

For example, moving cards to foundations may generate energy, while revealing hidden cards could unlock tactical opportunities.

These relationships are proposed mechanics and should be balanced through playtesting.

Players must understand how each solitaire action influences their resources.

Display resources through compact, readable indicators.

4. Dynamic Enemy Wave System

Develop a tactical enemy system that creates pressure during solitaire gameplay.

Enemies should arrive in waves based on a defined turn or action schedule.

Create several enemy classes with distinct characteristics:

Scout: Fast, low-damage enemy.

Raider: Moderate threat capable of repeated attacks.
Interceptor: An enemy that pressures defensive timing.

Heavy Cruiser: Slower opponent with stronger defenses.

Command Ship: A powerful opponent appearing during important encounters.

Use deterministic enemy statistics and clearly communicated attack patterns.

Show incoming threats, enemy health and expected attack timing.

Do not create unavoidable damage sequences that make the game impossible to complete.

5. Strategic Action System

Create a tactical command panel where players can spend resources on defensive and offensive operations.

Implement optional actions such as:

- Activate defensive shields.
- Repair damaged command systems.
- Fire a tactical weapon.
- Delay an incoming attack.
- Gain additional information about threats.
- Trigger a limited emergency ability.

Every action should require defined resources and have predictable consequences.

Prevent invalid actions and insufficient-resource exploits.

Make meaningful decisions more important than repeatedly pressing combat buttons.

6. Solitaire and Combat Integration

Design the game so card movements and combat are deeply connected.

Each valid card action should advance the game's strategic state according to clearly defined rules.

Create a turn-resolution pipeline:

1. Validate the selected solitaire move.
2. Update the card arrangement.
3. Calculate tactical resource changes.
4. Resolve any triggered player abilities.
5. Advance relevant enemy events.
6. Apply combat consequences.
7. Check victory and defeat conditions.
8. Save the new game state.

Ensure that combat cannot interrupt card state transitions in ways that corrupt the solitaire engine.

Use a centralized state machine for reliable execution.

7. Prologue Campaign

Build a short, engaging introductory mission.

Introduce players to the story of a commander defending a damaged station on the edge of explored space.

Teach gameplay progressively.

The prologue should explain card movement, resource generation, enemy attacks and tactical abilities.

Use contextual instructions that appear only when relevant.

Allow players to practice each introduced mechanic.

Provide an introductory victory condition and a clear transition into Skirmish mode.

Avoid lengthy tutorial walls that prevent users from reaching the actual game.

8. Skirmish Mode

Create a standalone strategy mode with randomized starting conditions.

Generate playable solitaire configurations and reasonable tactical scenarios.

Allow users to select difficulty levels such as Recruit, Officer and Commander.

Difficulty should adjust resource availability, enemy pressure and tactical challenges.

Avoid making difficulty increases depend solely on excessive random punishment.

Support replayability through varied card arrangements and enemy encounters.

Provide clear rules for victory, defeat and restarting.

9. Tactical HUD and Game Board

Design a responsive primary gameplay interface.

The central visual area must contain the solitaire tableau, stock, waste and foundation piles.

Place critical combat information in a dedicated tactical panel.

Show:

- Current mission.
- Energy level.
- Shield integrity.
- Command Points.
- Enemy threat status.
- Available abilities.
- Current tactical objective.
- Game progress.

Use recognizable icons and clear typography.

Ensure the game remains readable without overcrowding the interface.

10. Card Interactions and Animations

Implement intuitive card interactions for desktop and mobile devices.

Support pointer-based dragging and tapping to select and move cards.

Highlight legal destinations when a card or sequence is selected.

Provide immediate feedback for valid and invalid actions.

Animate card movements smoothly while keeping the underlying game state authoritative.

Include effects for revealing hidden cards and completing foundation piles.

Allow users to reduce motion or disable unnecessary animations.

Do not let animations block important game interactions.

11. Tactical Combat Effects

Create original visual feedback for space combat.
Introduce restrained laser effects, shield impacts, energy pulses and enemy damage indicators.

Display attack warnings before important enemy actions.

Use visual effects to communicate mechanical outcomes rather than decorating the interface without purpose.

Provide optional sound effects for card movement, resource generation, shield impacts and mission completion.

Include a mute control and accessible alternatives to sound-only feedback.

12. Game Progression and Rewards

Develop a progression system that rewards completed missions and skilled strategic play.

Track experience points, missions completed and selected gameplay achievements.

Support fictional military ranks.

Introduce achievements for actions such as:

- Winning a mission without losing shields.
- Completing a difficult encounter.
- Successfully defending against multiple waves.
- Winning without using emergency abilities.
- Completing the tutorial campaign.

Ensure rewards reflect actual recorded achievements.

Store progress locally when the user plays without an account.

13. Game State Persistence

Implement automatic game-state saving.

Preserve the current deck arrangement, revealed cards, resource levels, enemy state, mission progress and available abilities.

Use browser storage for local saved games.

Allow users to resume an unfinished mission.

Version the saved-state schema so application updates can handle older saves gracefully.

Validate restored states to prevent corruption.

Provide a restart option that resets all gameplay variables correctly.

14. Responsive Mobile Experience

Optimize the game for smartphones and tablets.

Use adaptive card sizes, touch-friendly interactions and intelligently arranged tactical controls.

Allow the combat information panel to collapse when necessary.

Ensure cards do not become too small to identify.

Support portrait and landscape layouts where practical.

Prevent accidental page scrolling while dragging cards.

Test interactions on common mobile browser sizes.

15. Intelligent Hint System

Build a deterministic hint engine that examines available legal card moves.

Prioritize potentially useful moves such as revealing hidden cards, opening tableau columns and advancing foundations when strategically appropriate.

Allow the hint system to consider current tactical resources and enemy pressure.

Show possible moves without claiming that every suggested action guarantees victory.

Optionally integrate an AI language model to provide natural-language explanations of game strategy.

The AI should receive structured game-state information, not control card validity or combat resolution.

Keep this AI strategy assistant optional so the core game remains playable without external AI APIs.

16. Game Balance Engine

Create a configurable rules module containing tactical parameters.

Store values for enemy damage, resource generation, ability costs and mission difficulty in a centralized configuration.

Develop automated simulation tools for assessing balance.

Track metrics such as:

- Mission completion frequency.
- Average number of moves.
- Resource availability.
- Enemy damage received.
- Frequency of unwinnable states.
- Usage of tactical abilities.

Use testing results to improve fairness.

Separate game balance tuning from fundamental solitaire rules.

17. Technical Architecture

Use Lovable as the AI-assisted development environment.

Build the application with React, TypeScript and Tailwind CSS.

Use a reliable state-management approach for cards, combat and mission progression.

Implement the solitaire rules as pure, independently testable functions.

Use a finite-state machine or equivalent state transition model for combat.

Use Framer Motion or CSS animations for card movements and visual feedback.

Use local storage or IndexedDB for saving game progress.

No authentication or external database should be required for the initial release.

Integrate an AI strategy assistant only if the optional model feature is genuinely implemented.
These technologies are proposed for the reconstructed build and should not be interpreted as a complete verified inventory of the original game's internal stack.

18. Security and Performance

Validate every state-changing action.

Prevent card duplication and invalid game transitions.

Avoid trusting unvalidated client input for any future public leaderboard.

Optimize card rendering to prevent unnecessary component updates.

Preload essential visual assets.

Keep image and audio resources lightweight.

Ensure the application remains usable on slower devices.

Do not require unnecessary browser permissions.

19. Quality Assurance

Create unit tests for card-dealing logic, legal card movement, foundation rules, stock management and win conditions.

Add tests for tactical resource calculations and enemy turn progression.

Test saving and loading during different stages of a mission.

Use browser automation for representative gameplay scenarios.

Confirm that players can enter a mission, interact with cards, defeat enemies, lose a mission, restart and return to the main menu.

Test actual touch interactions on mobile devices.

Avoid describing a feature as complete until it works in a real playable session.

20. Original Visual Identity

Create a distinctive science-fiction world with an atmosphere inspired by an aging military starship.

Use deep charcoal, weathered steel, muted gold and controlled electric-blue highlights.

Design original card backs, tactical symbols, command panels and mission graphics.

Use strong typography and detailed textures without sacrificing readability.

Avoid generic gaming dashboards, excessive visual clutter and unnecessary glowing interfaces.

The visual language should feel like a coherent fictional universe.

21. Final Deliverables

Deliver a functional browser game containing:

- Cinematic game homepage.
- Complete Klondike solitaire rules.
- Interactive card controls.
- Tactical resources.
- Enemy wave system.
- Combat abilities.
- Guided prologue mission.
- Replayable skirmish mode.
- Experience and achievements.
- Saved game progress.
- Responsive mobile controls.
- Optional hint system.
- Victory and defeat screens.

Include clean source code, a clear README, automated gameplay tests and production deployment instructions.

The application must run as a complete playable experience rather than a nonfunctional visual demonstration.

Core Principle: Every card is a decision. Every decision could change the battle.