Exemple #1
0
        private string unknown1; // [cnt1]

        #region IType Members

        public IType read(BinaryReader f)
        {
            cnt1     = f.ReadInt32();
            text1    = "";
            unknown1 = "";
            for (int i = 0; i < cnt1; i++)
            {
                text1 += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                if (i < cnt1 - 1)
                {
                    text1 += DatTool.DELIMITER;
                }

                byte[] temp = f.ReadBytes(2);
                unknown1 += BitConverter.ToString(temp);
                if (i < cnt1 - 1)
                {
                    unknown1 += DatTool.DELIMITER;
                }
            }
            cnt2  = f.ReadInt32();
            text2 = "";
            for (int i = 0; i < cnt2; i++)
            {
                text2 += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                if (i < cnt2 - 1)
                {
                    text2 += DatTool.DELIMITER;
                }
            }
            text3 += DatTool.ReadStringSimple_UnicodeInt32Length(f);

            return(this);
        }
        public IType read(BinaryReader f)
        {
            cnt    = f.ReadInt32();
            text   = "";
            values = "";

            for (int i = 0; i < cnt; i++)
            {
                text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                if (i < cnt - 1)
                {
                    text += DatTool.DELIMITER;
                }
            }

            for (int i = 0; i < cnt; i++)
            {
                values += f.ReadInt32().ToString();
                if (i < cnt - 1)
                {
                    values += DatTool.DELIMITER;
                }
            }
            return(this);
        }
        public IType write(BinaryWriter f)
        {
            string[] TmpStr = text.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt);
            for (int i = 0; i < cnt; i++)
            {
                DatTool.WriteString(f, TmpStr[i]);
            }

            return(this);
        }
        public IType write(BinaryWriter f)
        {
            string[] values = Value.Split(DatTool.DELIMITER);
            f.Write(Convert.ToInt32(values.Length));
            foreach (string parseS in values)
            {
                string[] v = parseS.Replace("(", "").Replace(")", "").Split(':');
                f.Write(Convert.ToInt32(v[0]));
                DatTool.WriteString(f, ConvertUtilities.replaceIn(v[1]));
            }

            return(this);
        }
        public IType read(BinaryReader f)
        {
            cnt  = f.ReadInt32();
            text = "";
            for (int i = 0; i < cnt; i++)
            {
                text += DatTool.ReadString(f);
                if (i < cnt - 1)
                {
                    text += DatTool.DELIMITER;
                }
            }

            return(this);
        }
        public IType read(BinaryReader f)
        {
            cntr = DatTool.ReadByteCount(f);
            text = "";
            for (int i = 0; i < cntr; i++)
            {
                text += f.ReadInt32().ToString();
                if (i < cntr - 1)
                {
                    text += DatTool.DELIMITER;
                }
            }

            text = ConvertUtilities.replaceOut(text);
            return(this);
        }
Exemple #7
0
        public IType write(BinaryWriter f)
        {
            string[] TmpStr = text1.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt1);
            for (int i = 0; i < cnt1; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
            }
            TmpStr = text2.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt2);
            for (int i = 0; i < cnt2; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
            }

            return(this);
        }
        public IType read(BinaryReader b)
        {
            int size = b.ReadInt32();

            for (int i = 0; i < size; i++)
            {
                int    id   = b.ReadInt32();
                String text = ConvertUtilities.replaceIn(DatTool.ReadString(b));
                Value += "(" + id + ":" + text + ")";
                if (i < size - 1)
                {
                    Value += DatTool.DELIMITER;
                }
            }

            return(this);
        }
        public void Compile(BinaryWriter f, List <Definition> infos)
        {
            writeCount(f, infos.Count);

            int total_records = infos.Count;

            MainForm.Instance.onStart(total_records);

            _log.Info("Total Count:" + total_records);

            for (int i = 0; i < total_records; i++)
            {
                CompileMain(f, infos, i);
                MainForm.Instance.setValue(i);
            }

            DatTool.WriteString(f, "SafePackage");
        }
        public IType write(BinaryWriter f)
        {
            string[] TmpStr    = text.Split(new[] { DatTool.DELIMITER });
            string[] TmpValues = values.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt);

            for (int i = 0; i < cnt; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
            }

            for (int i = 0; i < cnt; i++)
            {
                f.Write(int.Parse(TmpValues[i]));
            }

            return(this);
        }
        public IType write(BinaryWriter f)
        {
            text = ConvertUtilities.replaceIn(text);

            if (text.Length > 0)
            {
                string[] TmpStr = text.Split(new[] { DatTool.DELIMITER });
                DatTool.WriteByteCount(f, cntr);
                for (int i = 0; i < cntr; i++)
                {
                    f.Write(Convert.ToInt32(TmpStr[i]));
                }
            }
            else
            {
                DatTool.WriteByteCount(f, 0);
            }

            return(this);
        }
Exemple #12
0
        public IType write(BinaryWriter f)
        {
            string[] TmpStr  = text1.Split(new[] { DatTool.DELIMITER });
            string[] TmpStr2 = value1.Split(new[] { DatTool.DELIMITER });
            string[] TmpStr3 = unknown1.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt1);
            for (int i = 0; i < cnt1; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
                f.Write(TmpStr2[i]);
                f.Write(Convert.ToByte(TmpStr3[i], 16));
            }
            TmpStr = text2.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt2);
            for (int i = 0; i < cnt2; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
            }

            return(this);
        }
        public Definition ReadFieldValue(BinaryReader f, Definition info, String FName)
        {
            Definition TmpInfo = info;
            long       curPos  = f.BaseStream.Position;

            try
            {
                FieldInfo FType = MainForm.Instance.DatInfo.getDefinition().GetType().GetField(FName);

                Type field = FType.FieldType;

                if (FType.GetValue(info) == null)
                {
                    Object obj = field.InvokeMember(null, BindingFlags.CreateInstance, null, null, null);

                    if (obj is IType)
                    {
                        var type = (IType)obj;
                        FType.SetValue(info, type.read(f));
                    }
                    else
                    {
                        throw new NotImplementedException("Format " + obj.GetType().Name + " is not implement IType");
                    }
                }
                else
                {
                    FType.SetValue(info, ((IType)FType.GetValue(info)).read(f));
                }
            }
            catch (Exception ex)
            {
                TmpInfo.DumpFieldValues();
                ex = new ApplicationException(
                    String.Format("Error parsing string file (FieldName: {0} RecordOffset: 0x{1:X} DumpData: {2})",
                                  FName, f.BaseStream.Position, DatTool.Debug_DumpString(f, curPos, 8)), ex);
            }
            return(info);
        }
Exemple #14
0
        private string text2; // [cnt2]

        #region IType Members

        public IType read(BinaryReader f)
        {
            cnt1  = f.ReadInt32();
            text1 = "";
            for (int i = 0; i < cnt1; i++)
            {
                text1 += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                if (i < cnt1 - 1)
                {
                    text1 += DatTool.DELIMITER;
                }
            }
            cnt2  = f.ReadInt32();
            text2 = "";
            for (int i = 0; i < cnt2; i++)
            {
                text2 += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                if (i < cnt2 - 1)
                {
                    text2 += DatTool.DELIMITER;
                }
            }
            return(this);
        }
Exemple #15
0
        public IType write(BinaryWriter f)
        {
            string[] TmpStr  = text1.Split(new[] { DatTool.DELIMITER });
            string[] TmpStr2 = unknown1.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt1);
            for (int i = 0; i < cnt1; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
                string[] TmpStr3 = TmpStr2[i].Split(new[] { '-' });
                for (int j = 0; j < TmpStr3.Length; j++)
                {
                    f.Write(Convert.ToByte(TmpStr3[j], 16));
                }
            }
            TmpStr = text2.Split(new[] { DatTool.DELIMITER });
            f.Write(cnt2);
            for (int i = 0; i < cnt2; i++)
            {
                DatTool.WriteStringSimple_UnicodeInt32Length(f, TmpStr[i]);
            }
            DatTool.WriteStringSimple_UnicodeInt32Length(f, text3);

            return(this);
        }
Exemple #16
0
 public IType write(BinaryWriter f)
 {
     Text = ConvertUtilities.replaceIn(Text);
     DatTool.WriteString(f, Text);
     return(this);
 }
Exemple #17
0
 public IType read(BinaryReader b)
 {
     Text = DatTool.ReadString(b);
     Text = ConvertUtilities.replaceOut(Text);
     return(this);
 }
 public IType read(BinaryReader r)
 {
     Text = DatTool.ReadStringSimple_UnicodeInt32Length(r);
     Text = ConvertUtilities.replaceOut(Text);
     return(this);
 }
 public IType write(BinaryWriter f)
 {
     Text = ConvertUtilities.replaceIn(Text);
     DatTool.WriteStringSimple_UnicodeInt32Length(f, Text);
     return(this);
 }
Exemple #20
0
        public override Definition ParseMain(BinaryReader f, int RecNo)
        {
            var ret = new Definition();

            if (RConfig.Instance.DatVersionAsEnum >= DatVersion.Gracia_Plus__Epilogue)
            {
                var info  = new ChargrpInfo_Gracia_Plus();
                int count = 300;
                info.hair_tab = new UNICODE();
                for (int i = 0; i < count; i++)
                {
                    info.hair_tab.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < count - 1)
                    {
                        info.hair_tab.Text += ",";
                    }
                }
                info         = (ChargrpInfo_Gracia_Plus)base.ReadFieldValue(f, info, "face_mesh", "cnt_dmg");
                info.snd_att = new UNICODE();
                for (int i = 0; i < info.cnt_att.Value; i++)
                {
                    info.snd_att.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_att.Value - 1)
                    {
                        info.snd_att.Text += ",";
                    }
                }
                info.snd_def = new UNICODE();
                for (int i = 0; i < info.cnt_def.Value; i++)
                {
                    info.snd_def.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_def.Value - 1)
                    {
                        info.snd_def.Text += ",";
                    }
                }
                info.snd_dmg = new UNICODE();
                for (int i = 0; i < info.cnt_dmg.Value; i++)
                {
                    info.snd_dmg.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_dmg.Value - 1)
                    {
                        info.snd_dmg.Text += ",";
                    }
                }
                info = (ChargrpInfo_Gracia_Plus)base.ReadFieldValue(f, info, "voice_snd_hand", "p2");
                ret  = info;
            }
            else if (RConfig.Instance.DatVersionAsEnum >= DatVersion.Kamael)
            {
                var info = new ChargrpInfo_CT1();
                ret = info;
            }
            else
            {
                var info = new ChargrpInfo();
                info           = (ChargrpInfo)base.ReadFieldValue(f, info, "face_icon", "cnt_ft");
                info.hair_mesh = new UNICODE();
                for (int i = 0; i < info.cnt_hm.Value; i++)
                {
                    info.hair_mesh.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_hm.Value - 1)
                    {
                        info.hair_mesh.Text += ",";
                    }
                }
                info.hair_tex = new UNICODE();
                for (int i = 0; i < info.cnt_ht.Value; i++)
                {
                    info.hair_tex.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_ht.Value - 1)
                    {
                        info.hair_tex.Text += ",";
                    }
                }
                info.face_mesh = new UNICODE();
                for (int i = 0; i < info.cnt_fm.Value; i++)
                {
                    info.face_mesh.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_fm.Value - 1)
                    {
                        info.face_mesh.Text += ",";
                    }
                }
                info.face_tex = new UNICODE();
                for (int i = 0; i < info.cnt_ft.Value; i++)
                {
                    info.face_tex.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_ft.Value - 1)
                    {
                        info.face_tex.Text += ",";
                    }
                }
                info         = (ChargrpInfo)base.ReadFieldValue(f, info, "body_mesh1", "cnt_dmg");
                info.snd_att = new UNICODE();
                for (int i = 0; i < info.cnt_att.Value; i++)
                {
                    info.snd_att.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_att.Value - 1)
                    {
                        info.snd_att.Text += ",";
                    }
                }
                info.snd_def = new UNICODE();
                for (int i = 0; i < info.cnt_def.Value; i++)
                {
                    info.snd_def.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_def.Value - 1)
                    {
                        info.snd_def.Text += ",";
                    }
                }
                info.snd_dmg = new UNICODE();
                for (int i = 0; i < info.cnt_dmg.Value; i++)
                {
                    info.snd_dmg.Text += DatTool.ReadStringSimple_UnicodeInt32Length(f);
                    if (i < info.cnt_dmg.Value - 1)
                    {
                        info.snd_dmg.Text += ",";
                    }
                }
                info = (ChargrpInfo)base.ReadFieldValue(f, info, "voice_snd_hand", "voice_snd_fist");
                ret  = info;
            }
            return(ret);
        }