public static VAB Join(VH vh, SampleLine[] vb) { if (vh == null) { throw new ArgumentNullException("vh"); } if (vb == null) { throw new ArgumentNullException("vb"); } if (vh.VBSize != vb.Length) { ErrorManager.SignalIgnorableError("VAB: VB size field mismatch"); } SampleSet[] waves = new SampleSet [vh.Waves.Count]; int offset = 0; for (int i = 0; i < vh.Waves.Count; i++) { int wavelength = vh.Waves[i]; if (offset + wavelength > vb.Length) { ErrorManager.SignalError("VAB: Wave ends out of bounds"); } SampleLine[] wavelines = new SampleLine[wavelength]; for (int j = 0; j < wavelength; j++) { wavelines[j] = vb[offset + j]; } offset += wavelength; waves[i] = new SampleSet(wavelines); } return(new VAB(vh.IsOldVersion, vh.Volume, vh.Panning, vh.Attribute1, vh.Attribute2, vh.Programs, waves)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 2) { ErrorManager.SignalError("WavebankEntry: Wrong number of items"); } if (items[0].Length != 8) { ErrorManager.SignalError("WavebankEntry: First item length is wrong"); } int id = BitConv.FromInt32(items[0], 0); int length = BitConv.FromInt32(items[0], 4); if (id < 0 || id > 6) { ErrorManager.SignalIgnorableError("WavebankEntry: ID is invalid"); } if (length != items[1].Length) { ErrorManager.SignalIgnorableError("WavebankEntry: Length field mismatch"); } return(new WavebankEntry(id, SampleSet.Load(items[1]), eid)); }
public static T4Item Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length < 4) { ErrorManager.SignalError("T4Item: Data is too short"); } short count = BitConv.FromInt16(data, 0); short unknown1 = BitConv.FromInt16(data, 2); if (count < 0) { ErrorManager.SignalError("T4Item: Value count is negative"); } if (data.Length < 4 + 2 * count) { ErrorManager.SignalError("T4Item: Data is too short"); } short[] values = new short [count]; for (int i = 0; i < count; i++) { values[i] = BitConv.FromInt16(data, 4 + i * 2); } return(new T4Item(unknown1, values)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 2) { ErrorManager.SignalError("OldModelEntry: Wrong number of items"); } int polygoncount = BitConv.FromInt32(items[0], 0); if (items[1].Length != polygoncount * 8) { ErrorManager.SignalError("OldModelEntry: Polygon count mismatch"); } OldModelPolygon[] polygons = new OldModelPolygon [polygoncount]; for (int i = 0; i < polygoncount; i++) { byte[] polygondata = new byte [8]; Array.Copy(items[1], i * 8, polygondata, 0, polygondata.Length); polygons[i] = OldModelPolygon.Load(polygondata); } return(new OldModelEntry(items[0], polygons, eid)); }
public static SEQ Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } // All SEP/SEQ stuff is big-endian, like MIDI if (data.Length < 15) { ErrorManager.SignalError("SEQ: Data is too short"); } int magic = BEBitConv.FromInt32(data, 0); int version = BEBitConv.FromInt32(data, 4); if (magic != Magic) { ErrorManager.SignalIgnorableError("SEQ: Magic number is wrong"); } if (version != Version) { ErrorManager.SignalIgnorableError("SEQ: Version number is wrong"); } short resolution = BEBitConv.FromInt16(data, 8); int tempo = MIDIConv.From3BE(data, 10); short rhythm = BEBitConv.FromInt16(data, 13); byte[] scoredata = new byte [data.Length - 15]; Array.Copy(data, 15, scoredata, 0, scoredata.Length); return(new SEQ(resolution, tempo, rhythm, scoredata)); }
public override Entry Load(byte[][] items, int eid) { if (items.Length != 1) { ErrorManager.SignalError("DemoEntry: Wrong number of items"); } return(new DemoEntry(items[0], eid)); }
internal override void LoadToField(object obj, FieldInfo field) { if (field.FieldType == typeof(T?)) { if (rows.Count == 1) { if (rows[0].MetaValue == null) { if (rows[0].Values.Count == 1) { field.SetValue(obj, rows[0].Values[0]); } else { ErrorManager.SignalError("EntityProperty: Property has more values than expected"); } } else { ErrorManager.SignalError("EntityProperty: Property has an unexpected metavalue"); } } else { ErrorManager.SignalError("EntityProperty: Property has more rows than expected"); } } else if (field.FieldType == typeof(List <T>)) { if (rows.Count == 1) { if (rows[0].MetaValue == null) { List <T> list = new List <T>(); list.AddRange(rows[0].Values); field.SetValue(obj, list); } else { ErrorManager.SignalError("EntityProperty: Property has an unexpected metavalue"); } } else { ErrorManager.SignalError("EntityProperty: Property has more rows than expected"); } } else if (field.FieldType == GetType()) { field.SetValue(obj, this); } else { base.LoadToField(obj, field); } }
public sealed override Chunk Load(int chunkid, byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length != Chunk.Length) { throw new ArgumentException("Data must be 65536 bytes long."); } int id = BitConv.FromInt32(data, 4); int entrycount = BitConv.FromInt32(data, 8); int checksum = BitConv.FromInt32(data, 12); int headersize = 20 + entrycount * 4; if (id != chunkid) { ErrorManager.SignalIgnorableError("EntryChunk: Chunk id is incorrect"); } if (entrycount < 0) { ErrorManager.SignalError("EntryChunk: Entry count is negative"); } if (checksum != Chunk.CalculateChecksum(data)) { ErrorManager.SignalIgnorableError("Chunk: Checksum is wrong"); } if (headersize > data.Length) { ErrorManager.SignalError("EntryChunk: Data is too short"); } Entry[] entries = new Entry [entrycount]; byte[] entrydata; for (int i = 0; i < entrycount; i++) { int entrystart = BitConv.FromInt32(data, 16 + i * 4); int entryend = BitConv.FromInt32(data, 20 + i * 4); if (entrystart < 0) { ErrorManager.SignalError("EntryChunk: Entry begins out of bounds"); } if (entryend < entrystart) { ErrorManager.SignalError("EntryChunk: Entry ends before it begins"); } if (entryend > data.Length) { ErrorManager.SignalError("EntryChunk: Entry ends out of bounds"); } int entrysize = entryend - entrystart; entrydata = new byte [entrysize]; Array.Copy(data, entrystart, entrydata, 0, entrysize); entries[i] = Entry.Load(entrydata); } return(Load(entries)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 1) { ErrorManager.SignalError("SoundEntry: Wrong number of items"); } return(new SoundEntry(SampleSet.Load(items[0]), eid)); }
public Chunk Process(int chunkid) { if (loaders.ContainsKey(Type)) { return(loaders[Type].Load(chunkid, data)); } else { ErrorManager.SignalError("UnprocessedChunk: Unknown chunk type"); return(null); } }
public static UnprocessedEntry Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length < 16) { ErrorManager.SignalError("Entry: Data is too short"); } int magic = BitConv.FromInt32(data, 0); int eid = BitConv.FromInt32(data, 4); int type = BitConv.FromInt32(data, 8); int itemcount = BitConv.FromInt32(data, 12); if (magic != Magic) { ErrorManager.SignalIgnorableError("Entry: Magic number is wrong"); } if (itemcount < 0) { ErrorManager.SignalError("Entry: Item count is negative"); } if (data.Length < 20 + itemcount * 4) { ErrorManager.SignalError("Entry: Data is too short"); } byte[][] items = new byte [itemcount][]; byte[] itemdata; for (int i = 0; i < itemcount; i++) { int itemstart = BitConv.FromInt32(data, 16 + i * 4); int itemend = BitConv.FromInt32(data, 20 + i * 4); if (itemstart < 0) { ErrorManager.SignalError("Entry: Item begins out of bounds"); } if (itemend < itemstart) { ErrorManager.SignalError("Entry: Item ends before it begins"); } if (itemend > data.Length) { ErrorManager.SignalError("Entry: Item ends out of bounds"); } int itemsize = itemend - itemstart; itemdata = new byte [itemsize]; Array.Copy(data, itemstart, itemdata, 0, itemsize); items[i] = itemdata; } return(new UnprocessedEntry(items, eid, type)); }
public Entry Process(GameVersion gameversion) { Dictionary <int, EntryLoader> loaders = GetLoaders(gameversion); if (loaders.ContainsKey(type)) { return(loaders[type].Load(((List <byte[]>)Items).ToArray(), EID)); } else { ErrorManager.SignalError("UnprocessedEntry: Unknown entry type"); return(null); } }
internal override void LoadToField(object obj, FieldInfo field) { if (field.FieldType == typeof(EntityID?)) { if (Rows.Count == 1) { if (Rows[0].MetaValue == null) { if (Rows[0].Values.Count == 1) { field.SetValue(obj, new EntityID(Rows[0].Values[0])); } else { ErrorManager.SignalError("EntityProperty: Property has more values than expected"); } } else { ErrorManager.SignalError("EntityProperty: Property has an unexpected metavalue"); } } else if (Rows.Count == 2) { if (Rows[0].MetaValue == null && Rows[1].MetaValue == null) { if (Rows[0].Values.Count == 1 && Rows[1].Values.Count == 1) { field.SetValue(obj, new EntityID(Rows[0].Values[0], Rows[1].Values[0])); } else { ErrorManager.SignalError("EntityProperty: Property has more values than expected"); } } else { ErrorManager.SignalError("EntityProperty: Property has an unexpected metavalue"); } } else { ErrorManager.SignalError("EntityProperty: Property has more rows than expected"); } } else { base.LoadToField(obj, field); } }
public override Entry Load(byte[][] items, int eid) { if (items.Length < 2) { ErrorManager.SignalError("EntityEntry: Wrong number of items"); } byte[] unknown1 = items[0]; byte[] unknown2 = items[1]; Entity[] entities = new Entity [items.Length - 2]; for (int i = 2; i < items.Length; i++) { entities[i - 2] = Entity.Load(items[i]); } return(new EntityEntry(unknown1, unknown2, entities, eid)); }
public static NSD Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length < 1312) { ErrorManager.SignalError("NSD: Data is too short"); } int[] unknown1 = new int [256]; for (int i = 0; i < 256; i++) { unknown1[i] = BitConv.FromInt32(data, i * 4); } int chunkcount = BitConv.FromInt32(data, 1024); int entrycount = BitConv.FromInt32(data, 1028); int[] unknown2 = new int [70]; for (int i = 0; i < 70; i++) { unknown2[i] = BitConv.FromInt32(data, 1032 + i * 4); } if (chunkcount < 0) { ErrorManager.SignalError("NSD: Chunk count is negative"); } if (entrycount < 0) { ErrorManager.SignalError("NSD: Entry count is negative"); } if (data.Length < 1312 + 8 * entrycount) { ErrorManager.SignalError("NSD: Data is too short"); } NSDLink[] index = new NSDLink [entrycount]; for (int i = 0; i < entrycount; i++) { int chunkid = BitConv.FromInt32(data, 1312 + 8 * i); int entryid = BitConv.FromInt32(data, 1316 + 8 * i); index[i] = new NSDLink(chunkid, entryid); } int extralength = data.Length - (1312 + 8 * entrycount); byte[] extradata = new byte [extralength]; Array.Copy(data, 1312 + 8 * entrycount, extradata, 0, extralength); return(new NSD(unknown1, chunkcount, unknown2, index, extradata)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 3 && items.Length != 5 && items.Length != 6) { ErrorManager.SignalError("T11Entry: Wrong number of items"); } if (items[0].Length != 24) { ErrorManager.SignalError("T11Entry: First item length is wrong"); } return(new T11Entry(items, eid)); }
public static VHProgram Load(byte[] data, byte[] tonedata, bool isoldversion) { if (data.Length != 16) { throw new ArgumentException("Value must be 16 bytes long.", "data"); } if (tonedata.Length != 32 * 16) { throw new ArgumentException("Value must be 512 bytes long.", "tonedata"); } byte tonecount = data[0]; byte volume = data[1]; byte priority = data[2]; byte mode = data[3]; byte panning = data[4]; byte reserved1 = data[5]; short attribute = BitConv.FromInt16(data, 6); int reserved2 = BitConv.FromInt32(data, 8); int reserved3 = BitConv.FromInt32(data, 12); if (tonecount < 0 || tonecount > 16) { ErrorManager.SignalError("VHProgram: Tone count is wrong"); } if (reserved1 != (isoldversion ? 0x00 : 0xFF)) { ErrorManager.SignalIgnorableError("VHProgram: Reserved value 1 is wrong"); } if (reserved2 != -1) { ErrorManager.SignalIgnorableError("VHProgram: Reserved value 2 is wrong"); } if (reserved3 != -1) { ErrorManager.SignalIgnorableError("VHProgram: Reserved value 3 is wrong"); } VHTone[] tones = new VHTone [tonecount]; for (int i = 0; i < tonecount; i++) { byte[] thistonedata = new byte [32]; Array.Copy(tonedata, i * 32, thistonedata, 0, 32); tones[i] = VHTone.Load(thistonedata); } return(new VHProgram(isoldversion, volume, priority, mode, panning, attribute, tones)); }
public static OldFrame Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length < 56) { ErrorManager.SignalError("OldFrame: Data is too short"); } int vertexcount = BitConv.FromInt32(data, 0); if (vertexcount < 0 || vertexcount > Chunk.Length / 6) { ErrorManager.SignalError("OldFrame: Vertex count is invalid"); } if (data.Length < 56 + vertexcount * 6 + 2) { ErrorManager.SignalError("OldFrame: Data is too short"); } int modeleid = BitConv.FromInt32(data, 4); int xoffset = BitConv.FromInt32(data, 8); int yoffset = BitConv.FromInt32(data, 12); int zoffset = BitConv.FromInt32(data, 16); int x1 = BitConv.FromInt32(data, 20); int y1 = BitConv.FromInt32(data, 24); int z1 = BitConv.FromInt32(data, 28); int x2 = BitConv.FromInt32(data, 32); int y2 = BitConv.FromInt32(data, 36); int z2 = BitConv.FromInt32(data, 40); int xglobal = BitConv.FromInt32(data, 44); int yglobal = BitConv.FromInt32(data, 48); int zglobal = BitConv.FromInt32(data, 52); OldFrameVertex[] vertices = new OldFrameVertex [vertexcount]; for (int i = 0; i < vertexcount; i++) { byte[] vertexdata = new byte [6]; Array.Copy(data, 56 + i * 6, vertexdata, 0, vertexdata.Length); vertices[i] = OldFrameVertex.Load(vertexdata); } short unknown = BitConv.FromInt16(data, 56 + vertexcount * 6); return(new OldFrame(modeleid, xoffset, yoffset, zoffset, x1, y1, z1, x2, y2, z2, xglobal, yglobal, zglobal, vertices, unknown)); }
public static SampleSet Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } if (data.Length % 16 != 0) { ErrorManager.SignalError("SampleSet: Length is invalid"); } int samplelinecount = data.Length / 16; SampleLine[] samplelines = new SampleLine [samplelinecount]; for (int i = 0; i < samplelinecount; i++) { byte[] linedata = new byte [16]; Array.Copy(data, i * 16, linedata, 0, 16); samplelines[i] = SampleLine.Load(linedata); } return(new SampleSet(samplelines)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 3 && items.Length != 4) { ErrorManager.SignalError("OldSceneryEntry: Wrong number of items"); } if (items[1].Length % 8 != 0) { ErrorManager.SignalError("OldSceneryEntry: Second item (polygons) length is invalid"); } OldSceneryPolygon[] polygons = new OldSceneryPolygon [items[1].Length / 8]; for (int i = 0; i < polygons.Length; i++) { byte[] polygondata = new byte [8]; Array.Copy(items[1], i * 8, polygondata, 0, 8); polygons[i] = OldSceneryPolygon.Load(polygondata); } if (items[2].Length % 8 != 0) { ErrorManager.SignalError("OldSceneryEntry: Third item (vertices) length is invalid"); } OldSceneryVertex[] vertices = new OldSceneryVertex [items[2].Length / 8]; for (int i = 0; i < vertices.Length; i++) { byte[] vertexdata = new byte [8]; Array.Copy(items[2], i * 8, vertexdata, 0, 8); vertices[i] = OldSceneryVertex.Load(vertexdata); } byte[] extradata = null; if (items.Length >= 4) { extradata = items[3]; } return(new OldSceneryEntry(items[0], polygons, vertices, extradata, eid)); }
internal override void LoadToField(object obj, FieldInfo field) { if (field.FieldType == typeof(string)) { if (Rows.Count == 1) { if (Rows[0].MetaValue == null) { byte[] bytestr = new byte [Rows[0].Values.Count]; for (int i = 0; i < bytestr.Length; i++) { bytestr[i] = Rows[0].Values[i]; } string str = System.Text.Encoding.UTF8.GetString(bytestr); if (str.EndsWith("\0")) { str = str.Remove(str.Length - 1); } else { ErrorManager.SignalIgnorableError("EntityProperty: String is not null-terminated"); } field.SetValue(obj, str); } else { ErrorManager.SignalError("EntityProperty: Property has an unexpected metavalue"); } } else { ErrorManager.SignalError("EntityProperty: Property has more rows than expected"); } } else { base.LoadToField(obj, field); } }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 3) { ErrorManager.SignalError("MusicEntry: Wrong number of items"); } if (items[0].Length != 36) { ErrorManager.SignalError("MusicEntry: First item length is wrong"); } int seqcount = BitConv.FromInt32(items[0], 0); int vheid = BitConv.FromInt32(items[0], 4); int vb0eid = BitConv.FromInt32(items[0], 8); int vb1eid = BitConv.FromInt32(items[0], 12); int vb2eid = BitConv.FromInt32(items[0], 16); int vb3eid = BitConv.FromInt32(items[0], 20); int vb4eid = BitConv.FromInt32(items[0], 24); int vb5eid = BitConv.FromInt32(items[0], 28); int vb6eid = BitConv.FromInt32(items[0], 32); VH vh; if (items[1].Length != 0) { vh = VH.Load(items[1]); } else { vh = null; } SEP sep = SEP.Load(items[2], seqcount); return(new MusicEntry(vheid, vb0eid, vb1eid, vb2eid, vb3eid, vb4eid, vb5eid, vb6eid, vh, sep, eid)); }
public static SEP Load(byte[] data, int seqcount) { if (data == null) { throw new ArgumentNullException("data"); } if (seqcount < 0) { throw new ArgumentOutOfRangeException("seqcount"); } // All SEP/SEQ stuff is big-endian, like MIDI if (data.Length < 6) { ErrorManager.SignalError("SEP: Data is too short"); } int magic = BEBitConv.FromInt32(data, 0); short version = BEBitConv.FromInt16(data, 4); if (magic != Magic) { ErrorManager.SignalIgnorableError("SEP: Magic number is wrong"); } if (version != Version) { ErrorManager.SignalIgnorableError("SEP: Version number is wrong"); } int offset = 6; SEQ[] seqs = new SEQ [seqcount]; for (int i = 0; i < seqcount; i++) { if (data.Length < offset + 13) { ErrorManager.SignalError("SEP: Data is too short"); } short seqid = BEBitConv.FromInt16(data, offset); short resolution = BEBitConv.FromInt16(data, offset + 2); // tempo is 3 (yes, three) bytes int tempo = MIDIConv.From3BE(data, offset + 4); short rhythm = BEBitConv.FromInt16(data, offset + 7); int length = BEBitConv.FromInt32(data, offset + 9); if (seqid != i) { ErrorManager.SignalIgnorableError("SEP: Track number is wrong"); } if (length < 0) { ErrorManager.SignalError("SEP: Track length is negative"); } offset += 13; if (data.Length < offset + length) { ErrorManager.SignalError("SEP: Data is too short"); } byte[] seqdata = new byte [length]; Array.Copy(data, offset, seqdata, 0, length); seqs[i] = new SEQ(resolution, tempo, rhythm, seqdata); offset += length; } return(new SEP(seqs)); }
public sealed override EntityProperty Load(byte elementsize, short unknown, bool issparse, bool hasmetavalues, byte[] data) { if (elementsize != ElementSize) { ErrorManager.SignalError("EntityProperty: Element size is wrong"); } if (unknown < 0) { ErrorManager.SignalError("EntityProperty: Unknown value is invalid"); } List <EntityPropertyRow <T> > rows = new List <EntityPropertyRow <T> >(); for (int i = 0; i < unknown; i++) { rows.Add(new EntityPropertyRow <T>()); } int offset = 0; if (issparse) { if (offset + 2 * unknown > data.Length) { ErrorManager.SignalError("EntityProperty: Not enough data"); } foreach (EntityPropertyRow <T> row in rows) { int valuecount = (ushort)BitConv.FromInt16(data, offset); offset += 2; for (int i = 0; i < valuecount; i++) { row.Values.Add(new T()); } } } else { if (offset + 2 > data.Length) { ErrorManager.SignalError("EntityProperty: Not enough data"); } int valuecount = (ushort)BitConv.FromInt16(data, offset); offset += 2; foreach (EntityPropertyRow <T> row in rows) { for (int i = 0; i < valuecount; i++) { row.Values.Add(new T()); } } } if (hasmetavalues) { if (offset + 2 * unknown > data.Length) { ErrorManager.SignalError("EntityProperty: Not enough data"); } foreach (EntityPropertyRow <T> row in rows) { short metavalue = BitConv.FromInt16(data, offset); offset += 2; row.MetaValue = metavalue; } } Aligner.Align(ref offset, 4); byte[] elementdata = new byte [elementsize]; foreach (EntityPropertyRow <T> row in rows) { if (offset + row.Values.Count * elementsize > data.Length) { ErrorManager.SignalError("EntityProperty: Not enough data"); } for (int i = 0; i < row.Values.Count; i++) { Array.Copy(data, offset, elementdata, 0, elementsize); offset += elementsize; row.Values[i] = LoadElement(elementdata); } } Aligner.Align(ref offset, 4); if (offset != data.Length) { ErrorManager.SignalIgnorableError("EntityProperty: More data than expected"); } return(Load(rows)); }
public static Entity Load(byte[] data) { if (data.Length < 16) { ErrorManager.SignalError("Entity: Data is too short"); } int length = BitConv.FromInt32(data, 0); int blank1 = BitConv.FromInt32(data, 4); int blank2 = BitConv.FromInt32(data, 8); int propertycount = BitConv.FromInt32(data, 12); if (length != data.Length) { ErrorManager.SignalIgnorableError("Entity: Length field mismatch"); } if (blank1 != 0 || blank2 != 0) { ErrorManager.SignalIgnorableError("Entity: Blank value is wrong"); } if (propertycount < 0 || propertycount > ushort.MaxValue) { ErrorManager.SignalError("Entity: Property count is invalid"); } if (data.Length < 16 + propertycount * 8) { ErrorManager.SignalError("Entity: Data is too short"); } Dictionary <short, EntityProperty> properties = new Dictionary <short, EntityProperty>(); for (int i = 0; i < propertycount; i++) { short id = BitConv.FromInt16(data, 16 + i * 8); int offset = (ushort)BitConv.FromInt16(data, 18 + i * 8) + 12; int nextoffset = (i == propertycount - 1) ? data.Length : ((ushort)BitConv.FromInt16(data, 26 + i * 8) + 12); byte type = data[20 + i * 8]; byte elementsize = data[21 + i * 8]; short unknown = BitConv.FromInt16(data, 22 + i * 8); if (offset > data.Length) { ErrorManager.SignalError("Entity: Property begins out of bounds"); } if (nextoffset < offset) { ErrorManager.SignalError("Entity: Property ends before it begins"); } if (nextoffset > data.Length) { ErrorManager.SignalError("Entity: Property ends out of bounds"); } if (properties.ContainsKey(id)) { ErrorManager.SignalIgnorableError("Entity: Duplicate property"); } else { byte[] propertydata = new byte [nextoffset - offset]; Array.Copy(data, offset, propertydata, 0, propertydata.Length); EntityProperty property = EntityProperty.Load(type, elementsize, unknown, i == propertycount - 1, propertydata); properties.Add(id, property); } } return(new Entity(properties)); }
internal virtual void LoadToField(object obj, FieldInfo field) { ErrorManager.SignalError("EntityProperty: Type mismatch"); }
public static NSF Load(byte[] data) { if (data == null) { throw new ArgumentNullException("data"); } int offset = 0; int?firstid = null; List <UnprocessedChunk> prelude = null; List <Chunk> chunks = new List <Chunk>(); List <bool> preludecompression = null; List <bool> chunkcompression = new List <bool>(); while (offset < data.Length) { bool compressed; byte[] chunkdata = ReadChunk(data, ref offset, out compressed); UnprocessedChunk chunk = Chunk.Load(chunkdata); if (firstid == null) { firstid = chunk.ID; } else if (firstid == chunk.ID) { if (prelude != null) { ErrorManager.SignalError("NSF: Double prelude"); } prelude = new List <UnprocessedChunk>(); foreach (UnprocessedChunk unprocessedchunk in chunks) { prelude.Add(unprocessedchunk); } chunks.Clear(); preludecompression = chunkcompression; chunkcompression = new List <bool>(); } chunkcompression.Add(compressed); if (prelude != null && chunks.Count < prelude.Count) { for (int i = 0; i < Chunk.Length; i++) { if (prelude[chunks.Count].Data[i] != chunk.Data[i]) { ErrorManager.SignalIgnorableError("NSF: Prelude data mismatch"); break; } } } chunks.Add(chunk); } if (prelude != null && chunks.Count < prelude.Count) { ErrorManager.SignalIgnorableError("NSF: Prelude is longer than actual data"); } if (prelude != null) { ErrorManager.SignalIgnorableError("NSF: Prelude saving is not yet implemented"); } foreach (bool compressed in chunkcompression) { if (compressed) { ErrorManager.SignalIgnorableError("NSF: Non-prelude chunk was compressed"); } } return(new NSF(chunks)); }
public override Entry Load(byte[][] items, int eid) { if (items == null) { throw new ArgumentNullException("items"); } if (items.Length != 7) { ErrorManager.SignalError("SceneryEntry: Wrong number of items"); } if (items[0].Length != 76) { ErrorManager.SignalError("SceneryEntry: First item length is wrong"); } // TODO :: Get vertexcount from info int vertexcount = items[1].Length / 6; // TODO :: Check vertex list size SceneryVertex[] vertices = new SceneryVertex [vertexcount]; for (int i = 0; i < vertexcount; i++) { byte[] xydata = new byte [4]; byte[] zdata = new byte [2]; Array.Copy(items[1], (vertexcount - 1 - i) * 4, xydata, 0, xydata.Length); Array.Copy(items[1], vertexcount * 4 + i * 2, zdata, 0, zdata.Length); vertices[i] = SceneryVertex.Load(xydata, zdata); } // TODO :: Get trianglecount from info int trianglecount = items[2].Length / 6; // TODO :: Check triangle list size SceneryTriangle[] triangles = new SceneryTriangle [trianglecount]; for (int i = 0; i < trianglecount; i++) { byte[] adata = new byte [4]; byte[] bdata = new byte [2]; Array.Copy(items[2], (trianglecount - 1 - i) * 4, adata, 0, adata.Length); Array.Copy(items[2], trianglecount * 4 + i * 2, bdata, 0, bdata.Length); triangles[i] = SceneryTriangle.Load(adata, bdata); } // TODO :: Get quadcount from info int quadcount = items[3].Length / 8; // TODO :: Check quad list size SceneryQuad[] quads = new SceneryQuad [quadcount]; for (int i = 0; i < quadcount; i++) { byte[] quaddata = new byte [8]; Array.Copy(items[3], i * 8, quaddata, 0, quaddata.Length); quads[i] = SceneryQuad.Load(quaddata); } // TODO :: Get colorcount from info int colorcount = items[5].Length / 4; // TODO :: Check color list size SceneryColor[] colors = new SceneryColor [colorcount]; for (int i = 0; i < colorcount; i++) { byte red = items[5][i * 4]; byte green = items[5][i * 4 + 1]; byte blue = items[5][i * 4 + 2]; byte extra = items[5][i * 4 + 3]; colors[i] = new SceneryColor(red, green, blue, extra); } return(new SceneryEntry(items[0], vertices, triangles, quads, items[4], colors, items[6], eid)); }
private static byte[] ReadChunk(byte[] data, ref int offset, out bool compressed) { if (data == null) { throw new ArgumentNullException("data"); } if (offset < 0 || offset > data.Length) { throw new ArgumentOutOfRangeException("offset"); } if (data.Length < offset + 2) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } byte[] result = new byte [Chunk.Length]; short magic = BitConv.FromInt16(data, offset); if (magic == Chunk.Magic) { compressed = false; if (data.Length < offset + Chunk.Length) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } Array.Copy(data, offset, result, 0, Chunk.Length); offset += Chunk.Length; } else if (magic == Chunk.CompressedMagic) { compressed = true; int pos = 0; if (data.Length < offset + 12) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } short zero = BitConv.FromInt16(data, offset + 2); int length = BitConv.FromInt32(data, offset + 4); int skip = BitConv.FromInt32(data, offset + 8); if (zero != 0) { ErrorManager.SignalIgnorableError("NSF.ReadChunk: Zero value is wrong"); } if (length < 0 || length > Chunk.Length) { ErrorManager.SignalError("NSF.ReadChunk: Length field is invalid"); } if (skip < 0) { ErrorManager.SignalError("NSF.ReadChunk: Skip value is negative"); } offset += 12; while (pos < length) { if (data.Length < offset + 1) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } byte prefix = data[offset]; offset++; if ((prefix & 0x80) != 0) { prefix &= 0x7F; if (data.Length < offset + 1) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } int seek = data[offset]; offset++; int span = seek & 7; seek >>= 3; seek |= prefix << 5; if (span == 7) { span = 64; } else { span += 3; } if (pos - seek < 0) { ErrorManager.SignalError("NSF.ReadChunk: Repeat begins out of bounds"); } if (pos + span > Chunk.Length) { ErrorManager.SignalError("NSF.ReadChunk: Repeat ends out of bounds"); } // Do NOT use Array.Copy as // overlap is possible i.e. span // may be greater than seek for (int i = 0; i < span; i++) { result[pos + i] = result[pos - seek + i]; } pos += span; } else { if (data.Length < offset + prefix) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } Array.Copy(data, offset, result, pos, prefix); offset += prefix; pos += prefix; } } if (data.Length < offset + skip) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } offset += skip; if (data.Length < offset + (Chunk.Length - length)) { ErrorManager.SignalError("NSF.ReadChunk: Data is too short"); } Array.Copy(data, offset, result, pos, Chunk.Length - length); offset += (Chunk.Length - length); } else { compressed = false; // Fixes a stupid compile error ErrorManager.SignalError("NSF.ReadChunk: Unknown magic number"); } return(result); }
public static VH Load(byte[] data) { if (data.Length < 2592) { ErrorManager.SignalError("VH: Data is too short"); } int magic = BitConv.FromInt32(data, 0); int version = BitConv.FromInt32(data, 4); if (magic != Magic) { ErrorManager.SignalIgnorableError("VH: Magic number is wrong"); } bool isoldversion; if (version == Version) { isoldversion = false; } else if (version == OldVersion) { ErrorManager.SignalIgnorableError("VH: VABv6 (crash 1) is not fully supported"); isoldversion = true; } else { ErrorManager.SignalIgnorableError("VH: Version number is wrong"); isoldversion = true; } int id = BitConv.FromInt32(data, 8); int size = BitConv.FromInt32(data, 12); short reserved1 = BitConv.FromInt16(data, 16); short programcount = BitConv.FromInt16(data, 18); short tonecount = BitConv.FromInt16(data, 20); short wavecount = BitConv.FromInt16(data, 22); byte volume = data[24]; byte panning = data[25]; byte attribute1 = data[26]; byte attribute2 = data[27]; int reserved2 = BitConv.FromInt32(data, 28); if (id != 0) { ErrorManager.SignalIgnorableError("VH: ID is wrong"); } if (size < data.Length) { ErrorManager.SignalError("VH: Size field mismatch"); } if ((size - data.Length) % 16 != 0) { ErrorManager.SignalError("VH: Size field is invalid"); } int vbsize = (size - data.Length) / 16; if (reserved1 != -0x1112) { ErrorManager.SignalIgnorableError("VH: Reserved value 1 is wrong"); } if (programcount < 0 || programcount > 128) { ErrorManager.SignalError("VH: Program count is invalid"); } if (tonecount < 0 || tonecount > 2048) { ErrorManager.SignalError("VH: Tone count is invalid"); } if (wavecount < 0 || wavecount > 254) { ErrorManager.SignalError("VH: Wave count is invalid"); } if (reserved2 != -1) { ErrorManager.SignalIgnorableError("VH: Reserved value 2 is wrong"); } if (data.Length < 2592 + 32 * 16 * programcount) { ErrorManager.SignalError("VH: Data is too short"); } Dictionary <int, VHProgram> programs = new Dictionary <int, VHProgram>(); for (int i = 0; i < 128; i++) { byte[] programdata = new byte [16]; Array.Copy(data, 32 + 16 * i, programdata, 0, 16); if (programdata[0] == 0) { continue; } if (programs.Count == programcount) { ErrorManager.SignalError("VH: Program count field mismatch"); } byte[] tonedata = new byte [32 * 16]; Array.Copy(data, 32 + 16 * 128 + 32 * 16 * programs.Count, tonedata, 0, 32 * 16); programs.Add(i, VHProgram.Load(programdata, tonedata, isoldversion)); } if (programs.Count != programcount) { ErrorManager.SignalError("VH: Program count field mismatch"); } int[] waves = new int [wavecount]; for (int i = 0; i < wavecount; i++) { int wave = BitConv.FromInt16(data, 32 + 16 * 128 + 32 * 16 * programcount + 2 + i * 2); if (wave % 2 != 0) { ErrorManager.SignalError("VH: Wave size is invalid"); } waves[i] = wave / 2; } return(new VH(isoldversion, vbsize, volume, panning, attribute1, attribute2, programs, waves)); }