game_testing_bdd

Design BDD and TDD test workflows for ECS game systems and Godot behavior.

2|Updated Jul 2, 2026
One-click install
npx skills add https://github.com/Xyrces/godot-ecs-gamedev-playbook --skill game-testing-bdd
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: game_testing_bdd
Source: https://github.com/Xyrces/godot-ecs-gamedev-playbook/tree/main/skills/game_testing_bdd
Command: npx skills add https://github.com/Xyrces/godot-ecs-gamedev-playbook --skill game-testing-bdd

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill helps you define, verify, and maintain game behavior with disciplined BDD and TDD practices, so ECS systems and Godot gameplay code stay deterministic, testable, and safe to refactor.

Core Features & Use Cases

  • BDD scenario design: Translate gameplay requirements into clear Given-When-Then feature tests.
  • TDD for ECS systems: Build movement, combat, health, and other systems from failing tests upward.
  • Deterministic validation: Check fixed-timestep simulation, replay consistency, and world-state checksums.
  • Architecture enforcement: Verify Core stays Godot-free, components remain unmanaged structs, and systems stay focused.
  • Property-based and runtime-specific testing: Use FsCheck for invariants and Chickensoft GoDotTest or GodotTestDriver for Godot scene and input integration.
  • Use case: Ideal for a Godot ECS game where you need repeatable tests for combat resolution, physics updates, input-driven movement, and platform-specific scene behavior.

Quick Start

Use this skill to write a failing Given-When-Then test for a Godot ECS gameplay feature before implementing the system.

Frequently Asked Questions about game_testing_bdd

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I write BDD tests for ECS systems in Godot?

To write BDD tests for ECS systems in Godot, translate gameplay requirements into Given-When-Then feature specs and build systems upward from failing tests. This approach keeps engine-agnostic Core and Godot Client projects deterministic and safe to refactor.

What is property-based testing for game systems and when should I use FsCheck?

Property-based testing for game systems validates invariants across generated inputs using FsCheck. Use it when you need to verify combat resolution, physics updates, or input-driven movement hold true across a wide range of state combinations rather than fixed scenarios.

Does this testing approach support Chickensoft GoDotTest and GodotTestDriver for runtime tests?

Yes, this testing approach supports Chickensoft GoDotTest and GodotTestDriver for runtime-dependent tests. It applies specifically to Godot scene and input integration testing scenarios where engine dependencies are required.

How do I validate determinism and replay consistency in an ECS game simulation?

Validate determinism and replay consistency in an ECS game simulation by checking fixed-timestep simulation logic, verifying replay consistency, and comparing world-state checksums. This ensures gameplay code remains repeatable and safe to refactor over time.

Can I enforce architecture boundaries between engine-agnostic Core and Godot Client code?

Yes, you can enforce architecture boundaries by verifying Core stays Godot-free, components remain unmanaged structs, and systems stay focused. This architecture testing prevents engine dependencies from leaking into shared logic.

What's the best way to start TDD for movement and combat systems in a Godot ECS game?

The best way to start TDD for movement and combat systems in a Godot ECS game is to write a failing Given-When-Then test for the specific gameplay feature before implementing the system. Use reusable ECS test fixtures to isolate component state.