z4-types 0.2.0

Z4 game framework types
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

use std::sync::Arc;
use tokio::{
    sync::{mpsc::UnboundedSender, Mutex},
    time::sleep,
};

use crate::{HandleResult, Handler, RoomId, Task, Tasks};

/// Task message type
pub enum TaskMessage<H: Handler> {
    Result(RoomId, HandleResult<H::Param>),
}

/// Handle and listening tasks
pub fn handle_tasks<H: Handler>(
    room_id: RoomId,
    tasks: Tasks<H>,
    handler: Arc<Mutex<H>>,
    sender: UnboundedSender<TaskMessage<H>>,
) {
    for task in tasks {
        tokio::spawn(running(room_id, task, handler.clone(), sender.clone()));
    }
}

/// Loop listening task
async fn running<H: Handler>(
    room_id: RoomId,
    mut task: Box<dyn Task<H = H>>,
    handler: Arc<Mutex<H>>,
    sender: UnboundedSender<TaskMessage<H>>,
) {
    loop {
        sleep(std::time::Duration::from_secs(task.timer())).await;

        let mut handler_lock = handler.lock().await;
        if let Ok(res) = task.run(&mut handler_lock).await {
            let over = res.over;
            let _ = sender.send(TaskMessage::Result(room_id, res));
            if over {
                drop(handler_lock);
                break;
            }
        } else {
            drop(handler_lock);
            break;
        }
        drop(handler_lock);
    }
}