public override void SerializeImpl(SerializerObject s)
{
Type = s.Serialize <byte>(Type, name: nameof(Type));
KeyLength = s.Serialize <int>(KeyLength, name: nameof(KeyLength));
Key = s.SerializeString(Key, KeyLength, Encoding.UTF8, name: nameof(Key));
switch ((char)Type)
{
case 'n':
IntValue = s.Serialize <int>(IntValue, name: nameof(IntValue));
break;
case 'f':
FloatValue = s.Serialize <float>(FloatValue, name: nameof(FloatValue));
break;
case 's':
StringValueLength = s.Serialize <int>(StringValueLength, name: nameof(StringValueLength));
StringValue = s.SerializeString(StringValue, StringValueLength, Encoding.UTF8, name: nameof(StringValue));
break;
default:
throw new BinarySerializableException(this, $"Unsupported data type {Type}");
}
}
public override void SerializeImpl(SerializerObject s)
{
FileID = s.Serialize <sbyte>(FileID, name: nameof(FileID));
ResourceID = s.Serialize <byte>(ResourceID, name: nameof(ResourceID));
Byte2 = s.Serialize <byte>(Byte2, name: nameof(Byte2));
Byte3 = s.Serialize <byte>(Byte3, name: nameof(Byte3));
}
} // TODO: What is this?
public override void SerializeImpl(SerializerObject s)
{
Unknown1Offset = s.Serialize <ushort>(Unknown1Offset, name: nameof(Unknown1Offset));
Unknown2Offset = s.Serialize <ushort>(Unknown2Offset, name: nameof(Unknown2Offset));
ActionsCount = s.Serialize <byte>(ActionsCount, name: nameof(ActionsCount));
Actions = s.SerializeObjectArray <GBC_Action>(Actions, ActionsCount, name: nameof(Actions));
s.DoAt(Offset + Unknown1Offset, () =>
{
Data1Offsets = s.SerializeArray <ushort>(Data1Offsets, ActionsCount, name: nameof(Data1Offsets));
if (ActionData1 == null)
{
ActionData1 = new GBC_ActionData1[ActionsCount];
}
for (int i = 0; i < Data1Offsets.Length; i++)
{
if (Data1Offsets[i] != 0)
{
ActionData1[i] = s.DoAt(Offset + Data1Offsets[i], () => s.SerializeObject <GBC_ActionData1>(ActionData1[i], name: $"{nameof(ActionData1)}[{i}]"));
}
}
});
s.Goto(Offset + Unknown2Offset);
ActionData2 = s.SerializeObjectArray <GBC_ActionData2>(ActionData2, ActionsCount, name: nameof(ActionData2));
}
public override void SerializeImpl(SerializerObject s)
{
ObjType = s.Serialize <GBAVV_Isometric_ObjType>(ObjType, name: nameof(ObjType));
ObjType_TimeTrial = s.Serialize <GBAVV_Isometric_ObjType>(ObjType_TimeTrial, name: nameof(ObjType_TimeTrial));
XPos = s.SerializeObject <FixedPointInt>(XPos, name: nameof(XPos));
YPos = s.SerializeObject <FixedPointInt>(YPos, name: nameof(YPos));
}
public override void SerializeBlock(SerializerObject s)
{
s.SerializeBitValues <byte>(bitFunc => {
IsObjAnimation = bitFunc(IsObjAnimation ? 1 : 0, 1, name: nameof(IsObjAnimation)) == 1;
Batman_Byte00 = (byte)bitFunc(Batman_Byte00, 7, name: nameof(Batman_Byte00));
});
Index_Palette = s.Serialize <byte>(Index_Palette, name: nameof(Index_Palette));
AnimationsCount = s.Serialize <byte>(AnimationsCount, name: nameof(AnimationsCount));
Index_TileSet = s.Serialize <byte>(Index_TileSet, name: nameof(Index_TileSet));
if (s.GameSettings.EngineVersion < EngineVersion.GBA_BatmanVengeance)
{
TilemapWidth = s.Serialize <byte>(TilemapWidth, name: nameof(TilemapWidth));
TilemapHeight = s.Serialize <byte>(TilemapHeight, name: nameof(TilemapHeight));
Padding = s.SerializeArray <byte>(Padding, 2, name: nameof(Padding));
}
var animOffsetsBase = s.CurrentPointer;
AnimationOffsets = s.SerializeArray <uint>(AnimationOffsets, AnimationsCount, name: nameof(AnimationOffsets));
if (Animations == null)
{
Animations = new GBA_BatmanVengeance_Animation[AnimationOffsets.Length];
}
BlockEndPointer = Offset + BlockSize;
for (int i = 0; i < AnimationOffsets.Length; i++)
{
Animations[i] = s.DoAt(animOffsetsBase + AnimationOffsets[i], () => s.SerializeObject <GBA_BatmanVengeance_Animation>(Animations[i], onPreSerialize: a => a.Puppet = this, name: $"{nameof(Animations)}[{i}]"));
}
s.Goto(Offset + BlockSize);
}
public override void SerializeImpl(SerializerObject s)
{
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
Collision = s.SerializeObjectArray <GBAIsometric_TileCollision>(Collision, Width * Height, name: nameof(Collision));
}
public override void SerializeImpl(SerializerObject s)
{
Index = s.Serialize <ushort>(Index, name: nameof(Index));
LocIndex = s.SerializeObject <GBAIsometric_LocIndex>(LocIndex, name: nameof(LocIndex));
Int_00 = s.Serialize <int>(Int_00, name: nameof(Int_00));
Data = s.SerializeArray <byte>(Data, 12, name: nameof(Data));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
TextureBlockChecksum = s.DoChecksum(new Checksum8Calculator(false), () =>
{
s.DoXOR((byte)(s.GameSettings.EngineVersion == EngineVersion.R1_PC || s.GameSettings.EngineVersion == EngineVersion.R1_PocketPC ? 0 : 0xFF), () =>
{
// Read the offset table for the textures, based from the start of the tile texture arrays
TexturesOffsetTable = s.SerializePointerArray(TexturesOffsetTable, 1200, s.CurrentPointer + 1200 * 4 + 3 * 4, name: nameof(TexturesOffsetTable));
// Read the textures count
TexturesCount = s.Serialize <uint>(TexturesCount, name: nameof(TexturesCount));
NonTransparentTexturesCount = s.Serialize <uint>(NonTransparentTexturesCount, name: nameof(NonTransparentTexturesCount));
TexturesDataTableCount = s.Serialize <uint>(TexturesDataTableCount, name: nameof(TexturesDataTableCount));
});
TexturesChecksum = s.DoChecksum(new Checksum8Calculator(), () =>
{
// Serialize the textures
NonTransparentTextures = s.SerializeObjectArray <R1_PC_TileTexture>(NonTransparentTextures, NonTransparentTexturesCount, name: nameof(NonTransparentTextures));
TransparentTextures = s.SerializeObjectArray <R1_PC_TransparentTileTexture>(TransparentTextures, TexturesCount - NonTransparentTexturesCount, name: nameof(TransparentTextures));
// Serialize the fourth unknown value
Unknown4 = s.SerializeArray <byte>(Unknown4, 32, name: nameof(Unknown4));
}, ChecksumPlacement.After, calculateChecksum: s.GameSettings.EngineVersion == EngineVersion.R1_PC || s.GameSettings.EngineVersion == EngineVersion.R1_PocketPC, name: nameof(TexturesChecksum));
}, ChecksumPlacement.Before, calculateChecksum: s.GameSettings.EngineVersion == EngineVersion.R1_PC_Kit || s.GameSettings.EngineVersion == EngineVersion.R1_PC_Edu, name: nameof(TextureBlockChecksum));
}
public override void SerializeBlock(SerializerObject s)
{
Width = s.Serialize <uint>(Width, name: nameof(Width));
Height = s.Serialize <uint>(Height, name: nameof(Height));
Speed = s.Serialize <uint>(Speed, name: nameof(Speed));
FrameCount = s.Serialize <uint>(FrameCount, name: nameof(FrameCount));
FrameOffsets = s.SerializeArray <uint>(FrameOffsets, FrameCount, name: nameof(FrameOffsets));
if (s.GameSettings.EngineVersion == EngineVersion.GBC_R1_PocketPC)
{
if (FrameDataPPC == null)
{
FrameDataPPC = new BGR565Color[FrameCount][];
}
for (int i = 0; i < FrameDataPPC.Length; i++)
{
uint decompressedSize = Width * Height * 2;
uint nextOff = i < FrameDataPPC.Length - 1 ? FrameOffsets[i + 1] : BlockSize;
uint compressedSize = nextOff - FrameOffsets[i];
s.DoAt(BlockStartPointer + FrameOffsets[i], () => {
s.DoEncoded(new Lzo1xEncoder(compressedSize, decompressedSize), () => {
FrameDataPPC[i] = s.SerializeObjectArray <BGR565Color>(FrameDataPPC[i], Width * Height, name: $"{nameof(FrameDataPPC)}[{i}]");
});
});
}
}
}
public override void SerializeImpl(SerializerObject s)
{
Palette = s.SerializeObjectArray <RGBA5551Color>(Palette, 256, name: nameof(Palette));
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
Frames = s.SerializeObjectArray <Frame>(Frames, FramesCount, x => x.TileMapLength = Width * Height, name: nameof(Frames));
}
public override void SerializeImpl(SerializerObject s)
{
BIG_gst = s.SerializeString(BIG_gst, 4, name: nameof(BIG_gst));
XORIfNecessary(s, () =>
{
Version = s.Serialize <uint>(Version, name: nameof(Version));
MaxFile = s.Serialize <uint>(MaxFile, name: nameof(MaxFile));
MaxDir = s.Serialize <uint>(MaxDir, name: nameof(MaxDir));
MaxKey = s.Serialize <uint>(MaxKey, name: nameof(MaxKey));
Root = s.Serialize <uint>(Root, name: nameof(Root));
FirstFreeFile = s.Serialize <int>(FirstFreeFile, name: nameof(FirstFreeFile));
FirstFreeDirectory = s.Serialize <int>(FirstFreeDirectory, name: nameof(FirstFreeDirectory));
SizeOfFat = s.Serialize <uint>(SizeOfFat, name: nameof(SizeOfFat));
NumFat = s.Serialize <uint>(NumFat, name: nameof(NumFat));
});
UniverseKey = s.Serialize <uint>(UniverseKey, name: nameof(UniverseKey));
if (Version >= 43)
{
throw new NotImplementedException("V43: Not implemented in RCP");
}
FatFilesOffset = s.CurrentAbsoluteOffset;
SerializeFatFiles(s);
foreach (var fat in FatFiles)
{
foreach (var f in fat.Files)
{
KeyToPos[f.Key] = f.FileOffset;
}
}
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
Unk1 = s.Serialize <uint>(Unk1, name: nameof(Unk1));
var unk2Length = 27;
// The PS1 version hard-codes a different length for this version
if (s.GameSettings.EngineVersion == EngineVersion.R1_PS1_Edu && s.GameSettings.EduVolume.StartsWith("CS"))
{
unk2Length = 29;
}
Unk2 = s.SerializeArray <byte>(Unk2, unk2Length, name: nameof(Unk2));
Unk3 = s.SerializeArray <byte>(Unk3, 3130, name: nameof(Unk3));
SampleNames = s.SerializeStringArray(SampleNames, 7, 9, name: nameof(SampleNames));
VignetteItemsCount = s.Serialize <byte>(VignetteItemsCount, name: nameof(VignetteItemsCount));
Unk5 = s.Serialize <uint>(Unk5, name: nameof(Unk5));
Unk6 = s.Serialize <uint>(Unk6, name: nameof(Unk6));
VignetteItems = s.SerializeObjectArray <R1_PCEdu_GeneralFileVignetteItem>(VignetteItems, VignetteItemsCount, name: nameof(VignetteItems));
CreditsStringItemsCount = s.Serialize <uint>(CreditsStringItemsCount, name: nameof(CreditsStringItemsCount));
CreditsStringItems = s.SerializeObjectArray <R1_PC_GeneralFileStringItem>(CreditsStringItems, CreditsStringItemsCount, name: nameof(CreditsStringItems));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
// Serialize data
if (s.GameSettings.EngineVersion == EngineVersion.R1_DSi)
{
DSi_Dword_00 = s.Serialize <uint>(DSi_Dword_00, name: nameof(DSi_Dword_00));
DSi_Dword_04 = s.Serialize <uint>(DSi_Dword_04, name: nameof(DSi_Dword_04));
}
ImageDataPointer = s.SerializePointer(ImageDataPointer, name: nameof(ImageDataPointer));
BlockIndicesPointer = s.SerializePointer(BlockIndicesPointer, name: nameof(BlockIndicesPointer));
PaletteIndicesPointer = s.SerializePointer(PaletteIndicesPointer, name: nameof(PaletteIndicesPointer));
PalettesPointer = s.SerializePointer(PalettesPointer, name: nameof(PalettesPointer));
Width = s.Serialize <ushort>(Width, name: nameof(Width));
Height = s.Serialize <ushort>(Height, name: nameof(Height));
UnkBytes_14 = s.SerializeArray <byte>(UnkBytes_14, 4, name: nameof(UnkBytes_14));
Pointer_18 = s.SerializePointer(Pointer_18, name: nameof(Pointer_18));
Pointer_1B = s.SerializePointer(Pointer_1B, name: nameof(Pointer_1B));
UnkBytes_20 = s.SerializeArray <byte>(UnkBytes_20, 4, name: nameof(UnkBytes_20));
if (s.GameSettings.EngineVersion == EngineVersion.R1_DSi)
{
DSi_Dword_2C = s.Serialize <uint>(DSi_Dword_2C, name: nameof(DSi_Dword_2C));
}
// Serialize data from pointers
SerializeVignette(s, s.GameSettings.EngineVersion == EngineVersion.R1_DSi);
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.GBA_IsMilan)
{
Milan_ActorID = s.SerializeString(Milan_ActorID, length: 4, name: nameof(Milan_ActorID));
s.SerializeArray <byte>(new byte[8], 8, name: "Padding");
}
else
{
if (s.GameSettings.EngineVersion > EngineVersion.GBA_BatmanVengeance)
{
UnkData = s.SerializeArray <byte>(UnkData, 8, name: nameof(UnkData));
}
Index_Puppet = s.Serialize <byte>(Index_Puppet, name: nameof(Index_Puppet));
Byte_09 = s.Serialize <byte>(Byte_09, name: nameof(Byte_09));
Byte_0A = s.Serialize <byte>(Byte_0A, name: nameof(Byte_0A));
Byte_0B = s.Serialize <byte>(Byte_0B, name: nameof(Byte_0B));
if (s.GameSettings.EngineVersion == EngineVersion.GBA_BatmanVengeance)
{
Actions = s.SerializeObjectArray <GBA_Action>(Actions, (BlockSize - 4) / 12, name: nameof(Actions));
}
else
{
Actions = s.SerializeObjectArray <GBA_Action>(Actions, (BlockSize - 12) / 8, name: nameof(Actions));
}
}
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.EngineVersion <= EngineVersion.GBA_BatmanVengeance && !s.GameSettings.GBA_IsMilan)
{
if (s.GameSettings.GBA_IsShanghai)
{
s.Goto(ShanghaiOffsetTable.GetPointer(0));
}
Length = s.Serialize <ushort>(Length, name: nameof(Length));
PalOffset = s.Serialize <ushort>(PalOffset, name: nameof(PalOffset));
if (s.GameSettings.GBA_IsShanghai)
{
s.Goto(ShanghaiOffsetTable.GetPointer(1));
}
Palette = s.SerializeObjectArray <RGBA5551Color>((RGBA5551Color[])Palette, Length, name: nameof(Palette));
}
else if (s.GameSettings.EngineVersion == EngineVersion.GBA_SplinterCell_NGage)
{
Palette = s.SerializeObjectArray <BGRA4441Color>((BGRA4441Color[])Palette, BlockSize / 2, name: nameof(Palette));
}
else
{
Palette = s.SerializeObjectArray <RGBA5551Color>((RGBA5551Color[])Palette, BlockSize / 2, name: nameof(Palette));
}
}
public override void SerializeImpl(SerializerObject s)
{
ObjectType = s.Serialize <ushort>(ObjectType, name: nameof(ObjectType));
SpawnerObjectType = s.Serialize <ushort>(SpawnerObjectType, name: nameof(SpawnerObjectType));
LevelID_0 = s.Serialize <byte>(LevelID_0, name: nameof(LevelID_0));
LevelID_1 = s.Serialize <byte>(LevelID_1, name: nameof(LevelID_1));
s.Serialize <ushort>(default, name: "Padding");
public override void SerializeImpl(SerializerObject s)
{
ID = s.Serialize <ushort>(ID, name: nameof(ID));
StartIndex = s.Serialize <ushort>(StartIndex, name: nameof(StartIndex));
NumEntries = s.Serialize <ushort>(NumEntries, name: nameof(NumEntries));
Padding = s.Serialize <ushort>(Padding, nameof(Padding));
}
public override void SerializeImpl(SerializerObject s)
{
ID = s.Serialize <uint>(ID, name: nameof(ID));
AnimationGroupIndex = s.Serialize <ushort>(AnimationGroupIndex, name: nameof(AnimationGroupIndex));
AnimSetIndex = s.Serialize <ushort>(AnimSetIndex, name: nameof(AnimSetIndex));
UnkBytes = s.SerializeArray <byte>(UnkBytes, 8, name: nameof(UnkBytes));
}
public override void SerializeImpl(SerializerObject s)
{
switch (TileCompression)
{
case Compression.RLE1:
s.DoEncoded(new RHR_RLETileEncoder(RHR_RLETileEncoder.RLEMode.RLE1), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.RLE2:
s.DoEncoded(new RHR_RLETileEncoder(RHR_RLETileEncoder.RLEMode.RLE2), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.BlockDiff:
BaseMapEntry = s.Serialize <ushort>(BaseMapEntry, name: nameof(BaseMapEntry));
Padding = s.Serialize <ushort>(Padding, name: nameof(Padding));
s.DoEncoded(new RHREncoder(RHREncoder.EncoderMode.TileData), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
case Compression.Block:
s.DoEncoded(new RHREncoder(RHREncoder.EncoderMode.TileData), () => {
TileIndices = s.SerializeArray <ushort>(TileIndices, 64, name: nameof(TileIndices));
});
break;
}
}
/// <summary>
/// Serializes the data
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
XPosition = s.Serialize <byte>(XPosition, name: nameof(XPosition));
YPosition = s.Serialize <byte>(YPosition, name: nameof(YPosition));
Width = s.Serialize <byte>(Width, name: nameof(Width));
Height = s.Serialize <byte>(Height, name: nameof(Height));
}
public override void SerializeImpl(SerializerObject s)
{
ObjectID = s.Serialize <byte>(ObjectID, name: nameof(ObjectID));
Byte1 = s.Serialize <byte>(Byte1, name: nameof(Byte1));
Byte2 = s.Serialize <byte>(Byte2, name: nameof(Byte2));
ResourceReferenceID = s.Serialize <sbyte>(ResourceReferenceID, name: nameof(ResourceReferenceID));
}
public override void SerializeImpl(SerializerObject s)
{
Header = s.Serialize <GBARRR_OffsetTableEntryHeader>(Header, name: nameof(Header));
BlockSize = s.Serialize <uint>(BlockSize, name: nameof(BlockSize));
BlockOffset = s.Serialize <uint>(BlockOffset, name: nameof(BlockOffset));
s.Serialize <uint>(0, name: "Padding");
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
AnimLayersPointer = s.Serialize <uint>(AnimLayersPointer, name: nameof(AnimLayersPointer));
AnimFramesPointer = s.Serialize <uint>(AnimFramesPointer, name: nameof(AnimFramesPointer));
LayersPerFrame = s.Serialize <ushort>(LayersPerFrame, name: nameof(LayersPerFrame));
FrameCount = s.Serialize <ushort>(FrameCount, name: nameof(FrameCount));
}
public override void SerializeImpl(SerializerObject s)
{
if (s.GameSettings.GBA_IsMilan)
{
FrameCount = s.Serialize <ushort>((ushort)FrameCount, name: nameof(FrameCount));
Milan_Ushort_02 = s.Serialize <ushort>(Milan_Ushort_02, name: nameof(Milan_Ushort_02));
Milan_Bytes_04 = s.SerializeArray <byte>(Milan_Bytes_04, 8, name: nameof(Milan_Bytes_04));
}
else
{
FrameCount = s.Serialize <uint>(FrameCount, name: nameof(FrameCount));
}
var baseOffset = s.CurrentPointer;
FrameOffsets = s.SerializeArray <uint>(FrameOffsets, FrameCount, name: nameof(FrameOffsets));
if (Frames == null)
{
Frames = new GBA_BatmanVengeance_AnimationFrame[FrameCount];
}
for (int i = 0; i < FrameOffsets.Length; i++)
{
Frames[i] = s.DoAt(baseOffset + FrameOffsets[i], () => s.SerializeObject <GBA_BatmanVengeance_AnimationFrame>(Frames[i], onPreSerialize: f => f.Puppet = Puppet, name: $"{nameof(Frames)}[{i}]"));
}
}
public override void SerializeImpl(SerializerObject s)
{
Ushort_00 = s.Serialize <ushort>(Ushort_00, name: nameof(Ushort_00));
FrameIndex = s.Serialize <ushort>(FrameIndex, name: nameof(FrameIndex));
FramesCount = s.Serialize <ushort>(FramesCount, name: nameof(FramesCount));
Bytes_06 = s.SerializeArray <byte>(Bytes_06, 6, name: nameof(Bytes_06));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
FileOffset = s.Serialize <uint>(FileOffset, name: nameof(FileOffset));
FileSize = s.Serialize <uint>(FileSize, name: nameof(FileSize));
Unk1 = s.Serialize <uint>(Unk1, name: nameof(Unk1));
Unk2 = s.Serialize <uint>(Unk2, name: nameof(Unk2));
}
public override void SerializeImpl(SerializerObject s)
{
ObjType = s.Serialize <short>(ObjType, name: nameof(ObjType));
XPos = s.Serialize <short>(XPos, name: nameof(XPos));
YPos = s.Serialize <short>(YPos, name: nameof(YPos));
ObjParamsIndex = s.Serialize <ushort>(ObjParamsIndex, name: nameof(ObjParamsIndex));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
// Serialize font data
FontData = s.SerializeObject <R1_PS1_FontData>(FontData, name: nameof(FontData));
// Serialize fixed Rayman event
RaymanEvent = s.SerializeObject <R1_EventData>(RaymanEvent, name: nameof(RaymanEvent));
// Serialize event information
EventsPointer = s.SerializePointer(EventsPointer, name: nameof(EventsPointer));
if (s.GameSettings.EngineVersion == EngineVersion.R1_PS1_JPDemoVol3)
{
UnknownEventTablePointer = s.SerializePointer(UnknownEventTablePointer, name: nameof(UnknownEventTablePointer));
}
EventCount = s.Serialize <uint>(EventCount, name: nameof(EventCount));
EventLinkTablePointer = s.SerializePointer(EventLinkTablePointer, name: nameof(EventLinkTablePointer));
EvenLinkCount = s.Serialize <uint>(EvenLinkCount, name: nameof(EvenLinkCount));
// Serialize data from pointers
s.DoAt(EventsPointer, () => Events = s.SerializeObjectArray <R1_EventData>(Events, EventCount, name: nameof(Events)));
if (UnknownEventTablePointer != null)
{
s.DoAt(UnknownEventTablePointer, () => UnknownEventTable = s.SerializeObjectArray <R1_PS1JPDemoVol3_UnknownEventTableItem>(UnknownEventTable, EventCount, name: nameof(UnknownEventTable)));
}
s.DoAt(EventLinkTablePointer, () => EventLinkTable = s.SerializeArray <byte>(EventLinkTable, EvenLinkCount, name: nameof(EventLinkTable)));
}
/// <summary>
/// Handles the data serialization
/// </summary>
/// <param name="s">The serializer object</param>
public override void SerializeImpl(SerializerObject s)
{
Byte00 = s.Serialize <byte>(Byte00, name: nameof(Byte00));
AnimationSpeed = s.Serialize <byte>(AnimationSpeed, name: nameof(AnimationSpeed));
if (Byte00 != 0)
{
AnimationPointer = s.SerializePointer(AnimationPointer, name: nameof(AnimationPointer));
}
else
{
LinkedStatePointer = s.SerializePointer(LinkedStatePointer, name: nameof(LinkedStatePointer));
}
CodePointer = s.SerializePointer(CodePointer, name: nameof(CodePointer));
Byte0A = s.Serialize <byte>(Byte0A, name: nameof(Byte0A));
Byte0B = s.Serialize <byte>(Byte0B, name: nameof(Byte0B));
s.DoAt(AnimationPointer, () => {
Animation = s.SerializeObject <R1Jaguar_AnimationDescriptor>(Animation, name: nameof(Animation));
//Animation = s.SerializeObject<Jaguar_R1_AnimationDescriptor>(Animation, onPreSerialize: l => l.FlipFlagInX = this.FlipFlagInX, name: nameof(Animation));
//Animation = s.SerializeObject<Jaguar_R1_AnimationDescriptor>(Animation, onPreSerialize: l => l.FlipFlagInX = (Byte00 != 200), name: nameof(Animation));
});
s.DoAt(LinkedStatePointer, () => {
LinkedState = s.SerializeObject <R1Jaguar_EventState>(LinkedState, name: nameof(LinkedState));
});
}
public override void SerializeBlock(SerializerObject s)
{
if (s.GameSettings.EngineVersion == EngineVersion.GBC_R1_PocketPC)
{
FileOffsets = s.SerializeArraySize <uint, uint>(FileOffsets, name: nameof(FileOffsets));
FileOffsets = s.SerializeArray <uint>(FileOffsets, FileOffsets.Length, name: nameof(FileOffsets));
if (Files == null)
{
Files = new SoundFile_PPC[FileOffsets.Length];
}
for (int i = 0; i < FileOffsets.Length; i++)
{
if (FileOffsets[i] == 0)
{
continue;
}
s.Goto(BlockStartPointer + FileOffsets[i]);
Files[i] = s.SerializeObject <SoundFile_PPC>(Files[i], name: $"{nameof(Files)}[{i}]");
}
}
else
{
DataOffsetsOffset = s.Serialize <ushort>(DataOffsetsOffset, name: nameof(DataOffsetsOffset));
UShort_02 = s.Serialize <ushort>(UShort_02, name: nameof(UShort_02));
SoundIDOffsetCount = s.Serialize <ushort>(SoundIDOffsetCount, name: nameof(SoundIDOffsetCount));
SoundOffsetCount = s.Serialize <ushort>(SoundOffsetCount, name: nameof(SoundOffsetCount));
s.DoAt(BlockStartPointer + DataOffsetsOffset, () => {
SoundIDOffsets = s.SerializeArray <ushort>(SoundIDOffsets, SoundIDOffsetCount, name: nameof(SoundIDOffsets));
SoundOffsets = s.SerializeArray <ushort>(SoundOffsets, SoundOffsetCount, name: nameof(SoundOffsets));
});
if (SoundIDs == null)
{
SoundIDs = new SoundID[SoundIDOffsetCount];
}
if (Sounds == null)
{
Sounds = new Sound[SoundOffsetCount];
}
for (int i = 0; i < SoundIDs.Length; i++)
{
s.Goto(BlockStartPointer + SoundIDOffsets[i]);
SoundIDs[i] = s.SerializeObject <SoundID>(SoundIDs[i], name: $"{nameof(SoundIDs)}[{i}]");
}
for (int i = 0; i < Sounds.Length; i++)
{
int nextOff = i < Sounds.Length - 1 ? SoundOffsets[i + 1] : (int)BlockSize;
int length = nextOff - SoundOffsets[i];
s.Goto(BlockStartPointer + SoundOffsets[i]);
Sounds[i] = s.SerializeObject <Sound>(Sounds[i], onPreSerialize: d => d.Length = length, name: $"{nameof(Sounds)}[{i}]");
if (Sounds[i].SoundProgramID.HasValue)
{
Sounds[i].SoundProgram = s.DoAt(DependencyTable.GetPointer(Sounds[i].SoundProgramID.Value - 1), () => {
return(s.SerializeObject <GBC_SoundProgram>(Sounds[i].SoundProgram, name: nameof(Sound.SoundProgram)));
});
}
}
}
}
