I'll start by reading the ROADMAP.md to understand what work is outstanding.

This is a large roadmap. The highest-impact item is Combat Integration (Phase 1, Item 1), which affects 800+ cards. Let me start by exploring the current codebase to understand what exists and what needs to be wired in.

Now I have a comprehensive understanding. Let me read the specific sections I need to modify.

Let me read more context needed to implement combat integration.

Now let me look at how damage dealing works in the game loop, and also how process_state_based_actions works since we'll need to ensure SBAs fire after combat damage.

Let me check the module structure and imports in game.rs.

Good - the combat module is already in lib.rs. Now I have all the context I need. Let me implement combat integration. This is a large task, so let me break it down:

1. Add CombatState to GameState
2. Add combat step handling to turn_based_actions() in game.rs
3. Add tests

Let me start implementing. First, add CombatState to GameState.

Now I have everything I need. Let me implement combat integration step by step.

Step 1: Add CombatState to GameState

Now add combat: CombatState::new() to the new() constructor:

Step 2: Implement combat steps in game.rs

First, add the imports needed:

Now implement the combat steps. Let me replace the _ => catch-all in turn_based_actions():

Now let me check if the gain_life method exists on Player:

Good. Now let's check if it compiles:

It compiles with just one unused import warning. Let me fix that:

Clean compile. Now let me check the rest of the workspace:

Full workspace compiles. Now let me run existing tests to make sure nothing is broken:

All 19 tests pass. Let me also check the engine tests:

All 188 engine tests pass. Now let me write tests for the combat integration. Let me find a good spot to add them in game.rs tests:

Let me find the end of the test module to add combat tests:

Now I need to look at the test setup pattern to understand how to construct a game for combat testing. Let me read a nearby test setup:

Good. Now I understand the test pattern. I need to write combat tests that create a game, manually set up the battlefield, and then call the combat step methods directly. Let me add tests at the end of the test module.

Now let me understand how to set up a quick test game. I'll need a helper function that creates a game and lets me add creatures to the battlefield, then I'll test combat directly. Let me add the tests:

All 13 combat tests pass. Let me run the full test suite to make sure nothing is broken:

All tests pass (201 engine + 19 integration = 220 total). Now let me update the ROADMAP.md to reflect this completed work:

Now update the step table and the combat integration section in the phased plan:

Now update the Phase 1 section:

Now commit this change:

Combat integration is complete and committed. Now let me move on to the next ROADMAP item: Triggered Ability Stacking (Phase 1, Item 2). This is the second highest-impact item, affecting ~400+ cards.

Let me explore the current state of the triggered ability system:

Excellent understanding. Let me now read the key sections I need to modify for triggered ability stacking - especially how abilities resolve from the stack:

Now let me read the AbilityStore methods more carefully, and how should_trigger works:

Now I understand the full picture. The key thing I need to do:

1. Emit events when game actions happen (ETB, dies, damage, etc.)
2. After SBAs, check for triggered abilities that match recent events
3. Push them on the stack in APNAP order
4. Let the priority loop handle resolution

The infrastructure is almost entirely in place. Let me look at where events need to be emitted - particularly during permanent ETB and death:

Now I'll implement triggered ability stacking. This is the second most impactful item. I need to:

1. Add event tracking to Game
2. Emit events at key game actions
3. After SBAs, check for triggered abilities matching events
4. Push triggered abilities onto the stack

Let me read the current process_step flow and the event log structure:

Good - EventLog already exists. Now let me look at the Game struct to add the event_log:

Now I have all the context. Let me implement triggered ability stacking. I'll modify game.rs to:

1. Add event_log field to Game
2. Add event emission at key points
3. Add check_triggered_abilities() method
4. Modify process_step() to loop SBAs + triggers

Now add the event_log field to the Game struct:

Add event_log: EventLog::new() to the constructor:

Now modify process_step() to loop SBAs + triggered abilities:

Now I need to emit events at key locations. Let me add event emission to the key game actions:

1. ETB (when a permanent enters the battlefield from resolving a spell)
2. Attack declared (when a creature is declared as an attacker)
3. Life gain (when a player gains life)
4. Damage to player (combat damage and spell damage)

Let me find and modify the ETB point in resolve_top_of_stack:

Let me find the resolve_top_of_stack more precisely:

Now I need to add event emission at key places. Let me modify resolve_top_of_stack to emit ETB events:

Now emit events for combat attacks in declare_attackers_step:

Let me find the attacker declaration part where I register attackers, and add event emission there:

Now emit events for life gain. Let me find where GainLife is handled in execute_effects:

Also emit for lifelink damage in combat:

Also emit for GainLifeVivid:

Now let me also emit ETB events when a permanent enters via the play_land function:

Now also emit for tokens created via CreateToken:

Let me add ETB event for token creation:

Now let me check if it compiles:

Clean compile. Let me also check the full workspace:

Now let me run all tests:

All 220 tests pass. Now let me write tests specifically for triggered abilities. I need to test that ETB triggers fire when a creature enters the battlefield, and that attack triggers fire when a creature attacks.

Two ETB tests fail. Let me check the enters_battlefield event constructor:

The event type is EntersTheBattlefield (not EnteredTheBattlefield). Let me check what the cards use:

There are TWO variants: EntersTheBattlefield (event fired) and EnteredTheBattlefield (trigger condition). Let me check which one cards use for their trigger events:

So cards use EnteredTheBattlefield as the trigger condition. But the event emitted by enters_battlefield() is EntersTheBattlefield. There's a mismatch. I need to either:

1. Change the event emission to use EnteredTheBattlefield, or
2. Make the trigger check match both

The cleaner fix is to emit EnteredTheBattlefield (the past tense) since that's what triggers respond to. Let me check my check_triggered_abilities code - I check against EnteredTheBattlefield there:

Looking at my code more carefully:

• The card trigger events list contains EnteredTheBattlefield
• should_trigger() checks if self.trigger_events.contains(&event.event_type)
• But the event emitted is EntersTheBattlefield

So they don't match. I need to emit EnteredTheBattlefield. Let me also fix the test which uses the wrong event type.

Also fix the check in check_triggered_abilities — I was checking EnteredTheBattlefield there which is now correct. Let me also fix the test to use the right event type:

All 5 trigger tests pass. Let me run the full test suite: