public void UpdateGame()
        {
            UpdateBombs();
            UpdateCurrentMapData();
            myPlayer.Update();
            otherPlayer.Update();
            debugBoxes.Clear();
            CheckPlayerCollision(myPlayer);
            CheckPlayerCollision(otherPlayer);

            packetSendDelay--;
            if (packetSendDelay == 0)
            {
                packetSendDelay = 5;
                PacketData.PlayerPacketData playerPacketData = new PacketData.PlayerPacketData();
                playerPacketData.direction = (int)myPlayer.GetDirection();
                playerPacketData.moveSpeed = myPlayer.GetMoveSpeed();
                playerPacketData.moving    = myPlayer.GetMoving();
                playerPacketData.positionX = myPlayer.GetPosition().X;
                playerPacketData.positionY = myPlayer.GetPosition().Y;
                PacketData.BombermanClientToServerPacket packet = new PacketData.BombermanClientToServerPacket(bombsSinceLastPacket, playerPacketData);
                client.TCPSendPacket(packet);
                bombsSinceLastPacket.Clear();
            }
        }
Exemple #2
0
        private void ClientMethod(object clientObj)
        {
            Client client = (Client)clientObj;

            List <int>    recievers = new List <int>();
            List <String> messages  = new List <String>();

            int numOfIncomingBytes = 0;

            while ((numOfIncomingBytes = client._binaryReader.ReadInt32()) != 0)
            {
                byte[] buffer = client._binaryReader.ReadBytes(numOfIncomingBytes);
                System.IO.MemoryStream memoryStream = new System.IO.MemoryStream();
                System.Runtime.Serialization.Formatters.Binary.BinaryFormatter binaryFormatter = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                memoryStream.Position = 0;
                memoryStream.Write(buffer, 0, numOfIncomingBytes);
                memoryStream.Position = 0;
                memoryStream.Seek(0, System.IO.SeekOrigin.Begin);
                PacketData.Packet rawPacket = binaryFormatter.Deserialize(memoryStream) as PacketData.Packet;
                memoryStream.SetLength(0);

                switch (rawPacket.type)
                {
                case PacketData.PacketType.LOGIN:
                    PacketData.LogInPacket loginPacket = (PacketData.LogInPacket)rawPacket;
                    Console.WriteLine(loginPacket.username + " connected.");

                    client.SetName(loginPacket.username);

                    for (int i = 0; i < _clients.Count; i++)
                    {
                        recievers.Add(i);
                        if (i != client.GetID())
                        {
                            messages.Add("<AAAA00[" + loginPacket.username + "]><777700 has joined the server>");
                        }
                        else
                        {
                            String newPlayerMessage = _newPlayerInfo + GetCurrentUsers(client.GetID());
                            messages.Add(newPlayerMessage);
                        }
                    }

                    for (int i = 0; i < recievers.Count; i++)
                    {
                        PacketData.ChatMessagePacket sendPacket = new PacketData.ChatMessagePacket(messages[i]);
                        SendPacket(sendPacket, _clients[recievers[i]]);
                    }

                    break;

                case PacketData.PacketType.END_CONNECTION:
                    List <String> commandParams = new List <String>();
                    ProcessEndConnectionCommand(commandParams, client.GetID(), ref recievers, ref messages);
                    break;

                case PacketData.PacketType.BOMBERMAN_CLIENT_TO_SERVER:
                    PacketData.BombermanClientToServerPacket bombermanClientToServerPacket = (PacketData.BombermanClientToServerPacket)rawPacket;
                    if (client.GetCurrentGame().GetClient1() == client)
                    {
                        SendPacket(new PacketData.BombermanServerToClientPacket(bombermanClientToServerPacket.bombsPlaced, bombermanClientToServerPacket.player), client.GetCurrentGame().GetClient2());
                        //SendPacket(new PacketData.BombermanServerToClientPacket(bombermanClientToServerPacket.player), client.GetCurrentGame().GetClient2());
                    }
                    else
                    {
                        SendPacket(new PacketData.BombermanServerToClientPacket(bombermanClientToServerPacket.bombsPlaced, bombermanClientToServerPacket.player), client.GetCurrentGame().GetClient1());
                        //SendPacket(new PacketData.BombermanServerToClientPacket(bombermanClientToServerPacket.player), client.GetCurrentGame().GetClient1());
                    }
                    break;

                case PacketData.PacketType.CHAT_MESSAGE:
                    PacketData.ChatMessagePacket packet = (PacketData.ChatMessagePacket)rawPacket;

                    recievers.Clear();
                    messages.Clear();

                    GetRefinedMessage(packet.message, client.GetID(), ref recievers, ref messages);

                    bool sendToAll = false;
                    if (recievers.Count == 0)
                    {
                        sendToAll = true;
                    }

                    if (sendToAll)
                    {
                        PacketData.ChatMessagePacket sendPacket = new PacketData.ChatMessagePacket(messages[0]);

                        for (int i = 0; i < _clients.Count; i++)
                        {
                            SendPacket(sendPacket, _clients[i]);
                        }
                    }
                    else
                    {
                        for (int i = 0; i < recievers.Count; i++)
                        {
                            PacketData.ChatMessagePacket sendPacket = new PacketData.ChatMessagePacket(messages[i]);
                            SendPacket(sendPacket, _clients[recievers[i]]);
                        }
                    }
                    break;
                }

                if (_clients[client.GetID()].GetShouldTerminate())
                {
                    System.Threading.Thread listenerThread = _clients[client.GetID()]._listenerThread;
                    _clients.Remove(_clients[client.GetID()]);

                    for (int i = client.GetID(); i < _clients.Count; i++)
                    {
                        _clients[i].SetID(_clients[i].GetID() - 1);
                    }

                    listenerThread.Abort();
                }
            }
            client.Close();
        }