private void onReceive(IAsyncResult iar)
 {
     try
     {
         byte[] datagram = udp.EndReceive(iar, ref endpoint);
         udp.BeginReceive(onReceive, null);
         var bpr = new BinaryPacketReader(datagram, true);
         player.updateData(bpr.readUpdateStruct());
     }
     catch (Exception e)
     {
         Console.WriteLine(e.Message);
     }
 }
 private void onReceive(IAsyncResult iar)
 {
     try
     {
         IPEndPoint endpoint = new IPEndPoint(IPAddress.Any, 0);
         byte[] datagram = udp.EndReceive(iar, ref endpoint);
         udp.BeginReceive(onReceive, null);
         var bpr = new BinaryPacketReader(datagram, true);
         uint playerid = bpr.readUInt32();
         var data = bpr.readUpdateStruct();
         if (!Client.instance.serverConnection.playersdata.ContainsKey(playerid)) Client.instance.serverConnection.playersdata.Add(playerid, data);
         else Client.instance.serverConnection.playersdata[playerid] = data;
     }
     catch (Exception e)
     {
         Game.Console.Print(e.Message);
     }
 }
        private void onReceive(IAsyncResult iar)
        {
            lock (Connection)
            {
                try
                {
                    int count = Connection.Client.EndReceive(iar);
                }
                catch
                {
                    Console.WriteLine("Client disconnected");
                    return;
                }

                var bpr = new BinaryPacketReader(Buffer);
                while (bpr.canRead())
                {
                    Commands command = bpr.readCommand();
                    if (command == Commands.Invalid) break;
                    switch (command)
                    {
                        case Commands.Disconnect:
                            {
                                if (Player != null)
                                {
                                    Server.instance.api.invokeOnPlayerDisconnect(Player);
                                }
                            }
                            break;

                        case Commands.Connect:
                            {
                                string nick = bpr.readString();
                                if (OnConnect != null) OnConnect.Invoke(nick);
                            }
                            break;

                        case Commands.InternalClient_requestSpawn:
                            {
                                if (Player != null)
                                {
                                    Server.instance.api.invokeOnPlayerDie(Player);
                                    Server.instance.api.invokeOnPlayerSpawn(Player);
                                    var bpf = new BinaryPacketFormatter(Commands.InternalClient_finishSpawn);
                                    Player.connection.write(bpf.getBytes());
                                }
                            }
                            break;
                        case Commands.Client_ping:
                            {
                                Int64 timestamp = bpr.readInt64();
                                Int64 current = DateTime.Now.Ticks;
                                Player.Ping = (int)((current - timestamp) /  10000);
                            }
                            break;

                        case Commands.Request_getSelectedPlayer:
                            {
                                if (Player != null)
                                {
                                    uint requestid = bpr.readUInt32();
                                    uint playerid = bpr.readUInt32();
                                    Request.dispatch(requestid, playerid);
                                }
                            }
                            break;

                        case Commands.Request_getCameraPosition:
                            {
                                if (Player != null)
                                {
                                    uint requestid = bpr.readUInt32();
                                    var vect = bpr.readVector3();
                                    Request.dispatch(requestid, vect);
                                }
                            }
                            break;

                        case Commands.Request_isObjectVisible:
                            {
                                if (Player != null)
                                {
                                    uint requestid = bpr.readUInt32();
                                    var vect = bpr.readByte() == 1;
                                    Request.dispatch(requestid, vect);
                                }
                            }
                            break;

                        case Commands.Request_worldToScreen:
                            {
                                if (Player != null)
                                {
                                    uint requestid = bpr.readUInt32();
                                    var x = bpr.readSingle();
                                    var y = bpr.readSingle();
                                    Request.dispatch(requestid, new SharpDX.Vector2(x, y));
                                }
                            }
                            break;

                        case Commands.Chat_sendMessage:
                            {
                                string text = bpr.readString();
                                if (text.StartsWith("/"))
                                {
                                    List<string> split = text.Split(' ').ToList();
                                    Server.instance.api.invokeOnPlayerSendCommand(Player, split.First().Substring(1), split.Skip(1).ToArray());
                                }
                                else
                                {
                                    Server.instance.api.invokeOnPlayerSendText(Player, text);
                                }
                            }
                            break;

                        case Commands.Player_damage:
                            {
                                if (Player != null)
                                {
                                    uint playerid = bpr.readUInt32();
                                    var bpf = new BinaryPacketFormatter(Commands.Player_setHealth);
                                    int newvalue = Server.instance.getPlayerById(playerid).data.ped_health - 10;
                                    bpf.Add(newvalue);
                                    var damaged_player = Server.instance.getPlayerById(playerid);
                                    damaged_player.connection.write(bpf.getBytes());
                                    if (newvalue <= 0 && !Player.isDead)
                                    {
                                        Player.isDead = true;
                                        Server.instance.api.invokeOnPlayerDie(damaged_player, Player, (Enums.Weapon)Player.data.weapon);
                                    }
                                }
                            }
                            break;

                        case Commands.Vehicle_damage:
                            {
                                if (Player != null)
                                {
                                    uint playerid = bpr.readUInt32();
                                    uint vehicleid = bpr.readUInt32();
                                    int delta = bpr.readInt32();
                                    var bpf = new BinaryPacketFormatter(Commands.Player_setVehicleHealth);
                                    int newvalue = Server.instance.vehicleController.getById(vehicleid).health - delta;
                                    bpf.Add(newvalue);
                                    Server.instance.getPlayerById(playerid).connection.write(bpf.getBytes());
                                }
                            }
                            break;

                        case Commands.Keys_down:
                            {
                                if (Player != null)
                                {
                                    int key = bpr.readInt32();
                                    Server.instance.api.invokeOnPlayerKeyDown(Player, (System.Windows.Forms.Keys)key);
                                }
                            }
                            break;

                        case Commands.Keys_up:
                            {
                                if (Player != null)
                                {
                                    int key = bpr.readInt32();
                                    Server.instance.api.invokeOnPlayerKeyUp(Player, (System.Windows.Forms.Keys)key);
                                }
                            }
                            break;

                        case Commands.NPCDialog_sendResponse:
                            {
                                if (Player != null)
                                {
                                    uint key = bpr.readUInt32();
                                    byte answer = Buffer[6];
                                    ServerNPCDialog.invokeResponse(Player, key, answer);
                                }
                            }
                            break;

                        case Commands.UpdateData:
                            {
                                if (Player != null)
                                {
                                    MIVSDK.UpdateDataStruct data = bpr.readUpdateStruct();
                                    if (Player.data.ped_health > data.ped_health)
                                    {
                                        Server.instance.api.invokeOnPlayerTakeDamage(Player, Player.data.ped_health, data.ped_health, Player.data.ped_health - data.ped_health);
                                    }
                                    Player.updateData(data);
                                }
                            }
                            break;
                    }
                }

                Connection.Client.BeginReceive(Buffer, 0, Buffer.Length, SocketFlags.None, onReceive, null);
            }
        }