public FAnimCurveType(FArchive Ar)
{
bMaterial = Ar.ReadBoolean();
bMorphtarget = Ar.ReadBoolean();
}
public virtual void Deserialize(FArchive reader) => TokenOffset = reader.Tell();
protected static Token Read(FArchive reader) => TokenFactory.Read(reader);
public IoStoreReader(FArchive tocStream, Func <string, FArchive> openContainerStreamFunc, EIoStoreTocReadOptions readOptions = EIoStoreTocReadOptions.ReadDirectoryIndex)
: base(tocStream.Name, tocStream.Versions)
{
Length = tocStream.Length;
TocResource = new FIoStoreTocResource(tocStream, readOptions);
List <FArchive> containerStreams;
if (TocResource.Header.PartitionCount <= 0)
{
containerStreams = new List <FArchive>(1);
try
{
containerStreams.Add(openContainerStreamFunc(tocStream.Name.SubstringBeforeLast('.') + ".ucas"));
}
catch (Exception e)
{
throw new FIoStatusException(EIoErrorCode.FileOpenFailed, $"Failed to open container partition 0 for {tocStream.Name}", e);
}
}
else
{
containerStreams = new List <FArchive>((int)TocResource.Header.PartitionCount);
var environmentPath = tocStream.Name.SubstringBeforeLast('.');
for (int i = 0; i < TocResource.Header.PartitionCount; i++)
{
try
{
var path = i > 0 ? string.Concat(environmentPath, "_s", i, ".ucas") : string.Concat(environmentPath, ".ucas");
containerStreams.Add(openContainerStreamFunc(path));
}
catch (Exception e)
{
throw new FIoStatusException(EIoErrorCode.FileOpenFailed, $"Failed to open container partition {i} for {tocStream.Name}", e);
}
}
}
Length += containerStreams.Sum(x => x.Length);
ContainerStreams = containerStreams;
if (TocResource.ChunkPerfectHashSeeds != null)
{
TocImperfectHashMapFallback = new();
if (TocResource.ChunkIndicesWithoutPerfectHash != null)
{
foreach (var chunkIndexWithoutPerfectHash in TocResource.ChunkIndicesWithoutPerfectHash)
{
TocImperfectHashMapFallback[TocResource.ChunkIds[chunkIndexWithoutPerfectHash]] = TocResource.ChunkOffsetLengths[chunkIndexWithoutPerfectHash];
}
}
}
#if GENERATE_CHUNK_ID_DICT
else
{
TocImperfectHashMapFallback = new Dictionary <FIoChunkId, FIoOffsetAndLength>((int)TocResource.Header.TocEntryCount);
for (var i = 0; i < TocResource.ChunkIds.Length; i++)
{
TocImperfectHashMapFallback[TocResource.ChunkIds[i]] = TocResource.ChunkOffsetLengths[i];
}
}
#endif
Info = TocResource.Header;
if (TocResource.Header.Version > EIoStoreTocVersion.Latest)
{
log.Warning("Io Store \"{0}\" has unsupported version {1}", Path, (int)Info.Version);
}
}
public override void Deserialize(FArchive reader)
{
base.Deserialize(reader);
reader.Read(out _value);
}
protected virtual PlayerElimination ParseElimination(FArchive archive, EventInfo info)
{
try
{
var elim = new PlayerElimination
{
Info = info,
};
if (archive.EngineNetworkVersion >= EngineNetworkVersionHistory.HISTORY_FAST_ARRAY_DELTA_STRUCT && Major >= 9)
{
archive.SkipBytes(9);
elim.EliminatedInfo = new PlayerEliminationInfo
{
Unknown1 = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
Location = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
Unknown2 = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
};
archive.ReadSingle(); //?
elim.EliminatorInfo = new PlayerEliminationInfo
{
Unknown1 = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
Location = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
Unknown2 = new FVector(archive.ReadSingle(), archive.ReadSingle(), archive.ReadSingle()),
};
ParsePlayer(archive, elim.EliminatedInfo);
ParsePlayer(archive, elim.EliminatorInfo);
}
else
{
if (Major <= 4 && Minor < 2)
{
archive.SkipBytes(12);
}
else if (Major == 4 && Minor <= 2)
{
archive.SkipBytes(40);
}
else
{
archive.SkipBytes(45);
}
elim.EliminatedInfo = new PlayerEliminationInfo
{
Id = archive.ReadFString()
};
elim.EliminatorInfo = new PlayerEliminationInfo
{
Id = archive.ReadFString()
};
}
elim.GunType = archive.ReadByte();
elim.Knocked = archive.ReadUInt32AsBoolean();
elim.Timestamp = info.StartTime;
return(elim);
}
catch (Exception ex)
{
_logger?.LogError($"Error while parsing PlayerElimination at timestamp {info.StartTime}");
throw new PlayerEliminationException($"Error while parsing PlayerElimination at timestamp {info.StartTime}", ex);
}
}
public override FArchive Serialize(FArchive archive) => base.Serialize(archive) .Read(ref _value);
public FRigVMByteCode(FArchive Ar)
{
InstructionCount = Ar.Read <int>();
OpCode = Ar.Read <ERigVMOpCode>();
switch (OpCode)
{
case ERigVMOpCode.Execute_0_Operands:
case ERigVMOpCode.Execute_1_Operands:
case ERigVMOpCode.Execute_2_Operands:
case ERigVMOpCode.Execute_3_Operands:
case ERigVMOpCode.Execute_4_Operands:
case ERigVMOpCode.Execute_5_Operands:
case ERigVMOpCode.Execute_6_Operands:
case ERigVMOpCode.Execute_7_Operands:
case ERigVMOpCode.Execute_8_Operands:
case ERigVMOpCode.Execute_9_Operands:
case ERigVMOpCode.Execute_10_Operands:
case ERigVMOpCode.Execute_11_Operands:
case ERigVMOpCode.Execute_12_Operands:
case ERigVMOpCode.Execute_13_Operands:
case ERigVMOpCode.Execute_14_Operands:
case ERigVMOpCode.Execute_15_Operands:
case ERigVMOpCode.Execute_16_Operands:
case ERigVMOpCode.Execute_17_Operands:
case ERigVMOpCode.Execute_18_Operands:
case ERigVMOpCode.Execute_19_Operands:
case ERigVMOpCode.Execute_20_Operands:
case ERigVMOpCode.Execute_21_Operands:
case ERigVMOpCode.Execute_22_Operands:
case ERigVMOpCode.Execute_23_Operands:
case ERigVMOpCode.Execute_24_Operands:
case ERigVMOpCode.Execute_25_Operands:
case ERigVMOpCode.Execute_26_Operands:
case ERigVMOpCode.Execute_27_Operands:
case ERigVMOpCode.Execute_28_Operands:
case ERigVMOpCode.Execute_29_Operands:
case ERigVMOpCode.Execute_30_Operands:
case ERigVMOpCode.Execute_31_Operands:
case ERigVMOpCode.Execute_32_Operands:
case ERigVMOpCode.Execute_33_Operands:
case ERigVMOpCode.Execute_34_Operands:
case ERigVMOpCode.Execute_35_Operands:
case ERigVMOpCode.Execute_36_Operands:
case ERigVMOpCode.Execute_37_Operands:
case ERigVMOpCode.Execute_38_Operands:
case ERigVMOpCode.Execute_39_Operands:
case ERigVMOpCode.Execute_40_Operands:
case ERigVMOpCode.Execute_41_Operands:
case ERigVMOpCode.Execute_42_Operands:
case ERigVMOpCode.Execute_43_Operands:
case ERigVMOpCode.Execute_44_Operands:
case ERigVMOpCode.Execute_45_Operands:
case ERigVMOpCode.Execute_46_Operands:
case ERigVMOpCode.Execute_47_Operands:
case ERigVMOpCode.Execute_48_Operands:
case ERigVMOpCode.Execute_49_Operands:
case ERigVMOpCode.Execute_50_Operands:
case ERigVMOpCode.Execute_51_Operands:
case ERigVMOpCode.Execute_52_Operands:
case ERigVMOpCode.Execute_53_Operands:
case ERigVMOpCode.Execute_54_Operands:
case ERigVMOpCode.Execute_55_Operands:
case ERigVMOpCode.Execute_56_Operands:
case ERigVMOpCode.Execute_57_Operands:
case ERigVMOpCode.Execute_58_Operands:
case ERigVMOpCode.Execute_59_Operands:
case ERigVMOpCode.Execute_60_Operands:
case ERigVMOpCode.Execute_61_Operands:
case ERigVMOpCode.Execute_62_Operands:
case ERigVMOpCode.Execute_63_Operands:
case ERigVMOpCode.Execute_64_Operands:
{
var op = Ar.Read <FRigVMExecuteOp>();
var count = op.OpCode - ERigVMOpCode.Execute_0_Operands;
for (var idx = 0; idx < count; idx++)
{
var _ = Ar.Read <FRigVMOperand>();
}
break;
}
case ERigVMOpCode.Copy:
{
var _ = Ar.Read <FRigVMCopyOp>();
break;
}
case ERigVMOpCode.Zero:
case ERigVMOpCode.BoolFalse:
case ERigVMOpCode.BoolTrue:
case ERigVMOpCode.Increment:
case ERigVMOpCode.Decrement:
{
var _ = Ar.Read <FRigVMUnaryOp>();
break;
}
case ERigVMOpCode.Equals:
case ERigVMOpCode.NotEquals:
{
var _ = Ar.Read <FRigVMComparisonOp>();
break;
}
case ERigVMOpCode.JumpAbsolute:
case ERigVMOpCode.JumpForward:
case ERigVMOpCode.JumpBackward:
{
var _ = Ar.Read <FRigVMJumpOp>();
break;
}
case ERigVMOpCode.JumpAbsoluteIf:
case ERigVMOpCode.JumpForwardIf:
case ERigVMOpCode.JumpBackwardIf:
{
var _ = Ar.Read <FRigVMJumpIfOp>();
break;
}
case ERigVMOpCode.BeginBlock:
{
var _ = Ar.Read <FRigVMBinaryOp>();
break;
}
}
}
public override void Deserialize(FArchive reader)
{
base.Deserialize(reader);
_value = true;
}
public override FArchive Serialize(FArchive archive) => archive.Read(ref _sourceDateTime) .ReadUnsafe(ref _timeStyle) .Read(ref _timeZone) .Read(ref _cultureName);
public override TaggedObject?Read(FArchive reader) => null;
public static EAudioFormat GetAudioFormat(FArchive Ar)
{
var rfId = Ar.Read <EChunkIdentifier>();
if (rfId != EChunkIdentifier.RIFF)
{
throw new Exception($"Invalid RIFF identifier (should be {EChunkIdentifier.RIFF} but actually is {rfId})");
}
var fileSize = Ar.Read <uint>();
var wvId = Ar.Read <EChunkIdentifier>();
if (wvId != EChunkIdentifier.WAVE)
{
throw new Exception($"Invalid WAVE identifier (should be {EChunkIdentifier.WAVE} but actually is {wvId})");
}
var ftId = Ar.Read <EChunkIdentifier>();
if (ftId != EChunkIdentifier.FMT)
{
throw new Exception($"Invalid FMT identifier (should be {EChunkIdentifier.FMT} but actually is {ftId})");
}
var ftSize = Ar.Read <uint>();
var savePos = Ar.Position;
var wFormatTag = Ar.Read <EAudioFormat>();
var nChannels = Ar.Read <ushort>();
var nSamplesPerSec = Ar.Read <uint>();
var nAvgBytesPerSec = Ar.Read <uint>();
var nBlockAlign = Ar.Read <ushort>();
var wBitsPerSample = Ar.Read <ushort>();
if (wFormatTag <= EAudioFormat.WAVE_FORMAT_PCM)
{
Ar.Position = savePos + ftSize;
return(wFormatTag);
}
var cbSize = Ar.Read <ushort>();
if (wFormatTag < EAudioFormat.WAVE_FORMAT_EXTENSIBLE)
{
Ar.Position = savePos + ftSize;
return(wFormatTag);
}
if (wBitsPerSample != (8 * nBlockAlign / nChannels))
{
throw new Exception("The original bits/sample field does not match the container size");
}
var wValidBitsPerSample = Ar.Read <ushort>();
var dwChannelMask = Ar.Read <uint>();
wFormatTag = Ar.Read <EAudioFormat>();
Ar.Position -= sizeof(EAudioFormat);
var subFormat = Ar.Read <FGuid>();
Ar.Position = savePos + ftSize;
return(wFormatTag);
}
public FIoStoreTocEntryMeta(FArchive Ar)
{
ChunkHash = new FIoChunkHash(Ar);
Flags = Ar.Read <FIoStoreTocEntryMetaFlags>();
}
public override void Deserialize(FArchive reader, PropertyTag tag) => reader.Read(out _value);
protected override void ReadReplayHeader(FArchive archive)
{
base.ReadReplayHeader(archive);
Branch = Replay.Header.Branch;
}
public FAssetRegistryArchive(FArchive Ar)
{
baseArchive = Ar;
}
/// <summary>
/// see https://github.com/EpicGames/UnrealEngine/blob/70bc980c6361d9a7d23f6d23ffe322a2d6ef16fb/Engine/Source/Runtime/NetworkReplayStreaming/LocalFileNetworkReplayStreaming/Private/LocalFileNetworkReplayStreaming.cpp#L363
/// </summary>
/// <param name="archive"></param>
/// <returns></returns>
protected override void ReadEvent(FArchive archive)
{
var info = new EventInfo
{
Id = archive.ReadFString(),
Group = archive.ReadFString(),
Metadata = archive.ReadFString(),
StartTime = archive.ReadUInt32(),
EndTime = archive.ReadUInt32(),
SizeInBytes = archive.ReadInt32()
};
_logger?.LogDebug($"Encountered event {info.Group} ({info.Metadata}) at {info.StartTime} of size {info.SizeInBytes}");
if (archive.NetworkVersion == 0)
{
_logger?.LogWarning($"Event occurred before header written. Ignoring ...");
return;
}
using var decryptedReader = Decrypt(archive, info.SizeInBytes);
// Every event seems to start with some unknown int
if (info.Group == ReplayEventTypes.PLAYER_ELIMINATION)
{
var elimination = ParseElimination(decryptedReader, info);
Replay.Eliminations.Add(elimination);
return;
}
else if (info.Metadata == ReplayEventTypes.MATCH_STATS)
{
Replay.Stats = ParseMatchStats(decryptedReader, info);
return;
}
else if (info.Metadata == ReplayEventTypes.TEAM_STATS)
{
Replay.TeamStats = ParseTeamStats(decryptedReader, info);
return;
}
else if (info.Metadata == ReplayEventTypes.ENCRYPTION_KEY)
{
Replay.GameInformation.PlayerStateEncryptionKey = ParseEncryptionKeyEvent(decryptedReader, info);
return;
}
else if (info.Metadata == ReplayEventTypes.CHARACTER_SAMPLE)
{
ParseCharacterSample(decryptedReader, info);
return;
}
else if (info.Group == ReplayEventTypes.ZONE_UPDATE)
{
ParseZoneUpdateEvent(decryptedReader, info);
return;
}
else if (info.Group == ReplayEventTypes.BATTLE_BUS)
{
ParseBattleBusFlightEvent(decryptedReader, info);
return;
}
else if (info.Group == "fortBenchEvent")
{
return;
}
_logger?.LogWarning($"Unknown event {info.Group} ({info.Metadata}) of size {info.SizeInBytes}");
// optionally throw?
throw new UnknownEventException($"Unknown event {info.Group} ({info.Metadata}) of size {info.SizeInBytes}");
}
public TaggedObject(FArchive reader) => Deserialize(reader);
public void Deserialize(FArchive reader)
{
reader.Read(out _min);
reader.Read(out _max);
reader.Read(out _isValid);
}
public void Deserialize(FArchive reader)
{
throw new NotImplementedException();
}
