Example #1
0
        public override bool MoveStep()
        {
            if (Program.NrPlayers == 1)
            {
                return(base.MoveStep());
            }
            else if (this.playerNr == 1)
            {
                int X = this.x;
                int Y = this.y;

                bool Result = base.MoveStep();

                if (this.x != X || this.y != Y || Result)
                {
                    BinaryOutput Output = new BinaryOutput();
                    Output.WriteByte(8);
                    Output.WriteInt(this.x);
                    Output.WriteInt(this.y);
                    Output.WriteInt(this.vx);
                    Output.WriteInt(this.vy);
                    Output.WriteBool(Result);

                    Program.MPE.SendUdpToAll(Output.GetPacket(), 3);
                }

                return(Result);
            }
            else
            {
                return(false);
            }
        }
Example #2
0
        public override void AfterMove()
        {
            Color DestPixel = RetroApplication.Raster[this.x, this.y];

            if (DestPixel.ToArgb() != Color.Black.ToArgb())
            {
                if (DestPixel.R == 255 && DestPixel.B == 0)
                {
                    RetroApplication.FillFlood(this.x, this.y, Color.Black);

                    if (this.playerNr == 1)
                    {
                        BinaryOutput Output = new BinaryOutput();
                        int          Gift   = RetroApplication.Random(0, 31);

                        Output.WriteByte(7);
                        Output.WriteInt(Gift);

                        this.GetGift(1, Gift, Output, null);

                        if (Program.NrPlayers > 1)
                        {
                            Program.MPE.SendUdpToAll(Output.GetPacket(), 3);
                        }
                    }
                }
                else if (!this.immortal)
                {
                    this.Die();
                    return;
                }
            }

            if (!this.invisible || this.playerNr == 2)
            {
                RetroApplication.Raster[this.x, this.y] = this.headColor;
            }

            if (this.immortal)
            {
                int SecondsLeft = 10 - (int)(DateTime.Now - this.immortalStart).TotalSeconds;

                if (SecondsLeft != this.immortalSecondsLeft)
                {
                    if (SecondsLeft < 0)
                    {
                        this.immortal = false;
                        Program.PlayerMsg(this.playerNr, string.Empty);
                    }
                    else
                    {
                        this.immortalSecondsLeft = SecondsLeft;
                        Program.PlayerMsg(this.playerNr, "Immortal " + SecondsLeft.ToString());
                    }
                }
            }
        }
Example #3
0
        public static void Main(string[] args)
        {
            ManualResetEvent Terminated = new ManualResetEvent(false);

            Initialize();

            Console.Out.WriteLine("Move the mouse to move the pointer on the screen.");
            Console.Out.WriteLine("Press left mouse button while moving to draw.");
            Console.Out.WriteLine("Press the ESC key to close the application.");
            Console.Out.WriteLine("You will be able to see what others draw as well.");

            OnKeyDown += (sender, e) =>
            {
                if (e.Key == Key.Escape || (e.Key == Key.C && e.Control))
                {
                    Terminated.Set();
                }
            };

            FillRectangle(0, 0, ScreenWidth, ScreenHeight, C64Colors.Blue);

            int          PointerTexture = AddSpriteTexture(GetResourceBitmap("Pointer.png"), System.Drawing.Color.FromArgb(0, 0, 255), true);
            Point        P       = GetMousePointer();
            Point        LastP   = P;
            Sprite       Pointer = CreateSprite(P.X, P.Y, PointerTexture);
            Random       Rnd     = new System.Random();
            int          R       = Rnd.Next(128, 255);
            int          G       = Rnd.Next(128, 255);
            int          B       = Rnd.Next(128, 255);
            Color        Color   = Color.FromArgb(R, G, B);
            bool         Draw    = false;
            BinaryOutput Payload;

            using (MqttConnection MqttConnection = ConnectToMqttServer("iot.eclipse.org", false, string.Empty, string.Empty))
            {
                WriteLine("<" + MqttConnection.State.ToString() + ">", C64Colors.LightGreen);

                MqttConnection.TrustServer = true;

                MqttConnection.OnConnectionError += (sender, ex) =>
                {
                    WriteLine("Unable to connect:", C64Colors.Red);
                };

                MqttConnection.OnError += (sender, ex) =>
                {
                    WriteLine(ex.Message, C64Colors.Red);
                };

                MqttConnection.OnStateChanged += (sender, state) =>
                {
                    WriteLine("<" + MqttConnection.State.ToString() + ">", C64Colors.LightGreen);

                    if (state == MqttState.Connected)
                    {
                        MqttConnection.SUBSCRIBE("RetroSharp/Examples/Networking/MultiUserDraw");
                    }
                };

                OnMouseMove += (sender, e) =>
                {
                    P = e.Position;
                    Pointer.SetPosition(P);

                    int DX = P.X - RasterWidth / 2;
                    int DY = P.Y - RasterHeight / 2;

                    Pointer.Angle = 90 + 22.5 + System.Math.Atan2(DY, DX) * 180 / System.Math.PI;

                    if (Draw)
                    {
                        Payload = new BinaryOutput();
                        Payload.WriteString(MqttConnection.ClientId);
                        Payload.WriteInt(LastP.X);
                        Payload.WriteInt(LastP.Y);
                        Payload.WriteInt(P.X);
                        Payload.WriteInt(P.Y);
                        Payload.WriteColor(Color);

                        MqttConnection.PUBLISH("RetroSharp/Examples/Networking/MultiUserDraw", MqttQualityOfService.AtMostOne, false, Payload);

                        DrawLine(LastP.X, LastP.Y, P.X, P.Y, Color);
                    }

                    LastP = P;
                };

                OnMouseDown += (sender, e) =>
                {
                    Draw = e.LeftButton;
                };

                OnMouseUp += (sender, e) =>
                {
                    Draw = e.LeftButton;
                };

                MqttConnection.OnContentReceived += (sender, Content) =>
                {
                    BinaryInput Input    = Content.DataInput;
                    string      ClientId = Input.ReadString();
                    if (ClientId != MqttConnection.ClientId)
                    {
                        int   X1 = (int)Input.ReadInt();
                        int   Y1 = (int)Input.ReadInt();
                        int   X2 = (int)Input.ReadInt();
                        int   Y2 = (int)Input.ReadInt();
                        Color cl = Input.ReadColor();

                        DrawLine(X1, Y1, X2, Y2, cl);
                    }
                };

                while (!Terminated.WaitOne(1000))
                {
                    ;
                }
            }

            Terminate();
        }
Example #4
0
        public void GetGift(int PlayerIndex, int GiftIndex, BinaryOutput Output, BinaryInput Input)
        {
            switch (GiftIndex)
            {
            case 0:
                this.framesPerPixel = 4;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Slow speed");
                break;

            case 1:
                this.framesPerPixel = 5;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Slower speed");
                break;

            case 2:
                this.framesPerPixel = 6;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Slowest speed");
                break;

            case 3:
                this.framesPerPixel = 2;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Fast speed");
                break;

            case 4:
                this.framesPerPixel = 1;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Faster speed");
                break;

            case 5:
                this.framesPerPixel = 1;
                this.stepsPerFrame  = 2;
                if (this.shotSpeed < 2)
                {
                    this.shotSpeed = 2;
                }
                Program.PlayerMsg(this.playerNr, "Fastest speed");
                break;

            case 6:
                this.framesPerPixel = 3;
                this.stepsPerFrame  = 1;
                Program.PlayerMsg(this.playerNr, "Normal speed");
                break;

            case 7:
                this.shotPower = 5;
                Program.PlayerMsg(this.playerNr, "Tiny bullets");
                break;

            case 8:
                this.shotPower = 10;
                Program.PlayerMsg(this.playerNr, "Small bullets");
                break;

            case 9:
                this.shotPower = 15;
                Program.PlayerMsg(this.playerNr, "Normal bullets");
                break;

            case 10:
                this.shotPower = 20;
                Program.PlayerMsg(this.playerNr, "Large bullets");
                break;

            case 11:
                this.shotPower = 25;
                Program.PlayerMsg(this.playerNr, "Huge bullets");
                break;

            case 12:
                this.shotPower = 30;
                Program.PlayerMsg(this.playerNr, "Humongous bullets");
                break;

            case 13:
                this.shotPower = 50;
                Program.PlayerMsg(this.playerNr, "Peace-maker bullets");
                break;

            case 14:
                this.tail = false;
                Program.PlayerMsg(this.playerNr, "No tail");
                break;

            case 15:
                this.tail = true;
                Program.PlayerMsg(this.playerNr, "Tail");
                break;

            case 16:
                this.shotSpeed = Math.Max(1, this.stepsPerFrame);
                Program.PlayerMsg(this.playerNr, "Slow bullets");
                break;

            case 17:
                this.shotSpeed = Math.Max(2, this.stepsPerFrame);
                Program.PlayerMsg(this.playerNr, "Fast bullets");
                break;

            case 18:
                this.shotSpeed = Math.Max(3, this.stepsPerFrame);
                Program.PlayerMsg(this.playerNr, "Faster bullets");
                break;

            case 19:
                this.shotSpeed = Math.Max(4, this.stepsPerFrame);
                Program.PlayerMsg(this.playerNr, "Fastest bullets");
                break;

            case 20:
                int  X, Y;
                int  dx, dy;
                bool Ok;
                int  TriesLeft = 100;
                int  Black     = Color.Black.ToArgb();

                if (!(Input is null))
                {
                    this.x = 319 - (int)Input.ReadInt();
                    this.y = 207 - (int)Input.ReadInt();
                }
                else
                {
                    Ok = false;

                    while (TriesLeft-- > 0 && !Ok)
                    {
                        X  = RetroApplication.Random(30, 290);
                        Y  = RetroApplication.Random(38, 170);
                        Ok = true;
                        for (dy = -5; dy < 5; dy++)
                        {
                            for (dx = -5; dx < 5; dx++)
                            {
                                if (RetroApplication.Raster[X + dx, Y + dy].ToArgb() != Black)
                                {
                                    Ok = false;
                                    dy = 5;
                                    break;
                                }
                            }
                        }

                        if (Ok)
                        {
                            Output.WriteInt(X);
                            Output.WriteInt(Y);

                            this.x = X;
                            this.y = Y;
                        }
                    }

                    if (!Ok && !(Output is null))
                    {
                        Output.WriteInt(this.x);
                        Output.WriteInt(this.y);
                    }
                }

                Program.PlayerMsg(this.playerNr, "Teleport");
                break;
Example #5
0
        public static void Main(string[] _)
        {
            Initialize();

            Guid   PlayerId = Guid.NewGuid();
            string Player1Name;
            string Player2Name;

            Console.Out.WriteLine("Welcome to Mask! (Worms/Tron)");
            Console.Out.WriteLine(new string('-', 70));
            Console.Out.WriteLine("You control the work using the cursor keys.");
            Console.Out.WriteLine("Fire, using SPACE.");
            Console.Out.WriteLine("If you die, press ENTER to restart the game.");
            Console.Out.WriteLine("You can chat during the game.");
            Console.Out.WriteLine("Remember to try to fetch the gifts. You do that by moving into them.");
            Console.Out.WriteLine();
            Console.Out.WriteLine("Hello. What is your name?");
            Player1Name = Player2Name = Console.ReadLine();

            using (MPE = new MultiPlayerEnvironment("Mask", false, "iot.eclipse.org", 1883, false, string.Empty, string.Empty,
                                                    "RetroSharp/Examples/Games/Mask", 2, PlayerId, new KeyValuePair <string, string>("NAME", Player1Name)))
            {
                MPE.OnStateChange += (sender, state) =>
                {
                    switch (state)
                    {
                    case MultiPlayerState.SearchingForGateway:
                        Console.Out.WriteLine("Searching for Internet Gateway.");
                        break;

                    case MultiPlayerState.RegisteringApplicationInGateway:
                        Console.Out.WriteLine("Registering game in gateway.");
                        break;

                    case MultiPlayerState.FindingPlayers:
                        Console.Out.WriteLine("Waiting for another player to connect.");
                        Console.Out.WriteLine("Press ESC to play in single player mode.");
                        OnKeyDown += new KeyEventHandler(MPE_Wait_OnKeyDown);
                        break;

                    case MultiPlayerState.ConnectingPlayers:
                        Console.Out.WriteLine("Connecting to players.");
                        break;
                    }
                };

                MPE.OnPlayerAvailable += (sender, player) =>
                {
                    Console.Out.WriteLine("New player available: " + player["NAME"]);
                    MPE.ConnectPlayers();
                };

                MPE.OnPlayerConnected += (sender, player) =>
                {
                    Player2Name = player["NAME"];
                };

                MPE.OnPlayerDisconnected += (sender, player) =>
                {
                    PlayerMsg(2, "Disconnected");
                    NrPlayers = 1;
                    LocalMachineIsGameServer = true;
                };

                if (MPE.Wait(int.MaxValue))
                {
                    NrPlayers = MPE.PlayerCount;
                    LocalMachineIsGameServer = MPE.LocalPlayerIsFirst;
                }
                else
                {
                    PlayerMsg(2, "Network error");
                    NrPlayers = 1;
                }

                OnKeyDown -= new KeyEventHandler(MPE_Wait_OnKeyDown);

                ManualResetEvent            Done             = new ManualResetEvent(false);
                LinkedList <Shot>           Shots            = new LinkedList <Shot>();
                LinkedList <Explosion>      Explosions       = new LinkedList <Explosion>();
                LinkedList <Present>        Presents         = new LinkedList <Present>();
                LinkedList <PlayerPosition> Player2Positions = new LinkedList <PlayerPosition>();
                Player Player1      = new Player(1, 20, 28, 1, 0, 3, Color.Green, Color.LightGreen, 15);
                Player Player2      = new Player(2, 299, 179, -1, 0, 3, Color.Blue, Color.LightBlue, 15);
                bool   Player1Up    = false;
                bool   Player1Down  = false;
                bool   Player1Left  = false;
                bool   Player1Right = false;
                bool   Player1Fire  = false;
                bool   Player2Up    = false;
                bool   Player2Down  = false;
                bool   Player2Left  = false;
                bool   Player2Right = false;
                bool   Player2Fire  = false;

                Player1.Opponent = Player2;
                Player2.Opponent = Player1;

                Clear();
                FillRectangle(0, 0, 319, 7, Color.FromKnownColor(KnownColor.DimGray));
                SetClipArea(0, 8, 319, 199);

                string s = Player1Name.Length <= 10 ? Player1Name : Player1Name.Substring(0, 10);
                Console.Out.Write(s);

                s = Player2Name.Length <= 10 ? Player2Name : Player2Name.Substring(0, 10);
                GotoXY(ConsoleWidth - s.Length, 0);
                Console.Out.Write(s);

                OnKeyDown += (sender, e) =>
                {
                    switch (e.Key)
                    {
                    case Key.Escape:
                        if (MPE.State == MultiPlayerState.FindingPlayers)
                        {
                            MPE.ConnectPlayers();
                        }
                        else
                        {
                            Done.Set();
                        }
                        break;

                    case Key.C:
                        if (e.Control)
                        {
                            Done.Set();
                        }
                        break;

                    case Key.Up:
                        if (!Player1.Dead && Player1.VY != 1)
                        {
                            Player1Up = true;

                            if (NrPlayers == 1)
                            {
                                if (!Player2.Dead)
                                {
                                    Player2Down = true;
                                }
                            }
                            else
                            {
                                MPE.SendUdpToAll(new byte[] { 0 }, 3);
                            }
                        }
                        break;

                    case Key.Down:
                        if (!Player1.Dead && Player1.VY != -1)
                        {
                            Player1Down = true;

                            if (NrPlayers == 1)
                            {
                                if (!Player2.Dead)
                                {
                                    Player2Up = true;
                                }
                            }
                            else
                            {
                                MPE.SendUdpToAll(new byte[] { 1 }, 3);
                            }
                        }
                        break;

                    case Key.Left:
                        if (!Player1.Dead && Player1.VX != 1)
                        {
                            Player1Left = true;

                            if (NrPlayers == 1)
                            {
                                if (!Player2.Dead)
                                {
                                    Player2Right = true;
                                }
                            }
                            else
                            {
                                MPE.SendUdpToAll(new byte[] { 2 }, 3);
                            }
                        }
                        break;

                    case Key.Right:
                        if (!Player1.Dead && Player1.VX != -1)
                        {
                            Player1Right = true;

                            if (NrPlayers == 1)
                            {
                                if (!Player2.Dead)
                                {
                                    Player2Left = true;
                                }
                            }
                            else
                            {
                                MPE.SendUdpToAll(new byte[] { 3 }, 3);
                            }
                        }
                        break;

                    case Key.Space:
                        if (!Player1.Dead)
                        {
                            Player1Fire = true;

                            if (NrPlayers == 1)
                            {
                                if (!Player2.Dead)
                                {
                                    Player2Fire = true;
                                }
                            }
                            else
                            {
                                MPE.SendUdpToAll(new byte[] { 4 }, 3);
                            }
                        }
                        break;

                    case Key.Enter:
                        if (Player1.Dead)
                        {
                            if (NrPlayers > 1)
                            {
                                MPE.SendUdpToAll(new byte[] { 5 }, 3);
                            }
                            else
                            {
                                lock (Player2Positions)
                                {
                                    Player2Positions.Clear();
                                }

                                Shots.Clear();
                                Explosions.Clear();
                                Presents.Clear();
                                Player1      = new Player(1, 20, 28, 1, 0, 3, Color.Green, Color.LightGreen, 15);
                                Player2      = new Player(2, 299, 179, -1, 0, 3, Color.Blue, Color.LightBlue, 15);
                                Player1Up    = false;
                                Player1Down  = false;
                                Player1Left  = false;
                                Player1Right = false;
                                Player1Fire  = false;

                                Player1.Opponent = Player2;
                                Player2.Opponent = Player1;

                                FillRectangle(0, 8, 319, 199, Color.Black);
                                PlayerMsg(1, string.Empty);
                                PlayerMsg(2, string.Empty);
                            }
                        }
                        break;
                    }
                };

                OnKeyPressed += (sender, e) =>
                {
                    ChatCharacter(1, e.Character);
                    MPE.SendTcpToAll(new byte[] { 10, (byte)(e.Character >> 8), (byte)(e.Character) });
                };

                OnUpdateModel += (sender, e) =>
                {
                    if (LocalMachineIsGameServer && Random() < 0.005)
                    {
                        int x1, y1;

                        do
                        {
                            x1 = Random(30, 285);
                            y1 = Random(38, 165);
                        }while (!Present.CanPlace(x1, y1, x1 + 5, y1 + 5));

                        Presents.AddLast(new Present(x1, y1, x1 + 5, y1 + 5));

                        if (NrPlayers > 1)
                        {
                            BinaryOutput Output = new BinaryOutput();

                            Output.WriteByte(6);
                            Output.WriteInt(x1);
                            Output.WriteInt(y1);

                            MPE.SendUdpToAll(Output.GetPacket(), 3);
                        }
                    }

                    LinkedListNode <Present> PresentObj, NextPresentObj;

                    PresentObj = Presents.First;
                    while (!(PresentObj is null))
                    {
                        NextPresentObj = PresentObj.Next;
                        if (PresentObj.Value.Move())
                        {
                            Presents.Remove(PresentObj);
                        }

                        PresentObj = NextPresentObj;
                    }

                    if (Player1Up)
                    {
                        Player1.Up();
                        Player1Up = false;
                    }
                    else if (Player1Down)
                    {
                        Player1.Down();
                        Player1Down = false;
                    }
                    else if (Player1Left)
                    {
                        Player1.Left();
                        Player1Left = false;
                    }
                    else if (Player1Right)
                    {
                        Player1.Right();
                        Player1Right = false;
                    }

                    if (Player2Up)
                    {
                        Player2.Up();
                        Player2Up = false;
                    }
                    else if (Player2Down)
                    {
                        Player2.Down();
                        Player2Down = false;
                    }
                    else if (Player2Left)
                    {
                        Player2.Left();
                        Player2Left = false;
                    }
                    else if (Player2Right)
                    {
                        Player2.Right();
                        Player2Right = false;
                    }

                    if (!Player1.Dead && Player1.Move())
                    {
                        Explosions.AddLast(new Explosion(Player1.X, Player1.Y, 30, Color.White));
                    }

                    if (!Player2.Dead)
                    {
                        if (NrPlayers == 1)
                        {
                            if (Player2.Move())
                            {
                                Explosions.AddLast(new Explosion(Player2.X, Player2.Y, 30, Color.White));
                            }
                        }
                        else
                        {
                            lock (Player2Positions)
                            {
                                try
                                {
                                    foreach (PlayerPosition P in Player2Positions)
                                    {
                                        Player2.BeforeMove();
                                        Player2.SetPosition(P.X, P.Y, P.VX, P.VY);
                                        Player2.AfterMove();

                                        if (P.Dead)
                                        {
                                            Player2.Die();
                                            Explosions.AddLast(new Explosion(Player2.X, Player2.Y, 30, Color.White));
                                        }
                                    }
                                }
                                finally
                                {
                                    Player2Positions.Clear();
                                }
                            }
                        }
                    }

                    if (Player1Fire)
                    {
                        Player1.Fire(Shots);
                        Player1Fire = false;
                    }

                    if (Player2Fire)
                    {
                        Player2.Fire(Shots);
                        Player2Fire = false;
                    }

                    LinkedListNode <Shot> ShotObj, NextShotObj;

                    ShotObj = Shots.First;
                    while (!(ShotObj is null))
                    {
                        NextShotObj = ShotObj.Next;
                        if (ShotObj.Value.Move())
                        {
                            Shots.Remove(ShotObj);
                            Explosions.AddLast(new Explosion(ShotObj.Value.X, ShotObj.Value.Y, ShotObj.Value.Power, Color.White));
                        }

                        ShotObj = NextShotObj;
                    }

                    LinkedListNode <Explosion> ExplosionObj, NextExplosionObj;

                    ExplosionObj = Explosions.First;
                    while (!(ExplosionObj is null))
                    {
                        NextExplosionObj = ExplosionObj.Next;
                        if (ExplosionObj.Value.Move())
                        {
                            Explosions.Remove(ExplosionObj);
                        }

                        ExplosionObj = NextExplosionObj;
                    }
                };

                MPE.OnGameDataReceived += (sender, e) =>
                {
                    byte Command = e.Data.ReadByte();

                    switch (Command)
                    {
                    case 0:                             // Remote player presses UP
                        if (!Player2.Dead)
                        {
                            Player2Down = true;
                        }
                        break;

                    case 1:                             // Remote player presses DOWN
                        if (!Player2.Dead)
                        {
                            Player2Up = true;
                        }
                        break;

                    case 2:                             // Remote player presses LEFT
                        if (!Player2.Dead)
                        {
                            Player2Right = true;
                        }
                        break;

                    case 3:                             // Remote player presses RIGHT
                        if (!Player2.Dead)
                        {
                            Player2Left = true;
                        }
                        break;

                    case 4:                             // Remote player presses SPACE (Fire)
                        if (!Player2.Dead)
                        {
                            Player2Fire = true;
                        }
                        break;

                    case 5:                             // Remote player presses ENTER (Restart)
                    case 9:                             // Acknowledgement of remote player presses ENTER (Restart)

                        if (Command == 5)
                        {
                            MPE.SendUdpToAll(new byte[] { 9 }, 3);
                        }

                        lock (Player2Positions)
                        {
                            Player2Positions.Clear();
                        }

                        Shots.Clear();
                        Explosions.Clear();
                        Presents.Clear();
                        Player1      = new Player(1, 20, 28, 1, 0, 3, Color.Green, Color.LightGreen, 15);
                        Player2      = new Player(2, 299, 179, -1, 0, 3, Color.Blue, Color.LightBlue, 15);
                        Player1Up    = false;
                        Player1Down  = false;
                        Player1Left  = false;
                        Player1Right = false;
                        Player1Fire  = false;

                        Player1.Opponent = Player2;
                        Player2.Opponent = Player1;

                        FillRectangle(0, 8, 319, 199, Color.Black);
                        PlayerMsg(1, string.Empty);
                        PlayerMsg(2, string.Empty);

                        BorderColor = Color.FromKnownColor(KnownColor.DimGray);
                        break;

                    case 6:                             // New Present
                        int x1 = 315 - (int)e.Data.ReadInt();
                        int y1 = 203 - (int)e.Data.ReadInt();

                        Presents.AddLast(new Present(x1, y1, x1 + 5, y1 + 5));
                        break;

                    case 7:                             // Gift
                        x1 = (int)e.Data.ReadInt();
                        Player2.GetGift(2, x1, null, e.Data);
                        break;

                    case 8:                             // Move player 2
                        lock (Player2Positions)
                        {
                            Player2Positions.AddLast(new PlayerPosition(e.Data));
                        }
                        break;

                    case 10:                                    // chat character
                        char ch = (char)e.Data.ReadUInt16();
                        ChatCharacter(2, ch);
                        break;
                    }
                };

                while (!Done.WaitOne(1000))
                {
                    ;
                }
            }

            Terminate();
        }