[Dev] Project Ace

[Supicioso]

I deleted my old thread to start this one.

Project Ace is a project I started on my site. It's the ace tool rewritten in C#, but made to be compatible with every version of ace. I still need a good GUI design, so If anyone is able to help me with that part, I'd be grateful.

A download of the latest revision will also become available on the home page.

Ideas are still welcome, if you have a request post it

You must be registered to see links

I also would hope to turn it into a repo site for future Open Source ace projects, like mine.

What's I've done so far.

2 different login options. Either by program, or database.

I'm currently working on the item system.

Site:

You must be registered to see links

 

[PanKJ]

namespace MainLib
{
    /// <summary>
    /// Coverts base data types to an array of bytes, and an array of bytes to base data types using the big-endian format.
    /// </summary>
    public static class Convert
    {
        public static byte[] GetBytes(short value)
        {
            return (byte[])BitConverter.GetBytes(value).Reverse<byte>();
        }
        public static byte[] GetBytes(int value)
        {
            return (byte[])BitConverter.GetBytes(value).Reverse<byte>();
        }
        public static byte[] GetBytes(float value)
        {
            return (byte[])BitConverter.GetBytes(value).Reverse<byte>();
        }
        public static byte[] GetBytes(string value, int length)
        {
            byte[] temp = (byte[])value.Cast<byte>();
            Array.Resize<byte>(ref temp, length);
            return temp;
        }
        public static short ToInt16(byte[] value)
        {
            return BitConverter.ToInt16((byte[])value.Reverse<byte>(), 0);
        }
        public static int ToInt32(byte[] value)
        {
            return BitConverter.ToInt32((byte[])value.Reverse<byte>(), 0);
        }
        public static float ToSingle(byte[] value)
        {
            return BitConverter.ToSingle((byte[])value.Reverse<byte>(), 0);
        }
        public static string ToString(byte[] value, int length)
        {
            return new string((char[])value.Cast<char>().Take<char>(length));
        }
    }
    public static class Tools
    {
        public static void PutBytes(byte[] destination, int index, short value)
        {
            Array.ConstrainedCopy(Convert.GetBytes(value), 0, destination, index, 2);
        }
        public static void PutBytes(byte[] destination, int index, int value)
        {
            Array.ConstrainedCopy(Convert.GetBytes(value), 0, destination, index, 4);
        }
        public static void PutBytes(byte[] destination, int index, float value)
        {
            Array.ConstrainedCopy(Convert.GetBytes(value), 0, destination, index, 4);
        }
        public static void PutBytes(byte[] destination, int index, string value, int length)
        {
            Array.ConstrainedCopy(Convert.GetBytes(value, length), 0, destination, index, 2);
        }
        public static short TakeInt16(byte[] source, int index)
        {
            byte[] temp = new byte[2];
            Array.ConstrainedCopy(source, index, temp, 0, 2);
            return Convert.ToInt16(temp);
        }
        public static int TakeInt32(byte[] source, int index)
        {
            byte[] temp = new byte[4];
            Array.ConstrainedCopy(source, index, temp, 0, 4);
            return Convert.ToInt32(temp);
        }
        public static float TakeSingle(byte[] source, int index)
        {
            byte[] temp = new byte[4];
            Array.ConstrainedCopy(source, index, temp, 0, 4);
            return Convert.ToSingle(temp);
        }
        public static string TakeString(byte[] source, int index, int length)
        {
            byte[] temp = new byte[length];
            Array.ConstrainedCopy(source, index, temp, 0, length);
            return Convert.ToString(temp, length);
        }
    }
}

namespace MainLib.StructuredBinaries
{
    public delegate void ObjSetDelegate(object value);
    public delegate void StrSetDelegate(string value);
    public delegate object ObjGetDelegate();
    public delegate string StrGetDelegate();


    public interface IFieldFormat
    {
        string Name { get; }
        int Index { get; }
        ObjSetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex);
        StrSetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex);
        ObjGetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex);
        StrGetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex);
    }

    public abstract class Bool8Field : IFieldFormat
    {
        public virtual string Name { get { return "A bool"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { data[YIndex][Index] = ((bool)value) ? (byte)1 : (byte)0; };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { data[YIndex][Index] = (bool.Parse(value)) ? (byte)1 : (byte)0; };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return (data[YIndex][Index] == 1) ? true : false; };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return (data[YIndex][Index] == 1) ? true.ToString() : false.ToString(); };
        }
    }
    public abstract class SInt8Field : IFieldFormat
    {
        public virtual string Name { get { return "A 8bit signed integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { data[YIndex][Index] = (byte)value; };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { data[YIndex][Index] = (byte)sbyte.Parse(value); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return data[YIndex][Index]; };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((sbyte)data[YIndex][Index]).ToString(); };
        }
    }
    public abstract class UInt8Field : IFieldFormat
    {
        public virtual string Name { get { return "A 8bit unsigned integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { data[YIndex][Index] = (byte)value; };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { data[YIndex][Index] = byte.Parse(value); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return data[YIndex][Index]; };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((byte)data[YIndex][Index]).ToString(); };
        }
    }
    public abstract class SInt16Field : IFieldFormat
    {
        public virtual string Name { get { return "A 16bit signed integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (short)value); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, short.Parse(value)); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return Tools.TakeInt16(data[YIndex], Index); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((short)Tools.TakeInt16(data[YIndex], Index)).ToString(); };
        }
    }
    public abstract class UInt16Field : IFieldFormat
    {
        public virtual string Name { get { return "A 16bit unsigned integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (ushort)value); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, ushort.Parse(value)); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return (ushort)Tools.TakeInt16(data[YIndex], Index); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((ushort)Tools.TakeInt16(data[YIndex], Index)).ToString(); };
        }
    }
    public abstract class SInt32Field : IFieldFormat
    {
        public virtual string Name { get { return "A 32bit signed integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (int)value); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, int.Parse(value)); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return Tools.TakeInt32(data[YIndex], Index); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((int)Tools.TakeInt32(data[YIndex], Index)).ToString(); };
        }
    }
    public abstract class UInt32Field : IFieldFormat
    {
        public virtual string Name { get { return "A 32bit unsigned integer"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (uint)value); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, uint.Parse(value)); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return (uint)Tools.TakeInt32(data[YIndex], Index); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((uint)Tools.TakeInt32(data[YIndex], Index)).ToString(); };
        }
    }
    public abstract class SingleField : IFieldFormat
    {
        public virtual string Name { get { return "A float"; } }
        public virtual int Index { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (float)value); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, float.Parse(value)); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return Tools.TakeSingle(data[YIndex], Index); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return ((float)Tools.TakeSingle(data[YIndex], Index)).ToString(); };
        }
    }
    public abstract class StringField : IFieldFormat
    {
        public virtual string Name { get { return "A fixed string"; } }
        public virtual int Index { get { return 0; } }
        public virtual int Size { get { return 0; } }
        public ObjSetDelegate GetObjSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(object value) { Tools.PutBytes(data[YIndex], Index, (string)value, Size); };
        }
        public StrSetDelegate GetStrSetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate(string value) { Tools.PutBytes(data[YIndex], Index, value, Size); };
        }
        public ObjGetDelegate GetObjGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return Tools.TakeString(data[YIndex], Index, Size); };
        }
        public StrGetDelegate GetStrGetDelegate(List<byte[]> data, int YIndex)
        {
            return delegate() { return Tools.TakeString(data[YIndex], Index, Size); };
        }
    }

    public interface ITableFormat
    {
        Table Parent { get; set; }
        string Name { get; }
        IFieldFormat[] Fields { get; }
        int RecordLength { get; }
    }

    public class Table
    {
        public List<byte[]> Data;
        public ITableFormat Format;
        public int XDimension
        {
            get
            {
                return Format.RecordLength;
            }
        }
        public int YDimension
        {
            get
            {
                return Data.Count;
            }
        }
        public int Size
        {
            get
            {
                return XDimension * YDimension;
            }
        }
        public byte[] Bytes
        {
            set
            {
                if ((value.Length % XDimension) != 0) throw new ArgumentException("Invalid data for the " + Format.Name + " table");
                byte[] temp = new byte[XDimension];
                Data = new List<byte[]>();
                for (int i = 0; i < (value.Length / XDimension); i++)
                {
                    Array.ConstrainedCopy(value, i * XDimension, temp, 0, XDimension);
                    Data.Add(temp);
                }
            }
            get
            {
                byte[] temp = new byte[XDimension * YDimension];
                for (int i = 0; i < YDimension; i++) Array.ConstrainedCopy(Data[i], 0, temp, i * XDimension, XDimension);
                return temp;
            }
        }
        public object this[int YIndex, int XIndex]
        {
            get
            {
                return Format.Fields[XIndex].GetObjSetDelegate(Data, YIndex)();
            }
            set
            {
                Format.Fields[XIndex].GetObjGetDelegate(Data, YIndex)(value);
            }
        }

        public Table(ITableFormat format)
        {
            Format = format;
        }
        public Table(ITableFormat format, byte[] data)
        {
            Format = format;
            Bytes = data;
        }
    }
}

namespace MainLib.StructuredBinaries.Omi.Ep33
{
    public class ItemsTable : ITableFormat
    {
        private class UniqueField : UInt32Field
        {
            public override string Name
            {
                get
                {
                    return "Unique Number";
                }
            }
            public override int Index
            {
                get
                {
                    return 0;
                }
            }
        }
        private class NameField : StringField
        {
            public override string Name
            {
                get
                {
                    return "Name";
                }
            }
            public override int Index
            {
                get
                {
                    return 5;
                }
            }
            public override int Size
            {
                get
                {
                    return 43;
                }
            }
        }
        public override Table Parent { get { return null; } }
        public override string Name { get { return "Items Table"; } }
        public static IFieldFormat[] Fields { get { return new IFieldFormat[] { new UniqueField(), new NameField() }; } }
        public override int RecordLength { get { return 456; } }
    }
}

I suppose this works. You can use it to read omi, if you understand what the code does. Theres not needed stuff because i used some generic libraries i have and becuse these namespaces will be used to do more things. Following the item table example you can define other table formats. Also theres plenty room for improvement, like making some methods static etc, so that memory is saved up. Btw, i tried to view threads/subforums in your forum but it says i dont have permission.

 

[Supicioso]

Yea, I fixed registration.

Thanks for the code. I'm working on a section for such things.

 

[Supicioso]

I finally got done Ducking around with the site, and after 2 days and countless OS reinstalls I have the site up and running.

You must be registered to see links

PanKJ and I both look over this site, and everything you need to know about what we're working on is there.

If you test out a program, post an issue or idea for us to look over. Mind you, none of this is done yet. We have a long way to go before it's complete.