Struct z4_engine::Engine

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

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, account: Address, peer: PeerId, pubkey: [u8; 32], salt: [u8; 32], block: [u8; 32], )

create a pending room when scan from chain

pub fn join_pending( &mut self, id: RoomId, account: Address, peer: PeerId, pubkey: [u8; 32], )

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, send: Sender<SendMessage>, chain_send: UnboundedSender<ChainMessage>, )

create a room when scan from chain

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

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

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

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

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

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

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

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

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