Exemplo n.º 1
0
        private bool LoadUserGameStatsSchema()
        {
            string path;

            try
            {
                path = API.Steam.GetInstallPath();
                path = Path.Combine(path, "appcache");
                path = Path.Combine(path, "stats");
                path = Path.Combine(path, string.Format(
                                        CultureInfo.InvariantCulture,
                                        "UserGameStatsSchema_{0}.bin",
                                        this._GameId));

                if (File.Exists(path) == false)
                {
                    return(false);
                }
            }
            catch
            {
                return(false);
            }

            var kv = KeyValue.LoadAsBinary(path);

            if (kv == null)
            {
                return(false);
            }

            var currentLanguage = this._SteamClient.SteamApps008.GetCurrentGameLanguage();

            //var currentLanguage = "german";

            this._AchievementDefinitions.Clear();
            this._StatDefinitions.Clear();

            var stats = kv[this._GameId.ToString(CultureInfo.InvariantCulture)]["stats"];

            if (stats.Valid == false ||
                stats.Children == null)
            {
                return(false);
            }

            foreach (var stat in stats.Children)
            {
                if (stat.Valid == false)
                {
                    continue;
                }

                var rawType = stat["type_int"].Valid
                                  ? stat["type_int"].AsInteger(0)
                                  : stat["type"].AsInteger(0);
                var type = (APITypes.UserStatType)rawType;
                switch (type)
                {
                case APITypes.UserStatType.Invalid:
                {
                    break;
                }

                case APITypes.UserStatType.Integer:
                {
                    var    id   = stat["name"].AsString("");
                    string name = GetLocalizedString(stat["display"]["name"], currentLanguage, id);

                    this._StatDefinitions.Add(new Stats.IntegerStatDefinition()
                        {
                            Id            = stat["name"].AsString(""),
                            DisplayName   = name,
                            MinValue      = stat["min"].AsInteger(int.MinValue),
                            MaxValue      = stat["max"].AsInteger(int.MaxValue),
                            MaxChange     = stat["maxchange"].AsInteger(0),
                            IncrementOnly = stat["incrementonly"].AsBoolean(false),
                            DefaultValue  = stat["default"].AsInteger(0),
                            Permission    = stat["permission"].AsInteger(0),
                        });
                    break;
                }

                case APITypes.UserStatType.Float:
                case APITypes.UserStatType.AverageRate:
                {
                    var    id   = stat["name"].AsString("");
                    string name = GetLocalizedString(stat["display"]["name"], currentLanguage, id);

                    this._StatDefinitions.Add(new Stats.FloatStatDefinition()
                        {
                            Id            = stat["name"].AsString(""),
                            DisplayName   = name,
                            MinValue      = stat["min"].AsFloat(float.MinValue),
                            MaxValue      = stat["max"].AsFloat(float.MaxValue),
                            MaxChange     = stat["maxchange"].AsFloat(0.0f),
                            IncrementOnly = stat["incrementonly"].AsBoolean(false),
                            DefaultValue  = stat["default"].AsFloat(0.0f),
                            Permission    = stat["permission"].AsInteger(0),
                        });
                    break;
                }

                case APITypes.UserStatType.Achievements:
                case APITypes.UserStatType.GroupAchievements:
                {
                    if (stat.Children != null)
                    {
                        foreach (var bits in stat.Children.Where(
                                     b => string.Compare(b.Name, "bits", StringComparison.InvariantCultureIgnoreCase) == 0))
                        {
                            if (bits.Valid == false ||
                                bits.Children == null)
                            {
                                continue;
                            }

                            foreach (var bit in bits.Children)
                            {
                                string id   = bit["name"].AsString("");
                                string name = GetLocalizedString(bit["display"]["name"], currentLanguage, id);
                                string desc = GetLocalizedString(bit["display"]["desc"], currentLanguage, "");

                                this._AchievementDefinitions.Add(new Stats.AchievementDefinition()
                                    {
                                        Id          = id,
                                        Name        = name,
                                        Description = desc,
                                        IconNormal  = bit["display"]["icon"].AsString(""),
                                        IconLocked  = bit["display"]["icon_gray"].AsString(""),
                                        IsHidden    = bit["display"]["hidden"].AsBoolean(false),
                                        Permission  = bit["permission"].AsInteger(0),
                                    });
                            }
                        }
                    }

                    break;
                }

                default:
                {
                    throw new InvalidOperationException("invalid stat type");
                }
                }
            }

            return(true);
        }
        public bool ReadAsBinary(Stream input)
        {
            this.Children = new List <KeyValue>();

            try
            {
                while (true)
                {
                    var type = (KeyValueType)input.ReadValueU8();

                    if (type == KeyValueType.End)
                    {
                        break;
                    }

                    var current = new KeyValue
                    {
                        Type = type,
                        Name = input.ReadStringUnicode(),
                    };

                    switch (type)
                    {
                    case KeyValueType.None:
                    {
                        current.ReadAsBinary(input);
                        break;
                    }

                    case KeyValueType.String:
                    {
                        current.Valid = true;
                        current.Value = input.ReadStringUnicode();
                        break;
                    }

                    case KeyValueType.WideString:
                    {
                        throw new FormatException("wstring is unsupported");
                    }

                    case KeyValueType.Int32:
                    {
                        current.Valid = true;
                        current.Value = input.ReadValueS32();
                        break;
                    }

                    case KeyValueType.UInt64:
                    {
                        current.Valid = true;
                        current.Value = input.ReadValueU64();
                        break;
                    }

                    case KeyValueType.Float32:
                    {
                        current.Valid = true;
                        current.Value = input.ReadValueF32();
                        break;
                    }

                    case KeyValueType.Color:
                    {
                        current.Valid = true;
                        current.Value = input.ReadValueU32();
                        break;
                    }

                    case KeyValueType.Pointer:
                    {
                        current.Valid = true;
                        current.Value = input.ReadValueU32();
                        break;
                    }

                    default:
                    {
                        throw new FormatException();
                    }
                    }

                    if (input.Position >= input.Length)
                    {
                        throw new FormatException();
                    }

                    this.Children.Add(current);
                }

                this.Valid = true;
                return(input.Position == input.Length);
            }
            catch (Exception)
            {
                return(false);
            }
        }