Example #1
0
    private async Task OnPlayerLeave(PlayerLeaveEventArgs e)
    {
        var player = e.Player as Player;

        await player.SaveAsync();

        player.World.TryRemovePlayer(player);

        var destroy = new DestroyEntities(player.EntityId);

        foreach (Player other in Players)
        {
            if (other == player)
            {
                continue;
            }

            await other.client.RemovePlayerFromListAsync(player);

            if (other.visiblePlayers.Contains(player.EntityId))
            {
                await other.client.QueuePacketAsync(destroy);
            }
        }

        BroadcastMessage(string.Format(Config.LeaveMessage, e.Player.Username));
    }
Example #2
0
        internal void InvokePlayerLeaveEvent(Player player)
        {
            var ev = new PlayerLeaveEventArgs {
                Player = player
            };

            PlayerLeaveEvent?.Invoke(ev);
        }
Example #3
0
        private async Task OnPlayerLeave(PlayerLeaveEventArgs e)
        {
            foreach (var(_, other) in this.OnlinePlayers.Except(e.Player.Uuid))
            {
                await other.client.RemovePlayerFromListAsync(e.Player);
            }

            await this.BroadcastAsync(string.Format(this.Config.LeaveMessage, e.Player.Username));
        }
Example #4
0
    public void OnPlayerLeaveGame(PlayerLeaveEventArgs playerLeaveEvent)
    {
        IPlayer player = playerLeaveEvent.Player;

        using var packet             = new PlayerInfoPacket(PlayerInfoActionType.Remove, player);
        using var removePlayerPacket = new DestroyEntitiesPacket(player);

        IEnumerable <IMinecraftUser> players = _server.ConnectedPlayers.Where(x => x.Player.Id != player.Id);

        _server.SendTo(players, packet);
        _server.SendTo(players, removePlayerPacket);
    }
        public async Task OnPlayerLeave(PlayerLeaveEventArgs e)
        {
            if (!(_config.Enabled && _config.JoinLeaveMessages.Enabled))
            {
                return;
            }

            _ = Task.Run(async() =>
            {
                if (_config.ChatSync.Enabled)
                {
                    string message = string.Format(_config.JoinLeaveMessages.LeaveMessageTemplate, e.Player.Username);
                    await(await _client.GetChannelAsync(_config.JoinLeaveMessages.ChannelId)).SendMessageAsync(message);
                }
            });
            await Task.CompletedTask;
        }
Example #6
0
        private async Task OnPlayerLeave(PlayerLeaveEventArgs e)
        {
            var player = e.Player as Player;

            this.World.RemovePlayer(player);

            var destroy = new DestroyEntities
            {
                EntityIds = new() { player.EntityId }
            };

            foreach (var(_, other) in this.OnlinePlayers.Except(player.Uuid))
            {
                await other.client.RemovePlayerFromListAsync(player);

                if (other.VisiblePlayers.Contains(player.EntityId))
                {
                    await other.client.QueuePacketAsync(destroy);
                }
            }

            await this.BroadcastAsync(string.Format(this.Config.LeaveMessage, e.Player.Username));
        }
Example #7
0
 internal Task InvokePlayerLeaveAsync(PlayerLeaveEventArgs eventArgs) =>
 this.playerLeave.InvokeAsync(eventArgs);
 private void Player_PlayerLeaveEvent(PlayerLeaveEventArgs ev)
 => infectedPlayers.Remove(ev.Player);
 private void OnPlayerLeaveEvent(PlayerLeaveEventArgs ev)
 => MakeAndSendData(ev);
 internal ValueTask InvokePlayerLeaveAsync(PlayerLeaveEventArgs eventArgs) =>
 PlayerLeave.InvokeAsync(eventArgs);
Example #11
0
 internal async Task InvokePlayerLeave(PlayerLeaveEventArgs eventArgs)
 {
     await Task.Factory.StartNew(async() => { await this._playerLeave.InvokeAsync(eventArgs); });
 }