コード例 #1
0
ファイル: Analyzer.cs プロジェクト: Hashmi1/IndorilConverter
        public static void analyze2(string record)
        {
            ESM.open(Config.Paths.mw_esm);
            Log lg = new Log("explore.txt");

            while (ESM.find(record))
            {
                TES3.Record rec = new TES3.Record();
                rec.read();

                byte[] flgs = rec.find_first("BYDT").getData().ReadBytes(4);

                if (flgs[0] == 0 && flgs[3] == 0)
                {
                    string edid = rec.find_first("NAME").readString();
                    string rnam = rec.find_first("FNAM").readString();
                    string sex  = "";

                    if (BinaryFlag.isSet((int)flgs[2], (int)0x01))
                    {
                        sex = "Female";
                    }
                    else
                    {
                        sex = "Male";
                    }



                    lg.log(rnam + "," + sex + "," + edid);
                }
            }

            lg.show();
        }
コード例 #2
0
ファイル: Record.cs プロジェクト: Hashmi1/IndorilConverter
        public void write(BinaryWriter output)
        {
            Log.info("Writing RECORD: " + new string(type));

            // handle if compression set
            if (BinaryFlag.isSet(flags, 0x00040000))
            {
                MemoryStream mstream = new MemoryStream();
                BinaryWriter out2    = new BinaryWriter(mstream);


                for (int i = 0; i < fields.Count; i++)
                {
                    fields[i].write(out2);
                }

                mstream.Position = 0;

                byte[] uncompressed      = mstream.ToArray();
                int    uncompressed_size = uncompressed.Length;

                byte[] compressed_     = Ionic.Zlib.ZlibStream.CompressBuffer(uncompressed);
                int    compressed_size = compressed_.Length;

                dataSize = (uint)compressed_size + 4;

                output.Write(type);
                output.Write(dataSize);
                output.Write(flags);
                output.Write(id);
                output.Write(revision);
                output.Write(version);
                output.Write(unknown);

                output.Write(uncompressed_size);
                output.Write(compressed_);
                return;
            }



            // Non-Compressed case
            recalculate_size();

            output.Write(type);
            output.Write(dataSize);
            output.Write(flags);
            output.Write(id);
            output.Write(revision);
            output.Write(version);
            output.Write(unknown);

            for (int i = 0; i < fields.Count; i++)
            {
                fields[i].write(output);
            }
        }
コード例 #3
0
ファイル: LIGH.cs プロジェクト: Hashmi1/IndorilConverter
 private void read_flags()
 {
     Dynamic      = BinaryFlag.isSet(flags, (ushort)0x0001);
     Can_Carry    = BinaryFlag.isSet(flags, (ushort)0x0002);
     Negative     = BinaryFlag.isSet(flags, (ushort)0x0004);
     Flicker      = BinaryFlag.isSet(flags, (ushort)0x0008);
     Fire         = BinaryFlag.isSet(flags, (ushort)0x0010);
     Off_Default  = BinaryFlag.isSet(flags, (ushort)0x0020);
     Flicker_Slow = BinaryFlag.isSet(flags, (ushort)0x0040);
     Pulse        = BinaryFlag.isSet(flags, (ushort)0x0080);
     Pulse_Slow   = BinaryFlag.isSet(flags, (ushort)0x0100);
 }
コード例 #4
0
ファイル: NPC_.cs プロジェクト: Hashmi1/IndorilConverter
        public void read()
        {
            base.read();
            editor_id = find_first("NAME").readString().ToLower();
            game_name = find_first("FNAM").readString();
            race      = find_first("RNAM").readString();
            head      = find_first("BNAM").readString().ToLower();
            hair      = find_first("KNAM").readString().ToLower();

            faction = find_first("ANAM").readString();

            isFemale = BinaryFlag.isSet(find_first("FLAG").getData().ReadUInt32(), 0x0001);
            autoCalc = BinaryFlag.isSet(find_first("FLAG").getData().ReadUInt32(), 0x0010);
        }
コード例 #5
0
        private void search_group(TES5.Group grup)
        {
            if (grup.isType(TES5.Group.TYPE.TEMP_REFR))
            {
                UInt32 cell_form_id = Binary.toUInt32(grup.label);

                if (!formid_index.ContainsKey(cell_form_id))
                {
                    Log.error("Cell with formid: " + cell_form_id + " was not encountered");
                }

                string cell_id = formid_index[cell_form_id];

                put(cell_id, grup);

                return;
            }

            Queue <TES5.Group>  grps = new Queue <TES5.Group>(grup.subGroups);
            Queue <TES5.Record> recs = new Queue <TES5.Record>(grup.records);

            foreach (int t in grup.turn)
            {
                if (t == 1)
                {
                    TES5.Record r = recs.Dequeue();

                    #region if (r.isType("CELL"))

                    if (r.isType("CELL"))
                    {
                        TES5.Field DATA = r.try_find_field("DATA");

                        if (DATA == null)
                        {
                            continue;
                        }

                        if (DATA.data_size() < 2)
                        {
                            continue;
                        }

                        UInt16 flags = DATA.getData().ReadUInt16();

                        if (!BinaryFlag.isSet((UInt16)flags, (UInt16)0x0001))
                        {
                            continue;
                        }

                        TES5.Field EDID = r.try_find_field("EDID");

                        if (EDID != null)
                        {
                            BinaryReader reader  = EDID.getData();
                            string       cell_id = Text.trim(new string (reader.ReadChars(EDID.data_size())));
                            formid_index.Add(r.id, cell_id);
                        }
                    }
                    #endregion
                }

                if (t == 2)
                {
                    TES5.Group g = grps.Dequeue();
                    search_group(g);
                }
            }
        }
コード例 #6
0
        public static void presets()
        {
            string[] races = { "Breton",
                               "Dark Elf",
                               "High Elf",
                               "Imperial",
                               "Redguard",
                               "Wood Elf",
                               "Nord",
                               "Khajiit",
                               "Argonian",
                               "Orc" };

            string[] sexes = { "Female", "Male" };

            Dictionary <string, Dictionary <string, Queue <string> > > dict = new Dictionary <string, Dictionary <string, Queue <string> > >();

            foreach (string r in races)
            {
                Dictionary <string, Queue <string> > d = new Dictionary <string, Queue <string> >();

                dict.Add(r.Replace(" ", ""), d);

                foreach (string s in sexes)
                {
                    d.Add(s, new Queue <string>());
                }
            }

            TextReader fin = File.OpenText("tmp\\faces.csv");

            while (fin.Peek() != -1)
            {
                string   line   = fin.ReadLine();
                string[] parsed = line.Split(',');

                string race  = parsed[0];
                string sex   = parsed[1];
                string model = parsed[2].ToLower();

                dict[race.Replace(" ", "")][sex].Enqueue(model);
            }

            BinaryReader bw = new BinaryReader(new FileStream("tmp\\Skyrim.esm", FileMode.Open));

            TES5.Record head = new TES5.Record("TES4");

            head.read(bw);

            TES5.Group g = new TES5.Group();
            g.read(bw);

            while (!g.hasLabel("NPC_"))
            {
                Log.info("Reading: ");
                g.read(bw);
            }

            TES5.ESM esm = new TES5.ESM("faces.esp");
            esm.add_masters("Skyrim.esm");

            TES5.Group g_out = new TES5.Group("NPC_");

            foreach (TES5.Record r in g.records)
            {
                if (!r.isType("NPC_"))
                {
                    continue;
                }

                TES5.Field f = r.find_field_OR_FAIL("ACBS", "ACBS not found");

                UInt32 flagers = f.getData().ReadUInt32();

                if (BinaryFlag.isSet(flagers, 0x04))
                {
                    string edid = r.find_field_OR_FAIL("EDID", "").readString();
                    string sex  = "";
                    if (edid.Contains("Female"))
                    {
                        sex = "Female";
                    }
                    else if (edid.Contains("Male"))
                    {
                        sex = "Male";
                    }
                    else
                    {
                        Log.error("Can't be");
                    }

                    string race = edid.Split(new string[] { sex }, StringSplitOptions.None).First();

                    if (dict[race][sex].Count == 0)
                    {
                        continue;
                    }

                    string model = dict[race][sex].Dequeue();

                    Log.info(race);
                    Log.info(sex);
                    Log.info(r.find_field_OR_FAIL("EDID", "").readString());

                    TES5.Field full = r.try_find_field("FULL");

                    if (full == null)
                    {
                        full = new TES5.Field("FULL", Text.zstring(model));
                        r.fields.Insert(11, full);
                    }
                    else
                    {
                        full.replaceData(Text.zstring(model));
                    }

                    r.find_field_OR_FAIL("EDID", "").replaceData(Text.zstring(model));

                    TES5.Record new_rec = new TES5.Record("NPC_");
                    new_rec.clone(r, model);
                    new_rec.find_field_OR_FAIL("EDID", "").replaceData(Text.zstring(model));
                    g_out.addRecord(new_rec);
                }
            }


            esm.add_group(g_out);
            esm.write_to_file(Config.Paths.Templates.characters);
        }
コード例 #7
0
        public new void read(bool skip = false)
        {
            Name    = ESM.input.ReadChars(4);
            Size    = ESM.input.ReadInt32();
            Header1 = ESM.input.ReadInt32();
            Flags   = ESM.input.ReadInt32();

            if (!"CELL".Equals(new string(Name)))
            {
                Log.error("Error reading CELL, mismatch name");
            }

            int read_size = 0;

            while (read_size < Size)
            {
                SubRecord subrec = new SubRecord();
                subrec.read();
                read_size = read_size + subrec.size + 8;

                // Skipping over cell reference data for now
                if (subrec.isType("FRMR"))
                {
                    //Log.info("FRMR found");
                    REFR refr = new REFR();
                    read_size = read_size + refr.read(Size - read_size);
                    references.Add(refr);

                    continue;
                }

                subRecords.Add(subrec);
            }


            for (int i = 0; i < subRecords.Count; i++)
            {
                SubRecord    srec      = subRecords[i];
                BinaryReader srec_data = srec.getData();
                switch (new string(srec.name))
                {
                case ("NAME"):
                    if (srec.size > 1)
                    {
                        cell_name = new string(srec_data.ReadChars(srec.size));
                        cell_name = Text.trim(cell_name);
                    }
                    break;

                case ("RGNN"):
                    if (String.IsNullOrWhiteSpace(cell_name) || String.IsNullOrEmpty(cell_name.Trim()))
                    {
                        cell_name = new string(srec_data.ReadChars(srec.size));
                    }
                    break;

                case ("INTV"):
                    // water height is stored as a signed int, but the value
                    // corresponds to the float z-axis position of the water plane in the
                    // cell world
                    water_height = (float)srec_data.ReadInt32();

                    break;

                case ("AMBI"):
                    amb_col = srec_data.ReadBytes(4);
                    sun_col = srec_data.ReadBytes(4);
                    break;

                case ("DATA"):
                    data_flags = srec_data.ReadInt32();
                    grid_x     = srec_data.ReadInt32();
                    grid_y     = srec_data.ReadInt32();

                    interior = BinaryFlag.isSet(data_flags, (int)CELL_FLAGS.Interior);
                    HasWater = BinaryFlag.isSet(data_flags, (int)CELL_FLAGS.Water);
                    NoSleep  = BinaryFlag.isSet(data_flags, (int)CELL_FLAGS.NoSleep);

                    break;
                }
            }
        }
コード例 #8
0
ファイル: Record.cs プロジェクト: Hashmi1/IndorilConverter
 public bool flagSet(uint option)
 {
     return(BinaryFlag.isSet(flags, option));
 }
コード例 #9
0
ファイル: Record.cs プロジェクト: Hashmi1/IndorilConverter
        //long temp_store;

        public void read(BinaryReader input, bool unpack = true)
        {
            type     = input.ReadChars(4);
            dataSize = input.ReadUInt32();
            flags    = input.ReadUInt32();
            id       = input.ReadUInt32();
            revision = input.ReadUInt32();
            version  = input.ReadUInt16();
            unknown  = input.ReadUInt16();

            long reading_size = dataSize;

            if (Config.GeneralSettings.verbose)
            {
                Log.info("     Reading Record: " + new string(type) + " " + id.ToString("X") + " >>> " + uint.MaxValue.ToString("X"));
            }

            // If compressed flag is set then uncompress the data
            if (BinaryFlag.isSet(flags, 0x00040000))
            {
                this.compressed = true;
                UInt32 decompressed_size = input.ReadUInt32();
                byte[] compressed_data   = input.ReadBytes((int)dataSize - 4);

                //Log.infoX(compressed_data[0] + " " + compressed_data[1]);

                byte[] uncompressed_data = (Ionic.Zlib.ZlibStream.UncompressBuffer(compressed_data));

                //      temp_store = (int)dataSize;

                if (uncompressed_data.Length != decompressed_size)
                {
                    Log.error("Uncompressed Data was not of expected size: in Record.read()");
                }

                MemoryStream mstream = new MemoryStream();
                mstream.Write(uncompressed_data, 0, uncompressed_data.Length);
                mstream.Position = 0;

                //dataSize = (uint)uncompressed_data.Length;

                input = new BinaryReader(mstream);

                reading_size = uncompressed_data.Length;
            }



            if (!unpack)
            {
                Log.error("Not Implemented !unpack at Record.read()");
            }

            uint read_data = 0;

            while (read_data < reading_size)
            {
                Field field = new Field();
                field.read(input);
                fields.Add(field);

                if (field.isBig)
                {
                    read_data = read_data + (uint)field.data_size() + 6 + /*XXX size*/ +10;
                }
                else
                {
                    read_data = read_data + (uint)field.data_size() + 6;
                }
            }
        }