Struct Engine 

pub struct Engine<H: Handler> {
    pub pending: HashMap<RoomId, PendingRoom>,
    pub games: HashMap<GameId, Vec<RoomId>>,
    /* private fields */
}

Z4 main engine. Engine

Fields

pending: HashMap<RoomId, PendingRoom>

Rooms which is waiting create, room => (game, players, sequencer)

games: HashMap<GameId, Vec<RoomId>>

Supported games and game’s pending rooms

Implementations

impl<H: Handler> Engine<H>

pub fn init(config: Config) -> Self

Init a engine with config

pub fn create_pending( &mut self, id: RoomId, game: GameId, viewable: bool, player: Player, salt: [u8; 32], block: [u8; 32], )

Create a pending room when scan from chain

pub fn join_pending(&mut self, id: RoomId, player: Player)

Join new player to the room

pub fn del_pending(&mut self, id: RoomId)

Create a pending room when scan from chain

pub fn contains_pending(&self, id: &RoomId) -> bool

Check if contains pending room

pub async fn start_room( &mut self, id: RoomId, sequencer: (PeerId, String), params: Vec<u8>, is_self: bool, task_sender: UnboundedSender<TaskMessage<H>>, )

Create a room when scan from chain

pub async fn over_room(&mut self, id: RoomId)

Over a room

pub fn has_room(&self, id: &RoomId) -> bool

Check room exists

pub fn get_room(&self, id: &RoomId) -> &HandlerRoom<H>

Get room info

pub async fn is_room_player(&self, id: &RoomId, peer: &PeerId) -> bool

Check the player is in the room

pub async fn has_peer(&self, peer: &PeerId) -> bool

Check the player is in some rooms that hold by this node

pub async fn online( &mut self, id: RoomId, peer: PeerId, ctype: ConnectType, ) -> bool

When a player online/connected

pub async fn offline(&mut self, peer: PeerId)

When a player offline/disconnected

pub async fn run(self) -> Result<()>

Run the engine with game logic

pub async fn run_with_channel( self, chain_send: UnboundedSender<ChainMessage>, chain_recv: UnboundedReceiver<ChainMessage>, ) -> Result<()>

Run the engine with game logic and channel