issun 0.10.0

A mini game engine for logic-focused games - Build games in ISSUN (一寸) of time
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

#![cfg(feature = "network")]

use issun::event::{Event, EventBus};
use issun::network::{NetworkBackend, NetworkScope, QuicClientBackend};

#[derive(Clone, Debug, PartialEq, serde::Serialize, serde::Deserialize)]
struct PlayerMove {
    x: i32,
    y: i32,
}

impl Event for PlayerMove {
    fn is_networked() -> bool {
        true
    }

    fn network_scope() -> NetworkScope {
        NetworkScope::Broadcast
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore] // Requires relay server running: make server-dev
async fn test_client_server_connection() {
    // Connect to relay server
    let result = QuicClientBackend::connect_to_server("127.0.0.1:5000").await;

    match result {
        Ok(backend) => {
            println!("✅ Successfully connected to relay server");
            println!("Node ID: {:?}", backend.node_id());
            assert!(backend.is_connected());
        }
        Err(e) => {
            eprintln!("❌ Failed to connect to relay server: {:?}", e);
            eprintln!("Make sure the server is running: make server-dev");
            panic!("Connection failed: {:?}", e);
        }
    }
}

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
#[ignore] // Requires relay server running: make server-dev
async fn test_two_clients_ping_pong() {
    // This test requires the relay server to be running
    // Run: make server-dev

    // Connect two clients
    let client1_result = QuicClientBackend::connect_to_server("127.0.0.1:5000").await;
    let client2_result = QuicClientBackend::connect_to_server("127.0.0.1:5000").await;

    if client1_result.is_err() || client2_result.is_err() {
        eprintln!("⚠️  Skipping test: Relay server not running");
        eprintln!("   Run: make server-dev");
        return;
    }

    let client1 = client1_result.unwrap();
    let client2 = client2_result.unwrap();

    println!("✅ Both clients connected");
    println!("Client 1 Node ID: {:?}", client1.node_id());
    println!("Client 2 Node ID: {:?}", client2.node_id());

    // Create EventBus with network for both clients
    let mut bus1 = EventBus::new().with_network(client1);
    let mut bus2 = EventBus::new().with_network(client2);

    // Register event types
    bus1.register_networked_event::<PlayerMove>();
    bus2.register_networked_event::<PlayerMove>();

    // Client 1 publishes an event
    bus1.publish(PlayerMove { x: 10, y: 20 });
    bus1.dispatch();

    // Wait a bit for network propagation
    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;

    // Client 2 should receive the event
    bus2.poll_network();
    bus2.dispatch();

    let reader = bus2.reader::<PlayerMove>();
    let events: Vec<_> = reader.iter().cloned().collect();

    if !events.is_empty() {
        println!("✅ Client 2 received events: {:?}", events);
        assert_eq!(events.len(), 1);
        assert_eq!(events[0], PlayerMove { x: 10, y: 20 });
    } else {
        println!("⚠️  No events received (this might be a timing issue)");
        // Don't fail the test as network timing can be unpredictable
    }
}