Exemple #1
0
            internal FIELD(GffFieldType type, string label = "")
            {
                if (label.Length > MAX_LABEL_LENGTH)
                {
                    throw new Exception($"Label \"{label}\" is longer than {MAX_LABEL_LENGTH} characters, and is invalid.");
                }

                Type  = type;
                Label = label;
            }
        /// <summary>
        /// This method updates the cache and hak list properties in the module
        /// info, adding the passed array of strings to the appropriate property.
        /// Both of these lists consist of an array of structures with 1 string
        /// item in each struture.
        /// </summary>
        /// <param name="listTag">The property name for the list</param>
        /// <param name="entryTag">The property name for each string in the list's 
        /// structures</param>
        /// <param name="structID">The structure ID of the structures in the list</param>
        /// <param name="stringType">The data type of the string in the list, either
        /// ExoString or ResRef</param>
        /// <param name="values">The array of strings to add, duplicates are pruned</param>
        private void UpdateList(string listTag, string entryTag, uint structID, 
			GffFieldType stringType, string[] values)
        {
            // Get the array of elements in the list.
            GffListField listField = (GffListField) GetField(properties[listTag]);
            GffFieldCollection list = listField.Value;

            // Create a string collection containing lower case copies of all of
            // the strings.
            StringCollection strings = new StringCollection();
            strings.AddRange(values);
            for (int i = 0; i < strings.Count; i ++)
                strings[i] = strings[i].ToLower();

            // Make a first pass and eliminate any strings that are already
            // in the module.
            foreach (GffStructField field in list)
            {
                // Get the string entry for the value.
                GffFieldDictionary dict = field.Value;
                GffField structValue = dict[entryTag];

                // Check to see if the hak is in the list of haks to add if it is
                // then remove it.
                int index = strings.IndexOf((string) structValue.Value);
                if (-1 != index) strings.RemoveAt(index);
            }

            // Now loop through all of the remaining strings and add them to the
            // beginning of the list.  We walk the list backwards adding the items
            // to the beginning of the list's collection, so when we are done
            // all of the added items are in order at the FRONT of the list.
            for (int i = strings.Count - 1; i >= 0; i--)
            {
                // Create a ExoString field for the hak file name.
                GffField structValue = GffFieldFactory.CreateField(stringType);
                structValue.Value = strings[i];

                // Create a GffStructField for the new list element and
                // save the exoString hak name in it.
                GffStructField listStruct = (GffStructField)
                    GffFieldFactory.CreateField(GffFieldType.Struct);
                listStruct.StructureType = structID;
                listStruct.Value = new GffFieldDictionary();
                listStruct.Value.Add(entryTag, structValue);

                // Add the structure to the list.
                list.Insert(0, listStruct);
            }
        }
Exemple #3
0
            private static FIELD CreateNewField(BinaryReader br, int index, int fieldOffset, int dataOrDataOffset, GffFieldType fieldType)
            {
                FIELD data;

                switch (fieldType)
                {
                case GffFieldType.BYTE:
                    data = new BYTE(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.CHAR:
                    data = new CHAR(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.WORD:
                    data = new WORD(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.SHORT:
                    data = new SHORT(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.DWORD:
                    data = new DWORD(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.INT:
                    data = new INT(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.DWORD64:
                    data = new DWORD64(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.INT64:
                    data = new INT64(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.FLOAT:
                    data = new FLOAT(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.DOUBLE:
                    data = new DOUBLE(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.CExoString:
                    data = new CExoString(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.ResRef:
                    data = new ResRef(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.CExoLocString:
                    data = new CExoLocString(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.VOID:
                    data = new VOID(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.Struct:
                    int lbl_index = br.ReadInt32();
                    data = new STRUCT(br, br.ReadInt32(), lbl_index);
                    break;

                case GffFieldType.List:
                    data = new LIST(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.Orientation:
                    data = new Orientation(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.Vector:
                    data = new Vector(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                case GffFieldType.StrRef:
                    data = new StrRef(br, fieldOffset + dataOrDataOffset * 12);
                    break;

                default:
                    throw new Exception(string.Format("UNEXPECTED FIELD TYPE \"{0}\", IN STRUCT INDEX \"{1}\"", fieldType, index));
                }

                return(data);
            }
Exemple #4
0
            internal STRUCT(BinaryReader br, int index, int LabelIndex = -1)
                : base(GffFieldType.Struct)
            {
                //Header Info
                br.BaseStream.Seek(8, 0);
                int StructOffset       = br.ReadInt32();
                int StuctCount         = br.ReadInt32();
                int FieldOffset        = br.ReadInt32();
                int FieldCount         = br.ReadInt32();
                int LabelOffset        = br.ReadInt32();
                int LabelCount         = br.ReadInt32();
                int FieldDataOffset    = br.ReadInt32();
                int FieldDataCount     = br.ReadInt32();
                int FieldIndicesOffset = br.ReadInt32();

                //label logic
                if (LabelIndex < 0 || LabelIndex > LabelCount)
                {
                    Label = "";
                }
                else
                {
                    br.BaseStream.Seek(LabelOffset + LabelIndex * 16, 0);
                    Label = new string(br.ReadChars(16)).TrimEnd('\0');
                }

                //Struct Info
                br.BaseStream.Seek(StructOffset + index * 12, 0);
                Struct_Type = br.ReadInt32();
                int DataOrDataOffset = br.ReadInt32();
                int S_FieldCount     = br.ReadInt32();

                //If there is only one field, it pulls it from the field area
                if (S_FieldCount == 1)
                {
                    br.BaseStream.Seek(FieldOffset + DataOrDataOffset * 12, 0);
                    GffFieldType fieldType = (GffFieldType)br.ReadInt32();
                    FIELD        data      = CreateNewField(br, index, FieldOffset, DataOrDataOffset, fieldType);
                    Fields.Add(data);
                }
                //If there is more than one field, a set of Indices are read off, and then those fields are read in
                else if (S_FieldCount > 1)
                {
                    for (int i = 0; i < S_FieldCount; i++)
                    {
                        br.BaseStream.Seek(FieldIndicesOffset + DataOrDataOffset + 4 * i, 0);
                        int f_index = br.ReadInt32();

                        br.BaseStream.Seek(FieldOffset + f_index * 12, 0);
                        GffFieldType fieldType = (GffFieldType)br.ReadInt32();
                        FIELD        data      = CreateNewField(br, index, FieldOffset, f_index, fieldType);
                        Fields.Add(data);
                    }
                }
                else if (S_FieldCount == 0)
                {
                    return;
                }
                else
                {
                    throw new Exception(string.Format("BAD FIELD COUNT \"{0}\", IN STRUCT INDEX \"{1}\"", S_FieldCount, index));
                }
            }
Exemple #5
0
 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="type">Data type of the field</param>
 public RawGffField(GffFieldType type)
 {
     Type = (UInt32) type;
     LabelIndex = 0;
     DataOrDataOffset = 0;
 }
Exemple #6
0
        /// <summary>
        /// Class constructor
        /// </summary>
        /// <param name="uiName">Display name of the field</param>
        /// <param name="label">Tag of the field</param>
        /// <param name="type">Data type of the field</param>
        /// <param name="structureID">Structure ID of the field, only meaningful
        /// for lists and structures</param>
        /// <param name="children">Schema for the structure's child fields</param>
        public GffFieldSchema(string uiName, string tag, GffFieldType type,
			uint structID, GffSchemaCollection children)
        {
            this.uiName = uiName;
            this.tag = tag;
            this.type = type;
            this.structID = structID;
            this.children = children;
        }
Exemple #7
0
 /// <summary>
 /// Class constructor
 /// </summary>
 /// <param name="uiName">Display name of the field</param>
 /// <param name="label">Tag of the field</param>
 /// <param name="type">Data type of the field</param>
 public GffFieldSchema(string uiName, string tag, GffFieldType type)
     : this(uiName, tag, type, 0, null)
 {
 }
Exemple #8
0
 /// <summary>
 /// Creates a GffField derived object for the specified field type.
 /// </summary>
 /// <param name="type">The type of object to create</param>
 /// <returns>The created GffField derived object</returns>
 public static GffField CreateField(GffFieldType type)
 {
     switch (type)
     {
         case GffFieldType.Byte:
             return new GffByteField();
         case GffFieldType.Char:
             return new GffCharField();
         case GffFieldType.Word:
             return new GffWordField();
         case GffFieldType.Short:
             return new GffShortField();
         case GffFieldType.DWord:
             return new GffDWordField();
         case GffFieldType.Int:
             return new GffIntField();
         case GffFieldType.Float:
             return new GffFloatField();
         case GffFieldType.DWord64:
             return new GffDWord64Field();
         case GffFieldType.Int64:
             return new GffInt64Field();
         case GffFieldType.Double:
             return new GffDoubleField();
         case GffFieldType.ResRef:
             return new GffResRefField();
         case GffFieldType.ExoString:
             return new GffExoStringField();
         case GffFieldType.Void:
             return new GffVoidField();
         case GffFieldType.Struct:
             return new GffStructField();
         case GffFieldType.List:
             return new GffListField();
         case GffFieldType.ExoLocString:
             return new GffExoLocStringField();
         default:
             throw new NWNException("Unsupported data type");
     }
 }
Exemple #9
0
        /// <summary>
        /// Class constructor
        /// </summary>
        /// <param name="fieldType">The data type of the field.</param>
        /// <param name="fieldValue">The field's value</param>
        protected GffField(GffFieldType fieldType, object fieldValue)
        {
            // Make sure the derived class implements IGffSerialize
            if (!(this is IGffFieldSerialize)) throw new NWNException("Must implement IGffSerialize");

            this.fieldType = fieldType;
            this.fieldValue = fieldValue;
        }