Esempio n. 1
0
        private void ParseEliminationEventData(BinaryReader reader, ref ReplayInformation replayInfo)
        {
            reader.SkipBytes(87);
            var eliminatedId = reader.ReadGuid();

            reader.SkipBytes(2);
            var eliminatorId = reader.ReadGuid();

            var eliminated = replayInfo.MatchInformation.AddPlayer(eliminatedId);
            var eliminator = replayInfo.MatchInformation.AddPlayer(eliminatorId);

            var damageType    = (DamageType)reader.ReadByte();
            var isElimination = reader.ReadByte() == 0;

            if (isElimination)
            {
                eliminator.EliminatedPlayer(eliminated, damageType);
            }
            else
            {
                eliminator.DownedPlayer(eliminated, damageType);
            }

            replayInfo.MatchInformation.AddToFeed(eliminated, eliminator, damageType, isElimination);
        }
Esempio n. 2
0
        public ReplayInformation ReadReplayInfo()
        {
            var replayInfo = new ReplayInformation();

            using (BinaryReader reader = new BinaryReader(_replayStream))
            {
                var magicNumber = reader.ReadUInt32();
                if (magicNumber != FILE_MAGIC)
                {
                    throw new InvalidReplayFileException();
                }

                var fileVersion = reader.ReadUInt32();
                replayInfo.MatchInformation.LengthInMs = reader.ReadUInt32();
                var networkVersion = reader.ReadUInt32();
                var changeList     = reader.ReadUInt32();
                replayInfo.ReplayName = reader.ReadFString();

                var isLive = reader.ReadUInt32() != 0;

                if (fileVersion >= (uint)VersionHistoryType.HISTORY_RECORDED_TIMESTAMP)
                {
                    replayInfo.Timestamp = new DateTime(reader.ReadInt64());
                }

                if (fileVersion >= (uint)VersionHistoryType.HISTORY_COMPRESSION)
                {
                    var isCompressed = reader.ReadUInt32() != 0;
                }

                while (reader.BaseStream.Position < reader.BaseStream.Length)
                {
                    var chunkType        = (ChunkType)reader.ReadUInt32();
                    var chunkSizeInBytes = reader.ReadInt32();

                    var offset = reader.BaseStream.Position;

                    switch (chunkType)
                    {
                    case ChunkType.Header:
                        ParseHeaderChunk(reader, ref replayInfo);
                        break;

                    case ChunkType.Checkpoint:
                        ParseCheckpointChunk(reader);
                        break;

                    case ChunkType.ReplayData:
                        ParseReplayData(reader);
                        break;

                    case ChunkType.Event:
                        ParseEventData(reader, ref replayInfo);
                        break;
                    }

                    reader.BaseStream.Seek(offset + chunkSizeInBytes, SeekOrigin.Begin);
                }
            }
            _replayStream.Close();
            return(replayInfo);
        }