Пример #1
0
        internal static string ToFlagsName(MegaloScriptDatabase db, MegaloScriptValueType flagsValueType, uint flags)
        {
            if (flags == 0)
            {
                return("0");
            }

            var e = db.Enums[flagsValueType.EnumIndex];

            ToFlagsNameValidateFlags(e, flags);

            var  sb         = new System.Text.StringBuilder();
            bool first_flag = true;

            for (int x = 0; x < e.Members.Count; x++)
            {
                if (!Bitwise.Flags.Test(flags, 1U << x))
                {
                    continue;
                }

                if (!first_flag)
                {
                    sb.Append(kFlagsSeperator);
                }

                sb.Append(e.Members[x]);
                first_flag = false;
            }

            return(sb.ToString());
        }
Пример #2
0
        internal static uint FromFlagsName(MegaloScriptDatabase db, MegaloScriptValueType flagsValueType, string names)
        {
            if (string.IsNullOrEmpty(names) || names == "0")
            {
                return(0);
            }

            var  e     = db.Enums[flagsValueType.EnumIndex];
            uint flags = 0;

            string[] parts = names.Split(kFlagsSeperator, StringSplitOptions.RemoveEmptyEntries);
            for (int x = 0; x < parts.Length; x++)
            {
                int bit;
                if (e.NameToIndex.TryGetValue(parts[x], out bit))
                {
                    flags |= 1U << bit;
                }
                else
                {
                    throw new KeyNotFoundException(string.Format("'{0}' is not a valid bit name in {1}",
                                                                 parts[x], e.Name));
                }
            }

            return(flags);
        }
Пример #3
0
        static void PostprocessMegaloDatabase(MegaloScriptDatabase db, MegaloStaticDatabase associatedStaticDb)
        {
            System.IO.TextWriter errorOutput = null;
            if (Blam.Program.RunningUnitTests || OutputMegaloDatabasePostprocessErrorTextToConsole)
            {
                errorOutput = Console.Out;
            }

            db.Postprocess(associatedStaticDb, errorOutput);
        }
Пример #4
0
        internal static string ToMemberName(MegaloScriptDatabase db, MegaloScriptValueType enumValueType, int index)
        {
            var e = db.Enums[enumValueType.EnumIndex];

            if (enumValueType.EnumTraits == Proto.MegaloScriptValueEnumTraits.HasNoneMember)
            {
                index += 1;
            }
            return(e.Members[index]);
        }
Пример #5
0
            public void Initialize(MegaloScriptDatabase db)
            {
                var player_ref_type = db.VariableRefTypes[MegaloScriptVariableReferenceType.Player];

                PlayerIndexObject = player_ref_type.NameToMember[kObject_PlayerVar_Name].ValueType;
                PlayerIndexPlayer = player_ref_type.NameToMember[kPlayer_PlayerVar_Name].ValueType;

                ObjectReferenceType = db.VariableRefTypes[MegaloScriptVariableReferenceType.Object];
                // #NOTE_BLAM: assumes Player.SlaveObject is the first reference type and everything after it are player variable SlaveObject references
                FirstSlaveObjectTypeIndex =
                    ObjectReferenceType.NameToMember[kPlayer_SlaveObject_Name].TypeIndex;
                HighestSlaveObjectTypeIndex = ObjectReferenceType.Members.Count - 1;
            }
Пример #6
0
        internal static int FromMemberName(MegaloScriptDatabase db, MegaloScriptValueType enumValueType, string name)
        {
            var e     = db.Enums[enumValueType.EnumIndex];
            int index = 0;

            if (e.NameToIndex.TryGetValue(name, out index))
            {
                return(enumValueType.EnumTraits != Proto.MegaloScriptValueEnumTraits.HasNoneMember ? index : index - 1);
            }
            else
            {
                throw new KeyNotFoundException(string.Format("'{0}' is not a valid member name in {1}",
                                                             name, e.Name));
            }
        }
Пример #7
0
        public void PrepareDatabasesForUse(MegaloStaticDatabase staticDb, MegaloScriptDatabase scriptDb)
        {
            if (staticDb == null)
            {
                throw new ArgumentNullException(nameof(staticDb));
            }
            if (scriptDb == null)
            {
                throw new ArgumentNullException(nameof(scriptDb));
            }
            if (scriptDb.StaticDatabase != null)
            {
                throw new ArgumentException("Script db already had a static db reference set", nameof(scriptDb));
            }

            PostprocessMegaloDatabase(scriptDb, staticDb);
        }
Пример #8
0
        internal void WriteForTryToPort <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
                                                        MegaloScriptDatabase db)
            where TDoc : class
            where TCursor : class
        {
            // #TODO_BLAM: change impl
            db = db == MegaloScriptDatabase.HaloReach
                                ? MegaloScriptDatabase.Halo4
                                : MegaloScriptDatabase.HaloReach;

            MegaloScriptProtoCondition other;

            if (db.TryGetCondition(Name, out other) && !other.Name.StartsWith("Cond"))
            {
                s.WriteAttribute("DBID", other.DBID);
                s.WriteAttribute("origDBID", DBID);
            }
        }
Пример #9
0
        internal void WriteForTryToPort <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
                                                        MegaloScriptDatabase db)
            where TDoc : class
            where TCursor : class
        {
            // #TODO_IMPLEMENT: change impl
            db = db == MegaloScriptDatabase.HaloReach
                                ? MegaloScriptDatabase.Halo4
                                : MegaloScriptDatabase.HaloReach;

            MegaloScriptProtoAction other;

            if (db.TryGetAction(Name, out other) && !other.Name.StartsWith("Action", System.StringComparison.Ordinal))
            {
                s.WriteAttribute("DBID", other.DBID);
                s.WriteAttribute("origDBID", DBID);
            }
        }
Пример #10
0
 internal void WriteExtraModelInfo <TDoc, TCursor>(MegaloScriptDatabase db, IO.TagElementStream <TDoc, TCursor, string> s,
                                                   bool multipleParameters, Model.MegaloScriptModelTagElementStreamFlags flags)
     where TDoc : class
     where TCursor : class
 {
     if ((flags & MegaloScriptModelTagElementStreamFlags.WriteParamKinds) != 0 && Kind > MegaloScriptParamType.Input)
     {
         s.WriteAttributeEnum(kKindAttributeName, Kind);
     }
     if ((flags & MegaloScriptModelTagElementStreamFlags.WriteParamSigIds) != 0 && multipleParameters)
     {
         s.WriteAttribute(kSigIdAttributeName, SigId);
     }
     if ((flags & MegaloScriptModelTagElementStreamFlags.WriteParamTypes) != 0)
     {
         s.WriteAttribute(kTypeAttributeName, db.ValueTypeNames[Type.NameIndex]);
     }
     if ((flags & MegaloScriptModelTagElementStreamFlags.WriteParamNames) != 0)
     {
         s.WriteAttribute(kNameAttirbuteName, Name);
     }
 }
Пример #11
0
 public FlagsNameResolvingContext(Proto.MegaloScriptDatabase db, MegaloScriptValueType valueType)
 {
     Db = db; ValueType = valueType;
 }
        static void SerializeValueType <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s,
                                                       MegaloScriptDatabase db, ref MegaloScriptValueType value)
            where TDoc : class
            where TCursor : class
        {
            bool reading = s.IsReading;

            var    base_type  = reading ? MegaloScriptValueBaseType.None : value.BaseType;
            string name       = reading ? null : db.ValueTypeNames[value.NameIndex];
            int    bit_length = reading ? 0 : value.BitLength;

            s.StreamAttributeEnum("baseType", ref base_type);
            s.StreamAttribute("name", ref name);
            bool has_bit_length = s.StreamAttributeOpt("bitLength", ref bit_length, Predicates.IsNotZero);

            int name_index = reading ? db.ValueTypeNames.Count : -1;

            if (reading)
            {
                db.ValueTypeNames.Add(name);
            }

            switch (base_type)
            {
                #region MegaloScriptValueBaseType.None
            case MegaloScriptValueBaseType.None:
                if (reading)
                {
                    Contract.Assert(name_index == 0, "There should only be one None value type and it should come first");
                    Contract.Assert(db.ValueTypeNames[name_index] == kNoValueTypeName, "None value type is using non-standard name");
                    value = new MegaloScriptValueType(name_index, base_type, 0);
                }
                break;

                #endregion
                #region MegaloScriptValueBaseType.Single
            case MegaloScriptValueBaseType.Single:
            {
                int encoding_index = reading ? 0 : value.EncodingIndex;

                s.StreamAttributeIdAsString("encoding", ref encoding_index, db,
                                            (_db, str) => _db.SingleEncodings.FindIndex((x) => str.Equals(x.Name)),
                                            (_db, id) => _db.SingleEncodings[id].Name);

                if (reading)                                 // #NOTE_BLAM: requires -1 when reading the TypeParam as the encoding index
                {
                    value = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)(encoding_index + 1));
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Point3d
            case MegaloScriptValueBaseType.Point3d:
            {
                if (!has_bit_length)
                {
                    throw new System.IO.InvalidDataException(string.Format("Point3d {0} didn't define a bit-length",
                                                                           name));
                }

                bool is_signed = reading ? false : value.PointIsSigned;
                s.StreamAttributeOpt("signed", ref is_signed, Predicates.IsTrue);

                if (reading)
                {
                    value = new MegaloScriptValueType(name_index, base_type, bit_length,
                                                      0, is_signed ? 1U : 0U);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Flags
            case MegaloScriptValueBaseType.Flags:
            {
                int enum_index = reading ? 0 : value.EnumIndex;
                MegaloScriptValueEnumTraits enum_traits = reading ? 0 : value.EnumTraits;

                db.SerializeEnumTypeReference(s, "enumType", ref enum_index);

                if (reading)
                {
                    if (!has_bit_length)
                    {
                        bit_length = db.Enums[enum_index].Members.Count;
                    }
                    value = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)enum_index);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Enum
            case MegaloScriptValueBaseType.Enum:
            {
                int enum_index = reading ? 0 : value.EnumIndex;
                MegaloScriptValueEnumTraits enum_traits = reading ? 0 : value.EnumTraits;

                db.SerializeEnumTypeReference(s, "enumType", ref enum_index);
                s.StreamAttributeEnumOpt("enumTraits", ref enum_traits, e => e != MegaloScriptValueEnumTraits.None);

                if (reading)
                {
                    if (!has_bit_length)
                    {
                        int max_value = db.Enums[enum_index].Members.Count;
                        if (enum_traits == MegaloScriptValueEnumTraits.HasNoneMember)
                        {
                            max_value++;
                        }
                        bit_length = Bits.GetMaxEnumBits(max_value);
                    }
                    value = new MegaloScriptValueType(name_index, bit_length, enum_index, enum_traits);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Index
            case MegaloScriptValueBaseType.Index:
            {
                MegaloScriptValueIndexTarget index        = reading ? MegaloScriptValueIndexTarget.Undefined : value.IndexTarget;
                MegaloScriptValueIndexTraits index_traits = reading ? 0 : value.IndexTraits;

                s.StreamAttributeEnum("indexTarget", ref index);
                s.StreamAttributeEnum("indexTraits", ref index_traits);

                if (reading)
                {
                    // #NOTE_BLAM: If we for whatever reason wrote the DB back out, types with implicit bit lengths
                    // would have that length written where they didn't before
                    if (!has_bit_length)
                    {
                        bit_length = db.Limits.GetIndexTargetBitLength(index, index_traits);
                    }
                    value = new MegaloScriptValueType(name_index, bit_length, index, index_traits);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Var
            case MegaloScriptValueBaseType.Var:
            {
                MegaloScriptVariableType var_type = reading ? 0 : value.VarType;
                MegaloScriptVariableSet  var_set  = reading ? 0 : value.VarSet;

                s.StreamAttributeEnum("varType", ref var_type);
                s.StreamAttributeEnum("varSet", ref var_set);

                if (reading)
                {
                    // #NOTE_BLAM: If we for whatever reason wrote the DB back out, types with implicit bit lengths
                    // would have that length written where they didn't before
                    if (!has_bit_length)
                    {
                        bit_length = db.GetVariableIndexBitLength(var_set, var_type);
                    }
                    value = new MegaloScriptValueType(name_index, bit_length, var_type, var_set);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.VarReference
            case MegaloScriptValueBaseType.VarReference:
            {
                MegaloScriptVarReferenceType var_ref = reading ? 0 : value.VarReference;

                s.StreamAttributeEnum("varReferenceType", ref var_ref);

                if (reading)
                {
                    value = new MegaloScriptValueType(name_index, var_ref);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.Tokens
            case MegaloScriptValueBaseType.Tokens:
            {
                int max_tokens = reading ? 0 : value.MaxTokens;

                s.StreamAttribute("maxTokens", ref max_tokens);

                if (reading)
                {
                    bit_length = Bits.GetMaxEnumBits(max_tokens + 1);
                    value      = new MegaloScriptValueType(name_index, base_type, bit_length, (uint)max_tokens);
                }
            } break;

                #endregion
                #region MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex
            case MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex:
            {
                if (reading)
                {
                    value = new MegaloScriptValueType(name_index, MegaloScriptVarReferenceType.Object,
                                                      MegaloScriptValueBaseType.ObjectReferenceWithPlayerVarIndex);
                }
            } break;

                #endregion
            default:
                if (reading)
                {
                    value = new MegaloScriptValueType(name_index, base_type, bit_length);
                }
                break;
            }
        }