Getting Started

Getting Started

This guide covers everything you need to know to play Continuum and start developing with the codebase.

🎮 Playing Continuum

System Requirements

Minimum Requirements:

• OS: Windows 10, macOS 10.14, or Linux (Ubuntu 18.04+)
• RAM: 2 GB
• Graphics: OpenGL 3.3 support
• Storage: 50 MB available space

Recommended Requirements:

• OS: Latest stable version of your preferred OS
• RAM: 4 GB or more
• Graphics: Dedicated graphics card with Vulkan support
• Storage: 100 MB available space (for development)

Installation Options

Option 1: Download Release Build

1. Visit the GitHub Releases page
2. Download the latest release for your platform
3. Extract the archive to your preferred location
4. Run the Continuum executable

Option 2: Build from Source

# Clone the repository
git clone https://github.com/your-repo/continuum.git
cd continuum

# Install build dependencies
pip install scons

# Build the game
scons build-release

# Run the game
./build/continuum-release

Game Controls

Movement:

• WASD or Arrow Keys: Move your ship
• Hold for continuous movement, tap for precise positioning

Combat:

• Spacebar or Z Key: Fire current weapon
• X Key: Deploy bomb (when available)
• Tab: Switch between Vulcan and Laser weapons

Interface:

• Escape: Pause game / Access menu
• Enter: Confirm menu selections
• F11: Toggle fullscreen mode

Basic Gameplay

Your First Game

1. Launch the Game: Start Continuum and select "Start Game" from the main menu

2. Learn the Controls: Use WASD to move and Spacebar to shoot. Your ship automatically fires when you hold the key down.

3. Understand the Weapons:

   • Start with Vulcan (spread-fire): Good for groups of enemies
   • Switch to Laser (Tab key): Better for single, tough enemies

4. Collect Power-ups: When enemies are destroyed, they occasionally drop glowing power-ups. Collect these to upgrade your weapons.

5. Survive the Waves: Each wave brings more enemies. Try to clear all enemies to progress to the next wave.

Strategy Tips

Weapon Selection:

• Use Vulcan against multiple weak enemies
• Switch to Laser for armored enemies or tight formations
• Upgrade both weapons evenly for maximum effectiveness

Movement Tactics:

• Stay mobile - stationary ships are easy targets
• Use the edges of the screen for maneuvering room
• Learn enemy attack patterns to predict safe positions

Power-up Management:

• Prioritize collecting power-ups during safe moments
• Power-ups disappear after 10 seconds - don't wait too long
• Higher weapon levels dramatically increase your effectiveness

Scoring System

Points are awarded for:

• Destroying enemies (100-200 points each)
• Wave completion bonuses
• Perfect wave bonuses (no damage taken)
• High weapon accuracy

Score Multipliers:

• Later waves provide higher point multipliers
• Consecutive perfect waves increase bonus multipliers
• Weapon efficiency affects final score calculations

🛠️ Development Setup

Prerequisites

Required Software:

• Godot 4.4+: Download from godotengine.org
• Python 3.8+: For the SCons build system
• Git: For version control

Recommended Tools:

• Visual Studio Code: With GDScript extension
• Pre-commit: For automated code quality checks

Environment Setup

1. Clone the Repository

git clone https://github.com/your-repo/continuum.git
cd continuum

2. Install Build Dependencies

# Install SCons build system
pip install scons

# Install pre-commit for quality assurance
pip install pre-commit
pre-commit install

3. Install Game Dependencies

# Install Godot addons using gd-plug
./plug.gd install

4. Verify Installation

# Run the test suite
scons test

# Validate project integrity
scons validate

# Build development version
scons build-dev

Project Structure

continuum/
├── scenes/              # Godot scene files (.tscn)
│   ├── main/           # Main game scenes
│   ├── player/         # Player-related scenes
│   ├── enemies/        # Enemy templates
│   ├── projectiles/    # Bullet and projectile scenes
│   └── ui/             # User interface scenes
├── scripts/            # GDScript source code (.gd)
│   ├── autoloads/      # Singleton managers
│   ├── player/         # Player logic
│   ├── enemies/        # Enemy behaviors
│   └── projectiles/    # Projectile logic
├── assets/             # Game assets (textures, audio, etc.)
├── test/               # Test suite (gdUnit4)
│   ├── unit/           # Unit tests
│   ├── integration/    # Integration tests
│   └── scene/          # Scene tests
├── build/              # Build output directory
├── site_scons/         # SCons build system modules
├── SConstruct          # Main build configuration
└── project.godot       # Godot project configuration

Development Workflow

1. Running the Game

# Launch in Godot editor
/Applications/Godot.app/Contents/MacOS/Godot --path . --editor

# Run directly (macOS example)
/Applications/Godot.app/Contents/MacOS/Godot --path .

# Build and run development version
scons build-dev && ./build/continuum-dev

2. Running Tests

# Execute full test suite
scons test

# Run specific test file (advanced)
/Applications/Godot.app/Contents/MacOS/Godot --path . --headless \
  -s addons/gdUnit4/bin/GdUnitCmdTool.gd --add test/unit/test_player.gd

3. Code Quality

# Run pre-commit checks manually
pre-commit run --all-files

# Comprehensive project validation
scons validate

# Clean build artifacts
scons clean-build

Making Your First Change

1. Create a Feature Branch

git checkout -b feature/my-new-feature

2. Make Changes

• Edit GDScript files in the scripts/ directory
• Modify scenes in the scenes/ directory using Godot editor
• Add tests in the test/ directory

3. Test Your Changes

# Always run tests before committing
scons test

# Validate project integrity
scons validate

4. Commit Your Changes

# Add files to staging
git add .

# Commit with descriptive message
git commit -m "Add new enemy type with zigzag movement pattern

- Implement ZigzagEnemy class extending base Enemy
- Add configurable amplitude and frequency parameters
- Include comprehensive unit tests for movement patterns
- Update EnemyManager to spawn new enemy type"

Common Development Tasks

Adding a New Enemy Type

1. Create enemy scene in scenes/enemies/
2. Write enemy script in scripts/enemies/
3. Add spawn logic to EnemyManager.gd
4. Create unit tests in test/unit/
5. Test integration with wave system

Adding New Weapon Effects

1. Modify weapon logic in scripts/player/Player.gd
2. Update projectile behavior in scripts/projectiles/
3. Add visual effects in VisualEffects.gd
4. Create audio effects in SynthSoundManager.gd
5. Write comprehensive tests

Optimizing Performance

1. Use Godot's profiler to identify bottlenecks
2. Implement object pooling for frequently created objects
3. Optimize particle counts for target frame rate
4. Profile memory usage during intense gameplay
5. Validate performance improvements with benchmarks

Debugging Tips

Common Issues

Build Errors:

• Ensure Godot executable path is correct in SCons
• Verify all dependencies are installed (./plug.gd install)
• Check that project.godot is valid

Test Failures:

• Run individual tests to isolate issues
• Check test output in reports/ directory after running
• Verify mock objects are properly configured

Performance Issues:

• Enable Godot's profiler for performance analysis
• Monitor frame rate during intense scenes
• Check memory usage patterns during gameplay

Getting Help

Documentation:

• Read the Architecture page for system understanding
• Check the Game Design page for gameplay mechanics
• Review existing code for patterns and conventions

Community:

• Open GitHub issues for bugs or questions
• Check existing issues for similar problems
• Contribute to discussions and code reviews

Development Resources:

• Godot Documentation
• GDScript Style Guide
• gdUnit4 Documentation

This guide should get you started with both playing and developing Continuum. As you become more familiar with the codebase, don't hesitate to explore the more advanced features and contribute your own improvements!