Struct TcpClientConnection 

pub struct TcpClientConnection { /* private fields */ }

Implementations

impl TcpClientConnection

pub fn new(session_result: TcpSessionResult) -> Self

pub fn make(stream: TcpStream) -> Result<Self, Box<dyn Error>>

pub fn connect(address: impl ToSocketAddrs) -> Result<Self, Box<dyn Error>>

Examples found in repository

examples/ggpo.rs (line 255)

    fn draw_gui(&mut self, context: GameContext) {
        nav_horizontal_box(NavItemActive, || {
            if let Some(multiplayer) = context.multiplayer::<Multiplayer>() {
                text_box(TextBoxProps {
                    text: format!(
                        "WAITING FOR PLAYERS... ({}/2)",
                        multiplayer.peers_in_queue().count()
                    ),
                    font: TextBoxFont {
                        name: "roboto.ttf".to_owned(),
                        size: 24.0,
                    },
                    color: COLOR_WHITE,
                    horizontal_align: TextBoxHorizontalAlign::Center,
                    vertical_align: TextBoxVerticalAlign::Middle,
                    ..Default::default()
                });
            } else {
                let host = lobby_button("HOST");
                let join = lobby_button("JOIN");

                let is_host = if host.trigger_start() {
                    Some(true)
                } else if join.trigger_start() {
                    Some(false)
                } else {
                    None
                };

                if let Some(is_host) = is_host {
                    debug!("Starting {}...", if is_host { "server" } else { "client" });

                    context.network.clear_connections();
                    let id = if is_host {
                        context
                            .network
                            .add_connection(TcpServerConnection::listen(ADDRESS).unwrap());
                        PeerId::new(0)
                    } else {
                        context
                            .network
                            .add_connection(TcpClientConnection::connect(ADDRESS).unwrap());
                        PeerId::new(1)
                    };

                    let multiplayer = Multiplayer::new(context.network);
                    multiplayer.create_peer(id, PlayerRole::ROLE_ID);
                    *context.multiplayer_change = GameMultiplayerChange::Set(Box::new(
                        multiplayer
                            .with_ticks_per_second(30)
                            .with_max_prediction_ticks(MAX_PREDICTION_TICKS),
                    ));
                }
            }
        });
    }

examples/client_server.rs (line 249)

    fn draw_gui(&mut self, context: GameContext) {
        nav_horizontal_box(NavItemActive, || {
            if context.multiplayer::<ClientServerMultiplayer>().is_some() {
                text_box(TextBoxProps {
                    text: "ESTABLISHING CONNECTION...".to_owned(),
                    font: TextBoxFont {
                        name: "roboto.ttf".to_owned(),
                        size: 24.0,
                    },
                    color: COLOR_WHITE,
                    horizontal_align: TextBoxHorizontalAlign::Center,
                    vertical_align: TextBoxVerticalAlign::Middle,
                    ..Default::default()
                });
            } else {
                let host = lobby_button("HOST");
                let join = lobby_button("JOIN");

                let is_server = if host.trigger_start() {
                    Some(true)
                } else if join.trigger_start() {
                    Some(false)
                } else {
                    None
                };

                if let Some(is_server) = is_server {
                    debug!(
                        "Starting {}...",
                        if is_server { "server" } else { "client" }
                    );

                    context.network.clear_connections();
                    let mut network = GameNetwork::new(Arc::new(
                        PureAuthority::peer_factory(is_server)
                            .unwrap()
                            .with_typed::<PlayerController>(),
                    ));
                    if is_server {
                        network.add_connection(TcpServerConnection::listen(ADDRESS).unwrap());
                    } else {
                        network.add_connection(TcpClientConnection::connect(ADDRESS).unwrap());
                    }
                    if let Some(multiplayer) = ClientServerMultiplayer::new(&network) {
                        debug!("{} started", if is_server { "Server" } else { "Client" });

                        *context.network = network;
                        *context.multiplayer_change = GameMultiplayerChange::Set(Box::new(
                            multiplayer.with_ticks_per_second(30),
                        ));
                    }
                }
            }
        });
    }

examples/prediction_reconciliation.rs (line 249)

    fn draw_gui(&mut self, context: GameContext) {
        nav_horizontal_box(NavItemActive, || {
            if context.multiplayer::<Multiplayer>().is_some() {
                text_box(TextBoxProps {
                    text: "ESTABLISHING CONNECTION...".to_owned(),
                    font: TextBoxFont {
                        name: "roboto.ttf".to_owned(),
                        size: 24.0,
                    },
                    color: COLOR_WHITE,
                    horizontal_align: TextBoxHorizontalAlign::Center,
                    vertical_align: TextBoxVerticalAlign::Middle,
                    ..Default::default()
                });
            } else {
                let host = lobby_button("HOST");
                let join = lobby_button("JOIN");

                let is_server = if host.trigger_start() {
                    Some(true)
                } else if join.trigger_start() {
                    Some(false)
                } else {
                    None
                };

                if let Some(is_server) = is_server {
                    debug!(
                        "Starting {}...",
                        if is_server { "server" } else { "client" }
                    );

                    context.network.clear_connections();
                    let mut network = GameNetwork::new(Arc::new(
                        Authority::peer_factory(is_server)
                            .unwrap()
                            .with_typed::<PlayerRole>(),
                    ));
                    if is_server {
                        network.add_connection(TcpServerConnection::listen(ADDRESS).unwrap());
                    } else {
                        network.add_connection(TcpClientConnection::connect(ADDRESS).unwrap());
                    }
                    if let Some(multiplayer) = Multiplayer::new(&network) {
                        debug!("{} started", if is_server { "Server" } else { "Client" });

                        *context.network = network;
                        *context.multiplayer_change = GameMultiplayerChange::Set(Box::new(
                            multiplayer
                                .with_ticks_per_second(30)
                                .with_server_send_state_interval(SERVER_SEND_STATE_INTERVAL)
                                .with_client_lead_ticks(CLIENT_LEAD_TICKS)
                                .with_client_ping_interval(CLIENT_PING_INTERVAL),
                        ));
                    }
                }
            }
        });
    }

examples/rollback.rs (line 249)

    fn draw_gui(&mut self, context: GameContext) {
        nav_horizontal_box(NavItemActive, || {
            if context.multiplayer::<Multiplayer>().is_some() {
                text_box(TextBoxProps {
                    text: "ESTABLISHING CONNECTION...".to_owned(),
                    font: TextBoxFont {
                        name: "roboto.ttf".to_owned(),
                        size: 24.0,
                    },
                    color: COLOR_WHITE,
                    horizontal_align: TextBoxHorizontalAlign::Center,
                    vertical_align: TextBoxVerticalAlign::Middle,
                    ..Default::default()
                });
            } else {
                let host = lobby_button("HOST");
                let join = lobby_button("JOIN");

                let is_server = if host.trigger_start() {
                    Some(true)
                } else if join.trigger_start() {
                    Some(false)
                } else {
                    None
                };

                if let Some(is_server) = is_server {
                    debug!(
                        "Starting {}...",
                        if is_server { "server" } else { "client" }
                    );

                    context.network.clear_connections();
                    let mut network = GameNetwork::new(Arc::new(
                        Authority::peer_factory(is_server)
                            .unwrap()
                            .with_typed::<PlayerRole>(),
                    ));
                    if is_server {
                        network.add_connection(TcpServerConnection::listen(ADDRESS).unwrap());
                    } else {
                        network.add_connection(TcpClientConnection::connect(ADDRESS).unwrap());
                    }
                    if let Some(multiplayer) = Multiplayer::new(&network) {
                        debug!("{} started", if is_server { "Server" } else { "Client" });

                        *context.network = network;
                        *context.multiplayer_change = GameMultiplayerChange::Set(Box::new(
                            multiplayer
                                .with_ticks_per_second(30)
                                .with_server_send_state_interval(SERVER_SEND_STATE_INTERVAL)
                                .with_client_lead_ticks(CLIENT_LEAD_TICKS)
                                .with_client_ping_interval(CLIENT_PING_INTERVAL),
                        ));
                    }
                }
            }
        });
    }

pub fn log_frames(self, value: bool) -> Self

Trait Implementations

impl Drop for TcpClientConnection

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl GameConnection for TcpClientConnection

fn on_register( &mut self, events_sender: &Sender<EngineMeetingEvent>, ) -> EngineId

fn on_unregister(&mut self, events_sender: &Sender<EngineMeetingEvent>)

fn maintain(&mut self) -> bool

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any