Example #1
0
        public static string ToStr(this SerializableGameState info)
        {
            StringBuilder builder = new StringBuilder();

            builder.AppendLine(string.Format("SerializableGameState.ActorCounter={0}", info.ActorCounter));
            builder.AppendLine(string.Format("SerializableGameState.CheckUserOnJoin={0}", info.CheckUserOnJoin));
            builder.AppendLine(string.Format("SerializableGameState.DeleteCacheOnLeave={0}", info.DeleteCacheOnLeave));
            builder.AppendLine(string.Format("SerializableGameState.EmptyRoomTTL={0}", info.EmptyRoomTTL));
            builder.AppendLine(string.Format("SerializableGameState.IsOpen={0}", info.IsOpen));
            builder.AppendLine(string.Format("SerializableGameState.IsVisible={0}", info.IsVisible));
            builder.AppendLine(string.Format("SerializableGameState.LobbyId={0}", info.LobbyId));
            builder.AppendLine(string.Format("SerializableGameState.LobbyType={0}", info.LobbyType));
            builder.AppendLine(string.Format("SerializableGameState.MaxPlayers={0}", info.MaxPlayers));
            builder.AppendLine(string.Format("SerializableGameState.PlayerTTL={0}", info.PlayerTTL));
            builder.AppendLine(string.Format("SerializableGameState.PublishUserId={0}", info.PublishUserId));
            builder.AppendLine(string.Format("SerializableGameState.Slice={0}", info.Slice));
            builder.AppendLine(string.Format("SerializableGameState.SuppressRoomEvents={0}", info.SuppressRoomEvents));
            builder.AppendLine(info.ActorList.ToStr <SerializableActor>("SerializableGameState.ActorList", ToStr));
            builder.AppendLine(info.Binary.ToStr <string, object>("SerializableGameState.Binary"));
            builder.AppendLine(info.CustomProperties.ToStr <string, object>("SerializableGameState.CustomProperties"));
            builder.AppendLine(info.DebugInfo.ToStr <string, object>("SerializableGameState.DebugInfo"));
            builder.AppendLine(info.ExcludedActors.ToStr <ExcludedActorInfo>("SerializableGameState.ExcludedActors", ToStr));
            builder.AppendLine(info.ExpectedUsers.ToStr("SerializableGameState.ExpectedUsers"));
            builder.AppendLine(info.LobbyProperties.ToStr("SerializableGameState.LobbyProperties"));


            return(builder.ToString());
        }
        public bool SetState(SerializableGameState state)
        {
            this.ActorsManager.ActorNumberCounter = state.ActorCounter;
            if (state.ActorList != null)
            {
                this.ActorsManager.DeserializeActors(state.ActorList);
            }

            if (!this.SetGameStateUencodedBinaryPart(state.Binary))
            {
                return(false);
            }

            // - we now inlcude all properties in the binary state
            // - and decided it was confusing to loose type information
            // - so this filed is only for "Info" purposes
            // - only ignoring for now.

            if (state.EmptyRoomTTL != 0)
            {
                this.EmptyRoomLiveTime = state.EmptyRoomTTL;
            }

            this.IsOpen    = state.IsOpen;
            this.IsVisible = state.IsVisible;

            this.LobbyId   = state.LobbyId;
            this.LobbyType = (AppLobbyType)state.LobbyType;
            if (state.LobbyProperties != null)
            {
                this.LobbyProperties = new HashSet <object>(state.LobbyProperties.ToArray());
            }

            if (state.MaxPlayers != 0)
            {
                this.MaxPlayers = state.MaxPlayers;
            }

            if (state.PlayerTTL != 0)
            {
                this.PlayerTTL = state.PlayerTTL;
            }

            this.EventCache.Slice = state.Slice;

            this.RoomFlags = state.RoomFlags;
            this.Properties.DeleteNullProps = (this.RoomFlags & RoomOptionFlags.DeleteNullProps) != 0;
            this.Properties.Set((byte)GameParameter.MasterClientId, 0);

            this.ActorsManager.ExcludedActors = state.ExcludedActors ?? new List <ExcludedActorInfo>();
            this.ActorsManager.ExpectedUsers  = state.ExpectedUsers ?? new List <string>();
            if (state.ExpectedUsers != null && state.ExpectedUsers.Count > 0)
            {
                this.Properties.Set((byte)GameParameter.ExpectedUsers, state.ExpectedUsers.ToArray());
            }

            return(true);
        }
Example #3
0
        public SerializableGameState GetSerializableGameState()
        {
            const bool withDebugInfo = true;

            Dictionary <string, object> customProperties;
            ArrayList lobbyProperties;
            var       properties = PrepareProperties(out customProperties, out lobbyProperties);

            Dictionary <byte, ArrayList> actorGroups = null;
            int evCount;
            Dictionary <int, ArrayList> events;
            var binary = GetBinaryPartOfGameState(properties, ref actorGroups, out evCount, out events);

            var state = new SerializableGameState
            {
                ActorCounter       = this.ActorsManager.ActorNumberCounter,
                ActorList          = this.ActorsManager.SerializeActors(withDebugInfo),
                CheckUserOnJoin    = this.CheckUserOnJoin,
                CustomProperties   = customProperties,
                DeleteCacheOnLeave = this.DeleteCacheOnLeave,
                EmptyRoomTTL       = this.EmptyRoomLiveTime,
                IsOpen             = this.IsOpen,
                IsVisible          = this.IsVisible,
                LobbyId            = this.LobbyId,
                LobbyType          = (int)this.LobbyType,
                LobbyProperties    = lobbyProperties,
                MaxPlayers         = this.MaxPlayers,
                PlayerTTL          = this.PlayerTTL,
                SuppressRoomEvents = this.SuppressRoomEvents,
                Slice          = this.EventCache.Slice,
                Binary         = binary,
                ExcludedActors = this.actorsManager.ExcludedActors,
                ExpectedUsers  = this.ActorsManager.ExpectedUsers,
            };

            if (withDebugInfo)
            {
                state.DebugInfo = new Dictionary <string, object>();
                if (properties.Count > 0)
                {
                    state.DebugInfo.Add("DEBUG_PROPERTIES_18", properties);
                }
                if (evCount > 0)
                {
                    state.DebugInfo.Add("DEBUG_EVENTS_19", events);
                }
                if (actorGroups != null && actorGroups.Count > 0)
                {
                    state.DebugInfo.Add("DEBUG_GROUPS_20", actorGroups);
                }
            }

            return(state);
        }
Example #4
0
        private void WriteGameStateToFile(string name, SerializableGameState state)
        {
            var tempPath = System.IO.Path.GetTempPath();
            var fileName = System.IO.Path.Combine(tempPath, name + ".txt");
            var strState = JsonConvert.SerializeObject(state);

            // Append text to an existing file named "WriteLines.txt".
            using (var outputFile = new StreamWriter(fileName, false))
            {
                outputFile.WriteLine(strState);
                outputFile.Flush();
            }
        }
Example #5
0
        public bool SetState(Dictionary <string, object> state)
        {
            if (state.Keys.Contains("0"))
            {
                Log.ErrorFormat("Old style of serializaed data are used");
                return(false);
            }

            var serializedState = new SerializableGameState();

            foreach (var entry in state)
            {
                // TBD - improve performance using a Dictionary<String,YourEnum>,
                // see http://stackoverflow.com/questions/16100/how-do-i-convert-a-string-to-an-enum-in-c
                HiveHostGameState key;
                try
                {
                    key = (HiveHostGameState)Enum.Parse(typeof(HiveHostGameState), entry.Key, false);
                }
                catch (ArgumentException)
                {
                    continue;
                }

                switch (key)
                {
                case HiveHostGameState.ActorCounter:
//                        this.ActorsManager.ActorNumberCounter = (int)entry.Value;
                    serializedState.ActorCounter = (int)entry.Value;
                    break;

                case HiveHostGameState.ActorList:
                {
                    //var list = entry.Value as IList;
                    //this.ActorsManager.DeserializeActors(list);
                    var list = entry.Value as IList;

                    serializedState.ActorList = list.Cast <Dictionary <string, object> >().Select(d => d.ToSerializableActor()).ToList();
                }
                break;

                case HiveHostGameState.CustomProperties:
                    // TBD - we now inlcude all properties in the binary state
                    //     - and decided it was confusing to loose type information
                    //     - so this filed is only for "Info" purposes
                    //     - only ignoring for now.
                    // this.Properties.SetProperties((IDictionary)entry.Value);
                    break;

                case HiveHostGameState.CheckUserOnJoin:
                    //this.CheckUserOnJoin = (bool)entry.Value;
                    serializedState.CheckUserOnJoin = (bool)entry.Value;
                    break;

                case HiveHostGameState.DeleteCacheOnLeave:
                    //this.DeleteCacheOnLeave = (bool)entry.Value;
                    serializedState.DeleteCacheOnLeave = (bool)entry.Value;
                    break;

                case HiveHostGameState.EmptyRoomTTL:
//                        this.EmptyRoomLiveTime = (int)entry.Value;
                    serializedState.EmptyRoomTTL = (int)entry.Value;
                    break;

                case HiveHostGameState.IsOpen:
//                        this.IsOpen = (bool)entry.Value;
                    serializedState.IsOpen = (bool)entry.Value;
                    break;

                case HiveHostGameState.IsVisible:
                    //this.IsVisible = (bool)entry.Value;
                    serializedState.IsVisible = (bool)entry.Value;
                    break;

                case HiveHostGameState.LobbyId:
                    serializedState.LobbyId = (string)entry.Value;
//                        this.LobbyId = (string)entry.Value;
                    break;

                case HiveHostGameState.LobbyType:
                    serializedState.LobbyType = (int)(AppLobbyType)entry.Value;
//                        this.LobbyType = (AppLobbyType)entry.Value;
                    break;

                case HiveHostGameState.LobbyProperties:
                    //var lobbyProperties = entry.Value as ArrayList;
                    //if (lobbyProperties != null)
                    //{
                    //    this.LobbyProperties = new HashSet<object>((lobbyProperties).ToArray());
                    //}
                    serializedState.LobbyProperties = entry.Value as ArrayList;
                    break;

                case HiveHostGameState.MaxPlayers:
//                        this.MaxPlayers = Convert.ToByte(entry.Value);
                    serializedState.MaxPlayers = Convert.ToByte(entry.Value);
                    break;

                case HiveHostGameState.PlayerTTL:
//                        this.PlayerTTL = (int)entry.Value;
                    serializedState.PlayerTTL = (int)entry.Value;
                    break;

                case HiveHostGameState.SuppressRoomEvents:
//                        this.SuppressRoomEvents = (bool)entry.Value;
                    serializedState.SuppressRoomEvents = (bool)entry.Value;
                    break;

                case HiveHostGameState.Slice:
                    serializedState.Slice = (int)entry.Value;
//                        this.EventCache.Slice = (int)entry.Value;
                    break;

                case HiveHostGameState.Binary:
                    //var uencodedBinaryState = (Dictionary<string, object>)entry.Value;
                    //this.SetGameStateUencodedBinaryPart(uencodedBinaryState);
                    serializedState.Binary = (Dictionary <string, object>)entry.Value;
                    break;
                }
            }

            return(SetState(serializedState));
        }
 public bool SetGameState(SerializableGameState state)
 {
     return(this.host.SetGameState(state));
 }