QuantumStriker

Disclaimer

If you want to enjoy this game and submit your high score, please be aware that it may be lost due to future updates. If anyone besides myself is ever to play this game and contribute a score, I will try to develop a fully compatible mechanism so that past blockchain entries remain valid under future versions. I will save your score and do my best to ensure it is preserved for future iterations, but I cannot make that a guarantee.

Top Scores & Cheaters

Rank	Username	Score	Timestamp
1	kleinpanicDevAI	84700	2025-03-28 18:34:09
2	kleinpanic	2585	2025-03-26 16:02:08

No cheaters found.

QuantumStriker is a high-performance 2D space shooter written in C (using SDL2, SDL2_ttf, and SDL2_gfx). You pilot a futuristic spacecraft through a dynamically generated galactic environment, fending off waves of enemies that scale in difficulty as your score rises. When your ship is destroyed, your final score is recorded in a blockchain-based high score system that validates each entry via cryptographic proof-of-work and digital signatures. Invalid or tampered scores (failing verification) are flagged as cheaters and listed separately in the repository README.

Features

• Dynamic Galactic Environment:
  Explore a procedurally generated universe filled with stars, planets, and cosmic pickups. The background is populated randomly and scrolls as you fly, giving a sense of vast space.

• Adaptive Difficulty & Advanced AI:
  As your score grows, enemy spawn rates accelerate and AI behaviors become more challenging. Early on, you face simple drones, but as you progress, advanced enemy types (e.g., shooter, tank, fast, stealth, boss) appear. Shooter enemies maintain a strategic distance and fire at you with slight aim randomness for realism. Boss enemies have higher health and unique movement patterns to test your skills.

• Dynamic Ship Sizing:
  Change your ship’s size on the fly. Use UP to increase and DOWN to decrease your ship’s scale, affecting hitbox and firing spread. Press Right Shift to reset to the default size. This feature adds a tactical layer—larger ships can hit more targets but are easier to hit, while smaller ships are nimble but do less damage.

• Blockchain-Backed High Scores:
  After each game over, input a username to submit your score. The game creates a new block in highscore/blockchain.txt containing your username, score, timestamp, proof-of-work hash, and a digital signature. Proof-of-work ensures the score is computationally earned (by finding a hash with a required number of leading zeros), and the RSA signature (using your unique key) ties the block to you. A Python script, verify_scores.py, recomputes each block’s hash and checks the proof-of-work and signature to validate authenticity. Verified scores show up in Top Scores, whereas any block failing verification is listed under Cheaters.

• New Visual Effects (v0.1.9):

  • Fullscreen & Resizable Window: The game can run in fullscreen (--fullscreen flag) using your desktop’s resolution, or in a resizable window. The rendering system adapts to the current screen dimensions dynamically.
  • Camera Shake: When your ship takes damage (enemy bullet hits or enemy collisions), the camera briefly shakes to emphasize the impact. This uses a short shakeTimer and shakeMagnitude to offset the camera’s position for a few frames, then settles.
  • Explosion Animations: Destroying enemies with bullets triggers an explosion effect. A fiery orange blast expands and fades over 30 frames, adding visual feedback when you score a kill. These explosions do not occur for enemies destroyed by colliding with your ship (to distinguish kill types).

For a deeper technical breakdown, see ARCHITECTURE.md. For development guidelines, refer to CONTRIBUTING.md.

Installation

Dependencies

Ensure you have the following installed on your system:

• GCC or Clang (any C99-compliant compiler)
• SDL2 – Core library for graphics, windowing, and input.
• SDL2_ttf – Extension for rendering text (high score and HUD).
• SDL2_gfx – Extension for drawing shapes (used for explosions, shapes, etc.).
• OpenSSL – Required for RSA key generation and SHA-256 (for signature and proof-of-work).
• Make – For building the project.

On Debian/Ubuntu, you can install these via apt:

sudo apt-get install build-essential libsdl2-dev libsdl2-ttf-dev libsdl2-gfx-dev libssl-dev

(libssl-dev provides OpenSSL development libraries.)

Building

Clone the repository and navigate into it:

git clone https://github.com/yourusername/QuantumStriker.git
cd QuantumStriker

Compile the game using the provided Makefile:

make

This produces an executable named QuantumStriker. To include debug symbols and verbose logging, build in debug mode:

make debug

This defines debug flags and disables optimizations for easier debugging.

Usage

Run the game from the terminal:

./QuantumStriker

Use the controls described above to play. Close the game window or press Esc to exit.

Command-Line Flags

You can modify the game’s behavior with these optional flags:

• --version: Print the game version and exit.
• --help: Show a brief help text with usage and flags.
• --debug: Enable debug mode (console logging). By default, only critical errors log; with this flag, detailed logs appear (movement, collisions, AI decisions, etc.). Useful for development or if reporting a bug.
• --fullscreen: Start in fullscreen mode at desktop resolution. (You can still toggle windowed mode by quitting and restarting without the flag.)
• --highscores: Print all high scores recorded in the blockchain (valid and invalid) to the console in a formatted list, then exit.

Game Mechanics & High Score System

• Scoring: Your score increases with time survived and enemies destroyed. The current implementation awards 10 points per enemy kill plus 1 point per second of survival. The HUD (top-left) continuously displays your health, shield energy, score, and coordinates for awareness.

• Enemy AI: Enemies use simple AI patterns:

  • Basic drones head straight towards you.
  • Shooters try to keep a distance (~150-300 units) and fire periodically with slight inaccuracy.
  • Fast enemies dart quickly, making them hard to hit.
  • Evasive enemies zigzag or circle to avoid fire.
  • Tank enemies move slowly but can absorb more hits.
  • Stealth enemies occasionally turn invisible (not implemented fully in v0.1.9, but groundwork is laid).
  • Bosses appear at high scores (2000+ points) with significant health and a mix of behaviors (e.g., Boss1 might combine shooting and fast movements).

  The spawn algorithm introduces these types gradually: e.g., before 100 points only basics spawn; by 500 points, shooters mix in; by 1000, tanks join; by 2000+, all types including bosses can spawn. Each enemy type has preset health and sometimes unique properties (shooters have a shoot cooldown timer, stealth might have a transparency toggle, etc.).

• Game Loop: The core loop runs at ~60 FPS (frame delay ~15ms) and handles:

  1. Input – reading keyboard state for movement and actions.
  2. Updating Entities – moving the player and enemies, applying physics (thrust, drag), checking bounds.
  3. AI Decisions – updating enemy behavior (moving towards/away from player, deciding to shoot).
  4. Collisions – checking bullet collisions and enemy-player overlaps:
     • Player bullets vs enemies: if within ~15px, the bullet deals damage and (unless in dev “piercing” mode) disappears. If the enemy’s health drops ≤0, it’s “killed”: an explosion is triggered, the enemy is deactivated, and your kill count (for score) increments.
     • Enemy bullets vs player: if an active enemy bullet comes within ~15px of the player, it either depletes health (if your shield is off) or is absorbed (if shield on). On a hit without shield, the game triggers a camera shake (setting shakeTimer=20 frames and shakeMagnitude=10) to visually indicate damage. The bullet is then removed.
     • Enemy ships vs player: if any enemy gets within ~20px of the player, it’s a collision. If your shield is down, you take damage and camera shakes. The enemy is also destroyed by the