settled-reach/server/tests/game_loop.rs

//! E2E integration test: full game loop with input processing and snapshot generation
//! Tests the complete pipeline: client sends input -> server processes -> server sends snapshot

use bevy_app::prelude::*;
use settled_reach_server::bridge::framing::{read_framed, write_framed};
use settled_reach_server::bridge::tcp::TcpBridge;
use settled_reach_server::bridge::types::*;
use settled_reach_server::bridge::{BridgePlugin, BridgeResource};
use settled_reach_server::knowledge::{KnowledgeGraph, KnowledgePlugin};
use settled_reach_server::npc::relationships::TrustEventQueue;
use settled_reach_server::simulation::interaction::NearbyInteractionBuffer;
use settled_reach_server::simulation::monologue::{MonologueBuffer, MonologueState};
use settled_reach_server::simulation::movement::{PlayerCharacter, TilePosition, WalkabilityMap};
use settled_reach_server::simulation::SimulationPlugin;
use std::io::{BufReader, BufWriter};
use std::net::{TcpListener, TcpStream};
use std::thread;

#[test]
fn player_moves_north_through_full_pipeline() {
    // Bind listener first — port guaranteed ready, no sleep needed
    let listener = TcpListener::bind("127.0.0.1:0").expect("bind listener");
    let server_addr = listener.local_addr().expect("get local addr");

    // Spawn server thread
    let server_handle = thread::spawn(move || {
        let bridge = TcpBridge::accept_on(listener).expect("accept connection");

        // Build app
        let mut app = App::new();
        app.add_plugins(SimulationPlugin { seed: 0 });
        app.add_plugins(BridgePlugin);
        app.add_plugins(KnowledgePlugin);
        app.init_resource::<TrustEventQueue>();
        app.insert_resource(BridgeResource::new(bridge));
        app.insert_resource(WalkabilityMap::new(32, 32, 1));
        app.world_mut().spawn((
            PlayerCharacter,
            TilePosition::new(16, 16, 0),
            KnowledgeGraph::new(),
            NearbyInteractionBuffer::default(),
            MonologueBuffer::default(),
            MonologueState::default(),
        ));

        // Run one tick: receive input, process, validate movement, generate snapshot, send
        app.update();
    });

    // Client: connect and send input (no sleep — listener was pre-bound)
    let stream = TcpStream::connect(server_addr).expect("client connect");
    let mut reader = BufReader::new(stream.try_clone().expect("clone for reader"));
    let mut writer = BufWriter::new(stream);

    // Send PlayerInput: MoveNorth at tick 0
    let inputs = vec![PlayerInput {
        tick: 0,
        action: PlayerAction::MoveNorth,
    }];
    let payload = rmp_serde::to_vec_named(&inputs).expect("serialize inputs");
    write_framed(&mut writer, &payload).expect("send inputs");

    // Receive ObserverSnapshot
    let response = read_framed(&mut reader)
        .expect("read snapshot")
        .expect("not EOF");
    let snapshot: ObserverSnapshot =
        rmp_serde::from_slice(&response).expect("deserialize snapshot");

    // Snapshot captures state at end of tick 0 (before advance_tick increments to 1)
    assert_eq!(snapshot.tick, 0);
    assert_eq!(snapshot.entities.len(), 1);

    // v2 fields populated
    assert_eq!(snapshot.game_time.day, 0);
    assert_eq!(
        snapshot.game_time.day_phase,
        settled_reach_server::simulation::time::DayPhase::Morning
    );
    assert_eq!(
        snapshot.game_time.tick_rate,
        settled_reach_server::simulation::time::TickRate::Full
    );

    let player_entity = &snapshot.entities[0];
    // Player started at (16, 16, 0), moved north (y-1) to (16, 15, 0)
    // Render coords: (16.5, 15.5, 0)
    assert_eq!(player_entity.x, 16.5);
    assert_eq!(player_entity.y, 15.5);
    assert_eq!(player_entity.z, 0);
    assert!(matches!(player_entity.kind, EntityKind::Player));
    assert!(matches!(
        player_entity.visibility,
        VisibilitySector::Forward
    ));

    // Clean up
    drop(reader);
    drop(writer);
    server_handle.join().expect("server thread panicked");
}