Greyhound Dynasties

A multi-year dynasty management game: breed greyhounds, enter races, bet, and build a lasting kennel legacy.

Gameplay Overview

Greyhound Dynasties is a simulation-focused management game where you take control of a greyhound kennel. Your goal is to build a lasting dynasty through careful breeding, strategic race entry, and sound financial management.

• Breed dogs with complex polygenic genetics and inheritable traits.
• Race in 12-runner fields with segment-based physics (break, early, middle, late).
• Manage your kennel's economy, balancing purses, stud fees, sales, and upkeep.
• Progress through seasons and years, culminating in the prestigious Breeder's Cup.

Core Systems

Genetics & Breeding

• Hidden Polygenics: Traits like speed and stamina are influenced by multiple genes.
• 14 Archetypes: Distinct racing styles with specific scoring and inheritance biases.
• Freak Generation: Rare dogs with exceptional traits and specific liabilities.
• Lineage Tracking: Detailed pedigree analysis and dynasty tier progression (Emerging → Legendary).

Racing

• Segment-Based Simulation: Races are divided into Break, Early, Middle, and Late segments.
• Trouble Events: Dynamic commentary and events affecting race outcomes.
• Heat Bands: Public ratings determine race eligibility and competition tiers.

Dynasties

• Bloodline Legacy: Track the history and prestige of your kennel's bloodlines.
• Rivalries: Head-to-head competition tracking between kennels and bloodlines.
• Hall of Fame: Historical records for top dogs and achievements.

Economy

• Purses & Fees: Income from race winnings, stud fees, and dog sales.
• Upkeep & Maintenance: Weekly costs for training, vet, and kennel operations.
• AI Market: Competing AI kennels with distinct personalities and strategies.

Features

• React 19 & TypeScript: Modern, type-safe frontend architecture.
• Zustand State Management: Efficient, normalized world state.
• Deterministic RNG: Seeded randomness for reproducible simulations.
• Headless Simulation: Monte Carlo batch runner for balance testing and analysis.
• Trainer System: AI-driven insights on race results and breeding potential.

Screenshots

Installation and Running the Game

Prerequisites

• Node.js (v18+ recommended)
• npm or yarn

Steps

1. Clone the repository:

   git clone https://github.com/yourusername/greyhound-dynasties.git
   cd greyhound-dynasties

2. Install dependencies:

   npm install

3. Start the development server:

   npm run dev

4. Open your browser to http://localhost:5173 (or the port indicated in the console).

Running Simulations

To run headless Monte Carlo simulations for balance testing:

npm run sim -- --runs 10 --years 20 --seed 42 --verbose

See montecarlo.md for detailed simulation documentation.

Project Structure

src/
|-- App.tsx, main.tsx, index.css
|-- components/       # React UI components (screens, widgets, primitives)
|-- game/             # Game logic, data, and engine systems
|   |-- data/         # Static data (dogs, kennels, tracks, profiles)
|   |-- engine/       # Simulation logic (racing, breeding, economy, progression)
|   `-- types.ts      # Centralized type definitions
|-- store/            # Zustand state management (selectors, actions, persistence)
|-- lib/ai/           # Trainer adapter for deterministic AI responses
`-- utils/            # Shared utilities

Key Modules

• src/game/engine/progression.ts: Orchestrates the weekly game loop.
• src/game/engine/breeding.ts: Handles genetics, inheritance, and breeding plans.
• src/game/engine/raceResolution.ts: Manages race preparation and settlement.
• src/store/gameStore.ts: Composition root for state management.

Simulation Design Philosophy

Greyhound Dynasties is built on several key architectural principles:

1. Domain-Driven Design: Game logic is separated into focused modules (breeding, racing, economy) with clear responsibilities.
2. Immutable State: World state updates return new objects rather than mutating in place, ensuring predictability and ease of testing.
3. Deterministic Randomness: All randomness uses seeded generators, allowing for reproducible simulations and balance testing.
4. Headless Engine: The core simulation logic is decoupled from the UI, enabling batch processing and automated testing via the Monte Carlo framework.

Development Status

Greyhound Dynasties is currently in active development. The core systems (racing, breeding, economy) are implemented and undergoing balance refinement. The project uses a Monte Carlo simulation framework to validate game balance across long time horizons.

Contributing

Contributions are welcome! Please follow these steps:

1. Fork the repository.
2. Create a feature branch (git checkout -b feature/amazing-feature).
3. Commit your changes (git commit -m 'Add amazing feature').
4. Push to the branch (git push origin feature/amazing-feature).
5. Open a Pull Request.

Please ensure your code passes linting (npm run lint) and tests (npm run test).

License

This project is licensed under the MIT License - see the LICENSE file for details.