public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar != null)
     {
         var args = client.Invoker.Thread.TempRegisters;
         if (args[0] == 1)
         {
             LogicPlayer = client;
             client.Send("TSOMaze_Show_Logic", new byte[0]);
             CooldownTimer = 6;
         }
         else
         {
             CharismaPlayer = client;
             client.Send("TSOMaze_Show_Charisma", new byte[0]);
             CooldownTimer = 8;
         }
         if (LogicPlayer != null && CharismaPlayer != null)
         {
             EnqueueGotoState(VMEODTwoPersonJobObjectMazePluginStates.Ready);
         }
     }
     else
     {
         Controller = client;
     }
     base.OnConnection(client);
 }
Exemple #2
0
        private void WheelsStoppedHandler(string evt, string uselessString, VMEODClient client)
        {
            var winnings = CurrentWinnings;

            CurrentWinnings = 0;
            if (winnings > 0)
            {
                // send win event with random number for message displayed
                client.Send("slots_display_win", "" + SlotsRandom.Next(25, 30) + "%" + winnings);

                // pay the player
                var VM = client.vm;
                VM.GlobalLink.PerformTransaction(VM, false, Server.Object.PersistID, client.Avatar.PersistID, winnings,

                                                 // debit the balance of the machine
                                                 (bool success, int transferAmount, uint uid1, uint budget1, uint uid2, uint budget2) =>
                {
                    if (success)
                    {
                        MachineBalance = (int)(budget1);
                    }
                });
            }
            else
            {
                // send loss event with random number for message displayed
                client.Send("slots_display_loss", "" + SlotsRandom.Next(30, 35));
            }
        }
Exemple #3
0
 public override void OnConnection(VMEODClient client)
 {
     base.OnConnection(client);
     if (client.Avatar != null)
     {
         // get the params, temp 0 is player type
         var local = client.Invoker.Thread.TempRegisters;
         if ((local != null) && (local[0] == (short)VMEODWarGamePlayers.Blue))
         {
             BluePlayerClient = client;
             BluePlayerClient.Send("WarGame_Init", BluePlayerClient.Avatar.ObjectID + "%blue");
             NumberOfPlayers++;
         }
         else
         {
             RedPlayerClient = client;
             RedPlayerClient.Send("WarGame_Init", RedPlayerClient.Avatar.ObjectID + "%red");
             NumberOfPlayers++;
         }
     }
     else
     {
         ControllerClient = client;
     }
     if ((NumberOfPlayers == 2) && (ControllerClient != null))
     {
         BluePlayerClient.Send("WarGame_Draw_Opponent", RedPlayerClient.Avatar.ObjectID + "");
         RedPlayerClient.Send("WarGame_Draw_Opponent", BluePlayerClient.Avatar.ObjectID + "");
         NextGameHandler((short)VMEODWarGameEvents.NextGame, ControllerClient);
     }
 }
 private void BroadcastSharedEvent(string evt, byte[] data)
 {
     if (LogicPlayer != null)
     {
         LogicPlayer.Send(evt, data);
     }
     if (CharismaPlayer != null)
     {
         CharismaPlayer.Send(evt, data);
     }
 }
Exemple #5
0
 private void GameOverHandler(short eventID, VMEODClient player)
 {
     // check if object has enough money or too much money, then start new game or send offline message to the player
     if (IsObjectBalanceInBounds())
     {
         player.Send("slots_new_game", "");
     }
     else
     {
         player.Send("slots_close_machine", "");
     }
 }
        public override void OnConnection(VMEODClient client)
        {
            base.OnConnection(client);

            PlayerClient = client;

            // get the registers
            var args = client.Invoker.Thread.TempRegisters;

            // get the initial minutes and seconds
            CurrentDisplayedMinutes = args[2];
            CurrentDisplayedSeconds = args[3];

            // get the current running states
            IsRunning = (args[0] == 1) ? true : false;
            if (Enum.IsDefined(typeof(VMEODTimerPluginStates), args[1]))
            {
                State = (VMEODTimerPluginStates)Enum.ToObject(typeof(VMEODTimerPluginStates), args[1]);
            }
            else
            {
                State = VMEODTimerPluginStates.Countdown;
            }

            // show the client: @params - Byte[] { 0 if IsRunning or 1 if !IsRunning, 0 if State = Countdown 1 if State = Stopwatch, Minutes/256, Seconds }
            PlayerClient.Send("Timer_Show", new Byte[] { (byte)args[0], (byte)args[1], (byte)(CurrentDisplayedMinutes), (byte)CurrentDisplayedSeconds });
        }
        public override void OnConnection(VMEODClient client)
        {
            base.OnConnection(client);
            var args           = client.Invoker.Thread.TempRegisters;
            var trunkTypeShort = args[0];

            // check if the passed params match a trunk
            bool isValidTrunkParam = Enum.IsDefined(typeof(VMEODTrunkPluginCollections), trunkTypeShort);

            if (!isValidTrunkParam)
            {
                Server.Disconnect(client);
            }

            if (trunkTypeShort == (short)VMEODTrunkPluginCollections.costumes)
            {
                IsCostumeTrunk = true;
            }

            var typeString = Enum.GetName(typeof(VMEODTrunkPluginCollections), trunkTypeShort);

            // avatar gender affects collection & path
            var  avatar = client.Avatar;
            bool isMale = (avatar.GetPersonData(VMPersonDataVariable.Gender) == 0);

            string collectionPath = typeString + (isMale ? "_" : "_fe") + "male.col";

            // get the matching trunk collection
            var content = Content.GameContent.Get;

            TrunkOutfits = content.AvatarCollections.Get(collectionPath);

            client.Send("trunk_fill_UI", collectionPath);
        }
Exemple #8
0
        private void StoreDefaultSuit(VMEODClient client, VMPersonSuits category, uint outfitId)
        {
            GetOutfit(client.vm, outfitId, outfit => {
                if (outfit == null)
                {
                    //You don't own this outfit!
                    return;
                }

                if (outfit.outfit_type != (byte)category)
                {
                    //Wrong category, no swimming in PJs!
                    return;
                }

                //Set the default in the vm, this will be persisted on exit avatar persist
                client.vm.SendCommand(new VMNetSetOutfitCmd {
                    UID    = client.Avatar.PersistID,
                    Scope  = category,
                    Outfit = outfit.asset_id
                });

                //Have the UI update the default
                client.Send("dresser_refresh_default", "");
            });
        }
Exemple #9
0
        public override void OnConnection(VMEODClient client)
        {
            var args = client.Invoker.Thread.TempRegisters;

            // client belongs to a player
            if (client.Avatar != null)
            {
                if ((args != null) && (args[0] > -1) && (args[0] < 4))
                {
                    if (Lobby.Join(client, args[0]))
                    {
                        client.Send("Band_UI_Init", new byte[] { (byte)args[0] });
                        var slot = Lobby.GetSlotData(client);
                        if (slot != null)
                        {
                            slot.AvatarName  = client.Avatar.Name;
                            slot.Instrument  = (VMEODBandInstrumentTypes)Enum.ToObject(typeof(VMEODBandInstrumentTypes), args[0]);
                            slot.SkillAmount = GetAvatarsCurrentSkill(client);

                            if (Lobby.IsFull())
                            {
                                InitGame();
                            }
                        }
                    }
                }
            }
            // client belongs to the smart tile, is contoller
            else
            {
                Controller = client;
            }
            base.OnConnection(client);
        }
        public override void Tick()
        {
            base.Tick();

            if (IsRunning)
            {
                Tock = 0;

                if (State.Equals(VMEODTimerPluginStates.Countdown))
                {
                    // get the registers
                    var args = PlayerClient.Invoker.Thread.TempRegisters;
                    if ((args[2] == 0) && (args[3] == 0))
                    {
                        IsRunning        = false;
                        UpdatedAfterStop = true;
                        // get the updated minutes and seconds
                        CurrentDisplayedMinutes = args[2];
                        CurrentDisplayedSeconds = args[3];
                        PlayerClient.Send("Timer_Off", new byte[] { (byte)State });
                        PlayerClient.Send("Timer_Update", CurrentDisplayedMinutes + ":" + CurrentDisplayedSeconds);
                    }
                }
            }
            else if (!UpdatedAfterStop)
            {
                if (Tock == 0)
                {
                    PlayerClient.SendOBJEvent(new VMEODEvent((short)VMEODTimerEvents.Update));
                }
                Tock++;

                if (Tock == 5)
                {
                    UpdatedAfterStop = true;

                    // get the registers
                    var args = PlayerClient.Invoker.Thread.TempRegisters;

                    // get the final minutes and seconds
                    CurrentDisplayedMinutes = args[2];
                    CurrentDisplayedSeconds = args[3];

                    PlayerClient.Send("Timer_Update", CurrentDisplayedMinutes + ":" + CurrentDisplayedSeconds);
                }
            }
        }
Exemple #11
0
        private void WheelsStoppedHandler(string evt, string uselessString, VMEODClient client)
        {
            var winnings = CurrentWinnings;

            CurrentWinnings = 0;
            if (winnings > 0)
            {
                // send win event with random number for message displayed
                client.Send("slots_display_win", "" + SlotsRandom.Next(25, 30) + "%" + winnings);

                // pay the player
                var VM = client.vm;
                VM.GlobalLink.PerformTransaction(VM, false, Server.Object.PersistID, client.Avatar.PersistID, winnings,

                                                 // debit the balance of the machine
                                                 (bool success, int transferAmount, uint uid1, uint budget1, uint uid2, uint budget2) =>
                {
                    //TODO: Make this part of global link
                    VM.SendCommand(new VMNetAsyncResponseCmd(0, new VMTransferFundsState
                    {
                        Responded      = true,
                        Success        = success,
                        TransferAmount = transferAmount,
                        UID1           = uid1,
                        Budget1        = budget1,
                        UID2           = uid2,
                        Budget2        = budget2
                    }));
                    if (success)
                    {
                        MachineBalance  = (int)(budget1);
                        CurrentWinnings = 0; // winning payout cannot be duplicated
                    }
                    else
                    {
                        //Console.WriteLine("VMEODSlotsPlugin.WheelsStoppedHandler: There was an error while paying the player the winnings.");
                        CurrentWinnings = 0; // winning payout cannot be duplicated
                    }
                });
            }
            else
            {
                // send loss event with random number for message displayed
                client.Send("slots_display_loss", "" + SlotsRandom.Next(30, 35));
            }
        }
Exemple #12
0
 protected override void OnConnected(VMEODClient client)
 {
     //all this plugin needs to do is get the info from the database, and send it
     //on it's merry way
     Server.vm.GlobalLink.GetDynPayouts((data) =>
     {
         client.Send("newspaper_state", data);
     });
 }
        public override void OnConnection(VMEODClient client)
        {
            if (client.Avatar != null)
            {
                EODType         = VMEODGameshowBuzzerPluginType.Player;
                MyBuzzerEnabled = false;
                // get the score from the object's via tempregisters
                MyScore  = client.Invoker.Thread.TempRegisters[0];
                MyClient = client;
                MyClient.Send("BuzzerEOD_Init", new byte[] { (byte)VMEODGameshowBuzzerPluginType.Player });

                // update the UI to match their buzzer object's score
                MyClient.Send("Buzzer_Player_Score", BitConverter.GetBytes(MyScore));

                SyncEvent += PlayerSyncHandler;
            }
            base.OnConnection(client);
        }
Exemple #14
0
        private void UpdateScore(string evt, string body, VMEODClient client)
        {
            var parts = body.Split(',');

            if (parts.Length != 2)
            {
                return;
            }

            VMEODScoreboardTeam team;
            short difference;

            if (!Enum.TryParse <VMEODScoreboardTeam>(parts[0], out team) ||
                !short.TryParse(parts[1], out difference))
            {
                return;
            }

            Persist.Patch(current =>
            {
                var result = current.Clone();
                switch (team)
                {
                case VMEODScoreboardTeam.LHS:
                    result.LHSScore += difference;
                    if (result.LHSScore < 0)
                    {
                        result.LHSScore = 0;
                    }
                    if (result.LHSScore > 999)
                    {
                        result.LHSScore = 999;
                    }

                    client.SendOBJEvent(new Model.VMEODEvent((short)VMEODScoreboardEvent.SetLHSScore, result.LHSScore));
                    break;

                case VMEODScoreboardTeam.RHS:
                    result.RHSScore += difference;
                    if (result.RHSScore < 0)
                    {
                        result.RHSScore = 0;
                    }
                    if (result.RHSScore > 999)
                    {
                        result.RHSScore = 999;
                    }

                    client.SendOBJEvent(new Model.VMEODEvent((short)VMEODScoreboardEvent.SetRHSScore, result.RHSScore));
                    break;
                }

                client.Send("scoreboard_state", result);
                return(result);
            });
        }
 public override void Tick()
 {
     base.Tick();
     if ((Data != null) && (!IsRackNameInitialized) && (Client != null))
     {
         // send event to initialize rack name along with the name
         Client.Send("rack_initialize_name", Data.RackName);
         IsRackNameInitialized = true;
     }
 }
Exemple #16
0
        /// <summary>
        /// Execute an Incorrect Answer Sequence on the specified player index.
        /// </summary>
        /// <param name="evt">Buzzer_Host_PlayerIncorrect</param>
        /// <param name="playerBytes">player index 0-3</param>
        /// <param name="host"></param>
        private void PlayerIncorrectHandler(string evt, byte[] playerBytes, VMEODClient host)
        {
            lock (PlayerConfigLock)
            {
                var playerIndex = BitConverter.ToInt32(playerBytes, 0);
                lock (ConnectedContestants)
                {
                    if (!BuzzerEnabled)
                    {
                        string playerName = null;
                        var    player     = ConnectedContestants[playerIndex];
                        if (player != null && player.EODType.Equals(VMEODGameshowBuzzerPluginType.Player))
                        {
                            playerName = player.AvatarName;
                            player.ExecuteIncorrectAnswer((short)(_Options.AutoDeductWrongPoints ? _Options.CorrectAnswerScore : 0));
                            if (_Options.AutoDisableOnWrong)
                            {
                                SetPlayerBuzzer(playerIndex, false);
                            }

                            // other players should react
                            var players = GetConnectedPlayers(playerIndex, true);
                            foreach (var otherPlayers in players)
                            {
                                otherPlayers.ExecuteOthersAnswer(0, playerName);
                            }

                            // update host UI
                            host.Send("BuzzerEOD_Answer", new byte[0]);
                            // execute host event for host avatar to acknowledge player avatar's answer
                            Controller.SendOBJEvent(new Model.VMEODEvent((short)VMEODGameshowHostPluginEvents.Judge_Answer_Incorrect, player.MyClient?.Avatar?.ObjectID ?? 0));
                        }
                        ChangeBuzzerState(VMEODGameshowBuzzerStates.Disabled);
                    }
                    else
                    {
                        // buzzer enabled error
                        host.Send("Buzzer_Host_Error", new byte[(byte)VMEODGameshowBuzzerPluginErrors.H_NoChangesAllowed]);
                    }
                    SendContestantRoster();
                }
            }
        }
        public void PlayerHandUpdate(VMEODClient client, VMEODPizzaPlayer player)
        {
            string msg = "";

            foreach (var item in player.Hand)
            {
                msg += ((item == null) ? "--" : item.ToString()) + "\n";
            }
            client.Send("pizza_hand", msg);
        }
Exemple #18
0
 protected override void OnConnected(VMEODClient client)
 {
     //Send current state to the user
     Persist.GetData().ContinueWith(x =>
     {
         if (!x.IsFaulted && x.Result != null)
         {
             client.Send("scoreboard_state", x.Result);
         }
     });
 }
 public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar != null)
     {
         client.Send("dance_show", "");
     }
     else
     {
         //we're the dance floor controller!
         ControllerClient = client;
     }
 }
Exemple #20
0
 internal FreeSOMazeCardinals GetTargetCardinal(AbstractMazeCell <FreeSOMazeData> source, AbstractMazeCell <FreeSOMazeData> target)
 {
     _Client.Send("FreeSOMaze_alert", "Server: source is: " + source.Row + " " + source.Column + " and target: " + target.Row + " " + target.Column);
     if (source?.North_Neighbor?.Equals(target) ?? false)
     {
         return(FreeSOMazeCardinals.North);
     }
     if (source?.East_Neighbor?.Equals(target) ?? false)
     {
         return(FreeSOMazeCardinals.East);
     }
     if (source?.West_Neighbor?.Equals(target) ?? false)
     {
         return(FreeSOMazeCardinals.West);
     }
     if (source?.South_Neighbor?.Equals(target) ?? false)
     {
         return(FreeSOMazeCardinals.South);
     }
     return(FreeSOMazeCardinals.Invalid);
 }
Exemple #21
0
 public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar != null)
     {
         client.Send("dance_show", "");
     }
     else
     {
         //we're the dance floor controller!
         ControllerClient = client;
     }
 }
 public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar == null)
     {
         //we're the controller!
         SendClientBulletinData(client);
     }
     else
     {
         var param = client.Invoker.Thread.TempRegisters;
         Mode = (VMEODSignsMode)param[0];
         client.Send("bulletin_show", (param[0]).ToString());
     }
 }
Exemple #23
0
 public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar != null)
     {
         PlayerClient = client;
         client.Send("dance_show", GroupID.ToString());
     }
     else
     {
         //we're the dance floor controller!
         ControllerClient = client;
         GroupID          = client.Invoker.GetValue(SimAntics.Model.VMStackObjectVariable.GroupID);
     }
 }
Exemple #24
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="client"></param>
 public override void OnConnection(VMEODClient client)
 {
     if (client.Avatar != null)
     {
         // get the temps, [0] == 1 is logic, 2 is charisma
         var args = client.Invoker.Thread.TempRegisters;
         if (args[0] == 1)
         {
             LogicPlayer = new FreeSOMazePlayer(client, client.Avatar.GetPersonData(SimAntics.Model.VMPersonDataVariable.LogicSkill) / 100m, true);
             client.Send("FreeSOMaze_show_l", BitConverter.GetBytes(client.Avatar.ObjectID));
         }
         else
         {
             CharismaPlayer = new FreeSOMazePlayer(client, client.Avatar.GetPersonData(SimAntics.Model.VMPersonDataVariable.CharismaSkill) / 100m, false);
             client.Send("FreeSOMaze_show_c", BitConverter.GetBytes(client.Avatar.ObjectID));
         }
         EnqueueGotoState(FreeSOMazeStates.Lobby);
         base.OnConnection(client);
     }
     else
     {
         Controller = client;
     }
 }
Exemple #25
0
 /// <summary>
 /// Execute a search for a new player to replace the specificed index.
 /// </summary>
 /// <param name="evt">Buzzer_Host_FindNewPlayer</param>
 /// <param name="playerIndex">0-3</param>
 /// <param name="host"></param>
 private void FindNewPlayerHandler(string evt, byte[] playerIndex, VMEODClient host)
 {
     if (!BuzzerEnabled)
     {
         var index = BitConverter.ToInt32(playerIndex, 0);
         if (index > -1 && index < 4)
         {
             lock (PlayerConfigLock)
                 FillContestantSpot(index, true);
         }
     }
     else
     {
         // buzzer enabled error
         host.Send("Buzzer_Host_Error", new byte[(byte)VMEODGameshowBuzzerPluginErrors.H_NoChangesAllowed]);
     }
 }
Exemple #26
0
 /// <summary>
 /// Enables or Disables one specfic player from buzzing in when the MasterBuzzer is enabled. This cannot be changed when the MasterBuzzer is enabled.
 /// </summary>
 /// <param name="evt">Buzzer_Host_ToggleEnablePlayer</param>
 /// <param name="data">1 if enabled, 0 if disabled</param>
 /// <param name="host"></param>
 private void ToggleEnablePlayerHandler(string evt, byte[] data, VMEODClient host)
 {
     lock (ConnectedContestants)
     {
         if (!BuzzerEnabled)
         {
             TogglePlayerBuzzer(BitConverter.ToInt32(data, 0));
         }
         else
         {
             // buzzer enabled error
             host.Send("Buzzer_Host_Error", new byte[(byte)VMEODGameshowBuzzerPluginErrors.H_NoChangesAllowed]);
         }
     }
     lock (PlayerConfigLock)
         SendContestantRoster();
 }
Exemple #27
0
        public override void OnConnection(VMEODClient client)
        {
            Client = client;
            var param = client.Invoker.Thread.TempRegisters;

            if (client.Avatar != null)
            {
                var rackType = param[0];
                if (!Lobby.Join(client, 0))
                {
                    return;
                }
                RackType = (RackType)rackType;
                client.Send("rack_show", ((short)RackType).ToString());
                BroadcastOutfits(client.vm, false);
            }
        }
        public override void OnConnection(VMEODClient client)
        {
            var param = client.Invoker.Thread.TempRegisters;

            if (client.Avatar != null)
            {
                //take tuning settings from object
                PhoneWaitSeconds               = param[1];
                ContributionTimeoutSeconds     = param[2];
                RestartDelaySeconds            = param[3];
                CardsPerSmallIngredient        = param[4];
                CardsPerMediumIngredient       = param[5];
                CardsPerLargeIngredient        = param[6];
                CardsPerBonusIngredientPerSize = param[7];

                //what part are we trying to join?
                var station = param[0];
                if (Players[station] != null)
                {
                    //what? someone's already here...
                    Server.Disconnect(client);
                }
                else
                {
                    client.Send("pizza_show", "");
                    Players[station] = client;
                    //if not initialized, set up this player with an empty hand
                    //otherwise inherit the last hand.
                    if (PizzaPlayers[station] == null)
                    {
                        PizzaPlayers[station] = new VMEODPizzaPlayer();
                    }
                    PlayerRosterUpdate();
                }
            }
            else
            {
                //we're the pizza controller!
                ControllerClient = client;
            }
        }
Exemple #29
0
        public override void OnConnection(VMEODClient client)
        {
            if (client.Avatar != null)
            {
                _Random      = new Random(DateTime.Now.Millisecond + client.Avatar.ObjectID);
                EODType      = VMEODGameshowBuzzerPluginType.Host;
                MyClient     = client;
                SessionStamp = ClientListRefreshedStamp = _Random.NextDouble();
                _BuzzerState = VMEODGameshowBuzzerStates.Disabled;
                _Options     = new VMEODGameshowBuzzerHostOptions();

                // subscribe to player connection events
                ClientConnect    += NewClientConnectedHandler;
                ClientDisconnect += ClientDisconnectedHandler;
                PlayerBuzzed     += PlayerBuzzedHandler;

                // find players already connected
                FillContestantSpots();

                client.Send("BuzzerEOD_Init", new byte[] { (byte)VMEODGameshowBuzzerPluginType.Host });
            }
            base.OnConnection(client);
        }
Exemple #30
0
 /// <summary>
 /// Move the player at the specified index to the right.
 /// </summary>
 /// <param name="evt">Buzzer_Host_MovePlayerRight</param>
 /// <param name="sourcePlayerIndex">0-2</param>
 /// <param name="host"></param>
 private void MovePlayerRightHandler(string evt, byte[] sourcePlayerIndex, VMEODClient host)
 {
     if (!BuzzerEnabled)
     {
         lock (PlayerConfigLock)
         {
             var sourceIndex = BitConverter.ToInt32(sourcePlayerIndex, 0);
             lock (ConnectedContestants)
             {
                 var targetIndex = sourceIndex + 1;
                 if (targetIndex > 3)
                 {
                     targetIndex = 0;
                 }
                 if (IsValidConnectedContestant(sourceIndex))
                 {
                     var sourcePlayer = ConnectedContestants[sourceIndex];
                     if (IsValidConnectedContestant(targetIndex))
                     {
                         ConnectedContestants[sourceIndex] = ConnectedContestants[targetIndex];
                     }
                     else
                     {
                         ConnectedContestants[sourceIndex] = null;
                     }
                     ConnectedContestants[targetIndex] = sourcePlayer;
                 }
                 SendContestantRoster();
             }
         }
     }
     else
     {
         // buzzer enabled error
         host.Send("Buzzer_Host_Error", new byte[(byte)VMEODGameshowBuzzerPluginErrors.H_NoChangesAllowed]);
     }
 }
        public override void OnConnection(VMEODClient client)
        {
            Client = client;
            var param = client.Invoker.Thread.TempRegisters;

            if (client.Avatar != null)
            {
                var rackType = param[0];
                if (!Lobby.Join(client, 0))
                {
                    return;
                }
                RackType = (RackType)rackType;
                client.Send("rack_show", ((short)RackType).ToString());
                if (((VMTSOObjectState)Server.Object.TSOState).OwnerID == client.Avatar.PersistID)
                {
                    BroadcastOutfits(client.vm, true);
                }
                else
                {
                    BroadcastOutfits(client.vm, false);
                }
            }
        }
 public void PlayerHandUpdate(VMEODClient client, VMEODPizzaPlayer player)
 {
     string msg = "";
     foreach (var item in player.Hand)
     {
         msg += ((item == null) ? "--" : item.ToString()) + "\n";
     }
     client.Send("pizza_hand", msg);
 }
        public override void OnConnection(VMEODClient client)
        {
            var param = client.Invoker.Thread.TempRegisters;
            if (client.Avatar != null)
            {
                //take tuning settings from object
                PhoneWaitSeconds = param[1];
                ContributionTimeoutSeconds = param[2];
                RestartDelaySeconds = param[3];
                CardsPerSmallIngredient = param[4];
                CardsPerMediumIngredient = param[5];
                CardsPerLargeIngredient = param[6];
                CardsPerBonusIngredientPerSize = param[7];

                //what part are we trying to join?
                var station = param[0];
                if (Players[station] != null)
                {
                    //what? someone's already here...
                    Server.Disconnect(client);
                }
                else
                {
                    client.Send("pizza_show", "");
                    Players[station] = client;
                    PizzaPlayers[station] = new VMEODPizzaPlayer();
                    PlayerRosterUpdate();
                }
            }
            else
            {
                //we're the pizza controller!
                ControllerClient = client;
            }
        }