public PlayerJoinEvent(BitReader bitReader, Replay replay, int playerIndex)
        {
            this.EventType = GameEventType.Inactive;

            // This should probably be a series of {shl; or} on .Read(1)
            // to make it version-independent
            if (replay.ReplayBuild < 22612)
            {
                this.JoinFlags = (int)bitReader.Read(4);
            }
            else
            {
                this.JoinFlags = (int)bitReader.Read(12); // unknown
            }

            // Initialize player if not exists (true for observers)
            Player player = replay.GetPlayerById(playerIndex);
            if (player == null)
            {
                var p = new Player { PlayerType = PlayerType.Spectator };
                replay.ClientList[playerIndex] = player = p;
            }

            // Initialize wireframe
            player.Wireframe = new List<Unit>();
            player.WireframeSubgroup = 0;

            // Initialize control groups
            player.Hotkeys = new List<Unit>[10];
        }
        public CameraEvent(BitReader bitReader, Replay replay)
        {
            TargetX = CFixedToDouble(bitReader.Read(16));
            TargetY = CFixedToDouble(bitReader.Read(16));

            HasDistance = bitReader.Read(1) != 0;
            if (HasDistance)
            {
                Distance = CFixedToDouble(bitReader.Read(16));
            }

            HasPitch = bitReader.Read(1) != 0;
            if (HasPitch)
            {
                Pitch = RotationAmountToDegrees(bitReader.Read(16));
            }

            HasYaw = bitReader.Read(1) != 0;
            if (HasYaw)
            {
                Yaw = RotationAmountToDegrees(bitReader.Read(16));
            }

            HasHeightOffset = bitReader.Read(1) != 0;
            if (HasHeightOffset)
            {
                // Debug since we're unsure
                HeightOffset = CFixedToDouble(bitReader.Read(16));
            }

            this.EventType = GameEventType.Other;
        }
        public ReplayEditorViewModel(string replayPath)
        {
            this.CurrentFile = replayPath;

            try
            {
                this.replay = Replay.Parse(this.CurrentFile);
            }
            catch (Exception ex)
            {
                MessageBox.Show("The replay failed to load. Reason: " + ex.Message);
                return;
            }

            this.ReplayHeader = Path.GetFileName(this.CurrentFile);
            var messages = new ObservableCollection<PlayerChatMessage>();

            foreach (var message in this.replay.ChatMessages)
            {
                int id = message.PlayerId - 1;
                if (id < this.replay.Players.Length)
                {
                    var chat = new PlayerChatMessage { ChatMessage = message, Player = this.replay.Players[message.PlayerId - 1] };
                    messages.Add(chat);
                }
            }

            this.ChatMessageEditor = new ChatMessageEditViewModel { PlayerList = this.replay.Players };

            this.ChatMessages = messages;
        }
        /// <summary> Adds a single chat message to a replay. </summary>
        /// <param name="fileName"> The file name.  </param>
        /// <param name="messages"> The messages to add.  </param>
        public static void AddChatMessageToReplay(string fileName, IEnumerable<ChatMessage> messages)
        {
            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            using (var archive = new CArchive(fileName))
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.message.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    foreach (var message in messages)
                    {
                        buffer = GenerateChatMessage(
                            buffer,
                            message.Message,
                            message.MessageTarget,
                            message.PlayerId,
                            (int)message.Timestamp.TotalSeconds);
                    }

                    archive.ImportFile("replay.message.events", buffer);
                }

                archive.Close();
            }
        }
        public SendResourcesEvent(BitReader bitReader, Replay replay)
        {
            this.EventType = GameEventType.Other;

            var playerId = (int)bitReader.Read(4);
            Target = replay.GetPlayerById(playerId);

            var someFlags = (int)bitReader.Read(3);

            if (someFlags-- > 0) // 4
            {
                MineralsSent = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 3
            {
                VespeneSent = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 2
            {
                TerrazineSent = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 1
            {
                CustomSent = ReadSignedAmount(bitReader.Read(32));
            }
        }
        /// <summary> Adds a single chat message to a replay. </summary>
        /// <param name="fileName"> The file name.  </param>
        /// <param name="message"> The message.  </param>
        /// <param name="target"> The target. </param>
        /// <param name="playerId"> The player id.  </param>
        /// <param name="numSeconds"> The number of in-game seconds to insert the message at.  </param>
        public static void AddChatMessageToReplay(
            string fileName, string message, ChatMessageTarget target, int playerId, int numSeconds)
        {
            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            using (var archive = new CArchive(fileName))
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.message.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    var arr = GenerateChatMessage(buffer, message, target, playerId, numSeconds);
                    archive.ImportFile("replay.message.events", arr);
                }

                archive.Close();
            }
        }
        public static void Parse(Replay replay, byte[] buffer)
        {
            using (var stream = new MemoryStream(buffer))
            {
                using (var reader = new BinaryReader(stream))
                {
                    var i = reader.ReadByte();

                    var playerList = new string[i];
                    for (int j = 0; j < i; j++)
                    {
                        var str = ReadString(reader);

                        playerList[j] = str;
                        reader.ReadBytes(5);
                    }

                    if (positionAfter(reader, new byte[] { 115, 50, 109, 97 }))
                    {
                        reader.ReadBytes(2);
                        var gatewayStr = reader.ReadBytes(2);

                        var gateway = Encoding.UTF8.GetString(gatewayStr);
                        replay.Gateway = gateway;
                    }
                    else
                    {
                        replay.GameType = GameType.SinglePlayer;
                    }
                }
            }
        }
        /// <summary> Parses the replay.details file, applying it to a Replay object. </summary>
        /// <param name="replay"> The replay object to apply the parsed information to. </param>
        /// <param name="buffer"> The buffer containing the replay.details file. </param>
        public static void Parse(Replay replay, byte[] buffer)
        {
            using (var stream = new MemoryStream(buffer, false))
            {
                Parse(replay, stream);

                stream.Close();
            }
        }
        /// <summary> Parses the replay.details file, applying it to a Replay object. </summary>
        /// <param name="replay"> The replay object to apply the parsed information to. </param>
        /// <param name="stream"> The stream containing the replay.details file. </param>
        public static void Parse(Replay replay, Stream stream)
        {
            using (var reader = new BinaryReader(stream))
            {
                reader.ReadBytes(6);
                var playerCount = reader.ReadByte() >> 1;

                // Parsing Player Info
                var players = new Player[playerCount];

                for (int i = 0; i < playerCount; i++)
                {
                    players[i] = PlayerDetails.Parse(reader);
                }

                replay.Players = players;

                var mapNameLength = KeyValueStruct.Parse(reader).Value;

                var mapBytes = reader.ReadBytes(mapNameLength);

                replay.Map = Encoding.UTF8.GetString(mapBytes);

                var stringLength = KeyValueStruct.Parse(reader).Value;

                // This is typically an empty string, no need to decode.
                var unknownString = reader.ReadBytes(stringLength);

                reader.ReadBytes(3);

                var mapPreviewNameLength = KeyValueStruct.Parse(reader).Value;
                var mapPreviewNameBytes = reader.ReadBytes(mapPreviewNameLength);

                // What have I learned:
                // While I can get the name of the map preview file, apparently MPQLib.dll will not
                // Support exporting the file since its not in the file list. I tried, and it threw an error...
                // Maybe my buffer wasn't big enough, but it was some temporary file error, so I don't think so.
                var mapPreviewName = Encoding.UTF8.GetString(mapPreviewNameBytes);

                reader.ReadBytes(3);

                var saveTime = KeyValueLongStruct.Parse(reader).Value;
                var saveTimeZone = KeyValueLongStruct.Parse(reader).Value;
                var time = DateTime.FromFileTime(saveTime);

                // Subtract the timezone to get the appropriate UTC time.
                time = time.Subtract(new TimeSpan(saveTimeZone));

                // We create a new timestamp so we can properly set this as UTC time.
                replay.Timestamp = new DateTime(time.Ticks, DateTimeKind.Utc);

                reader.Close();
            }
        }
        public static void Parse(Replay replay, byte[] buffer)
        {
            int headerSize = 4;

            if (replay.ReplayBuild >= 17326) // 1.2.0
            {
                headerSize = 5;
            }

            var numAttributes = BitConverter.ToInt32(buffer, headerSize);

            var attributes = new ReplayAttribute[numAttributes];

            int initialOffset = 4 + headerSize;

            for (int i = 0; i < numAttributes; i++)
            {
                attributes[i] = ReplayAttribute.Parse(buffer, initialOffset + (i*13));
            }

            var rae = new ReplayAttributeEvents { Attributes = attributes };
            rae.ApplyAttributes(replay);
        }
        public RequestResourcesEvent(BitReader bitReader, Replay replay)
        {
            this.EventType = GameEventType.Other;

            var someFlags = (int)bitReader.Read(3);

            if (someFlags-- > 0) // 4
            {
                MineralsRequested = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 3
            {
                VespeneRequested = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 2
            {
                TerrazineRequested = ReadSignedAmount(bitReader.Read(32));
            }
            if (someFlags-- > 0) // 1
            {
                CustomRequested = ReadSignedAmount(bitReader.Read(32));
            }
        }
        /// <summary> Parses the replay.initdata file in a replay file. </summary>
        /// <param name="replay"> The replay file to apply the parsed data to. </param>
        /// <param name="buffer"> The buffer containing the replay.initdata file. </param>
        public static void Parse(Replay replay, byte[] buffer)
        {
            using (var stream = new MemoryStream(buffer))
            {
                using (var reader = new BinaryReader(stream))
                {
                    var i = reader.ReadByte();

                    var playerList = new string[i];
                    for (int j = 0; j < i; j++)
                    {
                        var str = ReadString(reader);

                        playerList[j] = str;
                        reader.ReadBytes(5);
                    }

                    // Save the full list of clients.
                    // This is no longer necessary since we get the client list elsewhere.
                    //// replay.ClientList = playerList;

                    if (PositionAfter(reader, new byte[] { 115, 50, 109, 97 }))
                    {
                        reader.ReadBytes(2);
                        var gatewayStr = reader.ReadBytes(2);

                        var gateway = Encoding.UTF8.GetString(gatewayStr);
                        replay.Gateway = gateway;
                    }
                    else
                    {
                        replay.GameType = GameType.SinglePlayer;
                    }
                }
            }
        }
Beispiel #13
0
        /// <summary>
        /// Parses the MPQ header on a file to determine version and build numbers.
        /// </summary>
        /// <param name="replay">Replay object to store </param>
        /// <param name="filename">Filename of the file to open.</param>
        public static void ParseHeader(Replay replay, string filename)
        {
            using (var reader = new BinaryReader(new FileStream(filename, FileMode.Open)))
            {
                byte[] magic = reader.ReadBytes(3);
                byte format = reader.ReadByte();

                byte[] buffer = reader.ReadBytes(4);
                var dataMaxSize = BitConverter.ToInt32(buffer, 0);

                buffer = reader.ReadBytes(4);
                int headerOffset = BitConverter.ToInt32(buffer, 0);

                buffer = reader.ReadBytes(4);
                int userDataHeaderSize = BitConverter.ToInt32(buffer, 0);

                int dataType = reader.ReadByte(); // Should be 0x05 = Array w/ Keys

                int numElements = ParseVlfNumber(reader);

                // The first value is the words: "Starcraft II Replay 11"
                int index = ParseVlfNumber(reader);

                int type = reader.ReadByte(); // Should be 0x02 = binary data

                int numValues = ParseVlfNumber(reader);
                byte[] starcraft2 = reader.ReadBytes(numValues);

                int index2 = ParseVlfNumber(reader);
                int type2 = reader.ReadByte(); // Should be 0x05 = Array w/ Keys

                int numElementsVersion = ParseVlfNumber(reader);
                var version = new int[numElementsVersion];

                while (numElementsVersion > 0)
                {
                    int i = ParseVlfNumber(reader);
                    int t = reader.ReadByte(); // Type;

                    if (t == 0x09)
                    {
                        // VLF
                        version[i] = ParseVlfNumber(reader);
                    }
                    else if (t == 0x06)
                    {
                        // Byte
                        version[i] = reader.ReadByte();
                    }
                    else if (t == 0x07)
                    {
                        // 4 Bytes
                        version[i] = BitConverter.ToInt32(reader.ReadBytes(4), 0);
                    }

                    numElementsVersion--;
                }

                // We now have the version. Just parse.
                replay.ReplayVersion = string.Format("{0}.{1}.{2}.{3}", version[0], version[1], version[2], version[3]);
                replay.ReplayBuild = version[4];

                reader.Close();
            }
        }
        public AbilityEvent(BitReader bitReader, Replay replay, Player player, AbilityData abilityData, UnitData unitData)
        {
            uint flags;
            //   1.3.3 patch notes:
            //   - Fixed an issue where the APM statistic could be artificially increased.
            // This adds the "failed" flag, which is triggered usually by holding down a
            // hotkey, leading to key repeat spamming the event throughout a single tick.
            if (replay.ReplayBuild < 18574) // < 1.3.3
            {
                flags = bitReader.Read(17);
            }
            else if (replay.ReplayBuild < 22612) // < 1.5.0
            {
                flags = bitReader.Read(18);
            }
            else
            {
                flags = bitReader.Read(20);
            }
            Queued = (flags & 2) != 0;
            RightClick = (flags & 8) != 0;
            WireframeClick = (flags & 0x20) != 0;
            ToggleAbility = (flags & 0x40) != 0;
            EnableAutoCast = (flags & 0x80) != 0;
            AbilityUsed = (flags & 0x100) != 0;
            WireframeUnload = (flags & 0x200) != 0;
            WireframeCancel = (flags & 0x400) != 0;
            MinimapClick = (flags & 0x10000) != 0;
            AbilityFailed = (flags & 0x20000) != 0;

            // flags & 0xf815 -> Debug for unknown flags
            // Never found any across all test data.

            DefaultAbility = (bitReader.Read(1) == 0);
            DefaultActor = true;
            if (!DefaultAbility)
            {
                AbilityType = abilityData.GetAbilityType(
                    (int)bitReader.Read(16),
                    (int)bitReader.Read(5));
                DefaultActor = (bitReader.Read(1) == 0);
                if (!DefaultActor)
                {   // I'm thinking this would be an array type... but I can't
                    // find anything that causes this bit to be set.
                    throw new InvalidOperationException("Unsupported: non-default actor");
                }
            }
            if (DefaultActor)
            {
                // Deep copy the current wireframe as the actor list
                // -----
                // If a user wants to deal with subgroups to get a more
                // concise actor list, the data is all here.  We're not
                // going to bother, though, because there are several
                // exceptions to account for in determining event actors.
                Actors = new List<Unit>(player.Wireframe.Count);
                foreach (var unit in player.Wireframe)
                {
                    Actors.Add(new Unit(unit));
                }
            }

            var targetType = bitReader.Read(2);
            if (targetType == 1) // Location target
            {
                var targetX = bitReader.Read(20);
                var targetY = bitReader.Read(20);
                var targetZ = bitReader.Read(32);
                TargetLocation = Location.FromEventFormat(targetX, targetY, targetZ);
            }
            else if (targetType == 2) // Unit + Location target
            {
                TargetFlags = (int)bitReader.Read(8);
                WireframeIndex = (int)bitReader.Read(8);

                var unitId = (int)bitReader.Read(32);
                var unit = replay.GetUnitById(unitId);
                var unitTypeId = (int)bitReader.Read(16);
                if (unit == null)
                {
                    var unitType = unitData.GetUnitType(unitTypeId);
                    unit = new Unit(unitId, unitType);
                    unit.typeId = unitTypeId;
                    replay.GameUnits.Add(unitId, unit);
                }

                TargetUnit = unit;

                var targetHasPlayer = bitReader.Read(1) == 1;
                if (targetHasPlayer)
                {
                    TargetPlayer = (int)bitReader.Read(4);
                }

                // 1.4.0 -- Don't really know what this was meant to fix
                if (replay.ReplayBuild >= 19595)
                {
                    var targetHasTeam = bitReader.Read(1) == 1;
                    if (targetHasTeam)
                    {
                        TargetTeam = (int)bitReader.Read(4);
                    }
                }

                var targetX = bitReader.Read(20);
                var targetY = bitReader.Read(20);
                var targetZ = bitReader.Read(32);
                TargetLocation = Location.FromEventFormat(targetX, targetY, targetZ);
            }
            else if (targetType == 3) // Unit target
            {
                var id = bitReader.Read(32);
                // Again, if the user wants to determine exactly which
                // queue item is canceled in the case of a queue cancel
                // event (the most common case of this target specifier's
                // occurence), they can; however, it requires an additional
                // data structure that I don't want to bother with; however,
                // all the underlying data is available in the events list.
                TargetId = id;
            }

            var lastBit = bitReader.Read(1); // Should be 0; if not, misalignment is likely

            if (!AbilityFailed)
            {
                if (RightClick)
                {
                    this.EventType = GameEventType.RightClick;
                }
                else
                {
                    this.EventType = EventData.GetInstance().GetEventType(this.AbilityType);
                }
            }
            else
            {
                this.EventType = GameEventType.Inactive;
            }
        }
        public SelectionEvent(BitReader bitReader, Replay replay, Player player, UnitData data)
        {
            int wireframeLength = 8;
            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }

            // Parse select event and update player wireframe accordingly
            WireframeIndex = (int)bitReader.Read(4);
            player.WireframeSubgroup = SubgroupIndex = (int)bitReader.Read(wireframeLength);

            if (WireframeIndex == 10)
            {
                this.EventType = GameEventType.Selection;
            }
            else // This is a control group update, likely from a CAbilMorph
            {
                this.EventType = GameEventType.Inactive;
            }

            List<Unit> affectedWireframe;
            if (WireframeIndex == 10)
            {
                affectedWireframe = player.Wireframe;
            }
            else
            {
                affectedWireframe = player.Hotkeys[WireframeIndex];
            }

            RemovedUnits = new List<Unit>();

            var updateFlags = (int)bitReader.Read(2);

            ClearSelection = false;

            if (updateFlags == 1)
            {
                var numBits = (int)bitReader.Read(wireframeLength);
                var unitsRemoved = new bool[numBits];

                var wireframeIndex = 0;
                while (numBits >= 8)
                {
                    numBits -= 8;
                    var flags = bitReader.Read(8);
                    for (int i = 0; i < 8; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += 8;
                }
                if (numBits != 0)
                {
                    var flags = bitReader.Read(numBits);
                    for (int i = 0; i < numBits; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += numBits;
                }

                for (int i = 0; i < wireframeIndex; i++)
                {
                    if (unitsRemoved[i])
                    {
                        RemovedUnits.Add(affectedWireframe[i]);
                    }
                }
            }
            else if (updateFlags == 2)
            {
                var indexArrayLength = (int)bitReader.Read(wireframeLength);
                if (indexArrayLength > 0)
                {
                    for (int i = 0; i < indexArrayLength; i++)
                    {
                        RemovedUnits.Add(affectedWireframe[(int)bitReader.Read(wireframeLength)]);
                    }
                }
            }
            else if (updateFlags == 3)
            {
                var indexArrayLength = (int)bitReader.Read(wireframeLength);
                if (indexArrayLength > 0)
                {
                    AddedUnits = new List<Unit>(indexArrayLength);
                    for (int i = 0; i < indexArrayLength; i++)
                    {
                        AddedUnits.Add(affectedWireframe[(int)bitReader.Read(wireframeLength)]);
                    }
                }

                ClearSelection = true;
            }

            // Build removed unit types
            RemovedUnitTypes = new Dictionary<UnitType, int>();
            foreach (var unit in RemovedUnits)
            {
                if (!RemovedUnitTypes.ContainsKey(unit.Type))
                {
                    RemovedUnitTypes.Add(unit.Type, 1);
                }
                else
                {
                    RemovedUnitTypes[unit.Type]++;
                }
            }

            HandleUnitArrays(bitReader, replay, data);

            // Now, update the player wireframe.
            UpdateWireframe(player);

            // Check for Morph update
            if (AddedUnits.SequenceEqual(RemovedUnits))
            {
                this.EventType = GameEventType.Inactive;
            }
        }
Beispiel #16
0
        public SelectionEvent(BitReader bitReader, Replay replay, Player player, UnitData data)
        {
            int wireframeLength = 8;

            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }

            // Parse select event and update player wireframe accordingly
            WireframeIndex           = (int)bitReader.Read(4);
            player.WireframeSubgroup = SubgroupIndex = (int)bitReader.Read(wireframeLength);

            if (WireframeIndex == 10)
            {
                this.EventType = GameEventType.Selection;
            }
            else // This is a control group update, likely from a CAbilMorph
            {
                this.EventType = GameEventType.Inactive;
            }

            List <Unit> affectedWireframe;

            if (WireframeIndex == 10)
            {
                affectedWireframe = player.Wireframe;
            }
            else
            {
                affectedWireframe = player.Hotkeys[WireframeIndex];
            }

            RemovedUnits = new List <Unit>();

            var updateFlags = (int)bitReader.Read(2);

            ClearSelection = false;

            if (updateFlags == 1)
            {
                var numBits      = (int)bitReader.Read(wireframeLength);
                var unitsRemoved = new bool[numBits];

                var wireframeIndex = 0;
                while (numBits >= 8)
                {
                    numBits -= 8;
                    var flags = bitReader.Read(8);
                    for (int i = 0; i < 8; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += 8;
                }
                if (numBits != 0)
                {
                    var flags = bitReader.Read(numBits);
                    for (int i = 0; i < numBits; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += numBits;
                }

                for (int i = 0; i < wireframeIndex; i++)
                {
                    if (unitsRemoved[i])
                    {
                        RemovedUnits.Add(affectedWireframe[i]);
                    }
                }
            }
            else if (updateFlags == 2)
            {
                var indexArrayLength = (int)bitReader.Read(wireframeLength);
                if (indexArrayLength > 0)
                {
                    for (int i = 0; i < indexArrayLength; i++)
                    {
                        RemovedUnits.Add(affectedWireframe[(int)bitReader.Read(wireframeLength)]);
                    }
                }
            }
            else if (updateFlags == 3)
            {
                var indexArrayLength = (int)bitReader.Read(wireframeLength);
                if (indexArrayLength > 0)
                {
                    AddedUnits = new List <Unit>(indexArrayLength);
                    for (int i = 0; i < indexArrayLength; i++)
                    {
                        AddedUnits.Add(affectedWireframe[(int)bitReader.Read(wireframeLength)]);
                    }
                }

                ClearSelection = true;
            }

            // Build removed unit types
            RemovedUnitTypes = new Dictionary <UnitType, int>();
            foreach (var unit in RemovedUnits)
            {
                if (!RemovedUnitTypes.ContainsKey(unit.Type))
                {
                    RemovedUnitTypes.Add(unit.Type, 1);
                }
                else
                {
                    RemovedUnitTypes[unit.Type]++;
                }
            }

            HandleUnitArrays(bitReader, replay, data);

            // Now, update the player wireframe.
            UpdateWireframe(player);

            // Check for Morph update
            if (AddedUnits.SequenceEqual(RemovedUnits))
            {
                this.EventType = GameEventType.Inactive;
            }
        }
Beispiel #17
0
        /// <summary> Parses a .SC2Replay file and returns relevant replay information.  </summary>
        /// <param name="fileName"> Full path to a .SC2Replay file.  </param>
        /// <returns> Returns the fully parsed Replay object. </returns>
        public static Replay Parse(string fileName)
        {
            if (File.Exists(fileName) == false)
            {
                throw new FileNotFoundException("The specified file does not exist.", fileName);
            }

            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            CArchive archive;

            try
            {
                archive = new CArchive(fileName);
            }
            catch (IOException)
            {
                // Usually thrown if the archive name contains korean. Copy it to a local file and open.
                var tmpPath = Path.GetTempFileName();

                File.Copy(fileName, tmpPath, true);

                archive = new CArchive(tmpPath);
            }

            try
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.initData";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayInitData.Parse(replay, buffer);
                }

                {
                    // Local scope allows the byte[] to be GC sooner, and prevents misreferences
                    const string CurFile = "replay.details";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayDetails.Parse(replay, buffer);
                }

                {
                    const string CurFile = "replay.attributes.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayAttributeEvents.Parse(replay, buffer);
                }

                {
                    const string CurFile = "replay.message.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    replay.ChatMessages = ReplayMessageEvents.Parse(buffer);
                }

                try
                {
                    const string CurFile = "replay.game.events";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    replay.PlayerEvents = ReplayGameEvents.Parse(replay, buffer);
                }
                catch (Exception)
                {
                    // In the current state, the parsing commonly fails.
                    // Incase of failing, we should probably just ignore the results of the parse
                    // And return.
                }
            }
            finally
            {
                archive.Dispose();
            }

            replay.Timestamp = File.GetCreationTime(fileName);

            return replay;
        }
Beispiel #18
0
        /// <summary> Parses a .SC2Replay file and returns relevant replay information.  </summary>
        /// <param name="fileName"> Full path to a .SC2Replay file.  </param>
        /// <param name="noEvents"> True if you don't want to parse events (uses about 5~10 MB on a pro replay, half on an amateur replay) </param>
        /// <returns> Returns the fully parsed Replay object. </returns>
        public static Replay Parse(string fileName, bool noEvents = false)
        {
            if (File.Exists(fileName) == false)
            {
                throw new FileNotFoundException("The specified file does not exist.", fileName);
            }

            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            CArchive archive;

            try
            {
                archive = new CArchive(fileName);
            }
            catch (IOException)
            {
                // Usually thrown if the archive name contains korean. Copy it to a local file and open.
                var tmpPath = Path.GetTempFileName();

                File.Copy(fileName, tmpPath, true);

                archive = new CArchive(tmpPath);
            }

            try
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.initData";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayInitData.Parse(replay, buffer);
                }

                {
                    // Local scope allows the byte[] to be GC sooner, and prevents misreferences
                    const string CurFile = "replay.details";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayDetails.Parse(replay, buffer);
                }

                {
                    const string CurFile = "replay.attributes.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayAttributeEvents.Parse(replay, buffer);
                }

                {
                    const string CurFile = "replay.message.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);
                    try
                    {
                        replay.ChatMessages = ReplayMessageEvents.Parse(buffer);
                    }
                    catch // Chat may have been removed without maintaining the structure
                          // Example:  LiquidHayPro vs MFTarga.SC2Replay from TLPro pack #36
                          // You can see a date on the file in MPQ editor, and viewing the
                          // replay in SC2 results in no chat at all.
                    {
                        replay.ChatMessages = new List<ChatMessage>();
                    }
                }

                try
                {
                    if (!noEvents)
                    {
                        const string CurFile = "replay.game.events";

                        var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                        var buffer = new byte[fileSize];

                        archive.ExportFile(CurFile, buffer);

                        replay.PlayerEvents = ReplayGameEvents.Parse(replay, buffer);
                    }
                }
                catch (Exception)
                {
                    // Likely to happen with any non-standard (i.e. format isn't melee nvn, locked alliances) replay.
                }
            }
            finally
            {
                archive.Dispose();
            }

            replay.Timestamp = File.GetCreationTime(fileName);

            return replay;
        }
        /// <summary> Erases the entire chat log of a file. </summary>
        /// <param name="fileName"> The file name.  </param>
        public static void ClearChatLog(string fileName)
        {
            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            using (var archive = new CArchive(fileName))
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.message.events";
                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    var arr = ClearChatLog(buffer);
                    archive.ImportFile("replay.message.events", arr);
                }

                archive.Close();
            }
        }
        /// <summary>
        /// Parses the MPQ header on a file to determine version and build numbers.
        /// </summary>
        /// <param name="replay">Replay object to store </param>
        /// <param name="filename">Filename of the file to open.</param>
        public static void ParseHeader(Replay replay, string filename)
        {
            using (var reader = new BinaryReader(new FileStream(filename, FileMode.Open)))
            {
                byte[] magic  = reader.ReadBytes(3);
                byte   format = reader.ReadByte();

                byte[] buffer      = reader.ReadBytes(4);
                var    dataMaxSize = BitConverter.ToInt32(buffer, 0);

                buffer = reader.ReadBytes(4);
                int headerOffset = BitConverter.ToInt32(buffer, 0);

                buffer = reader.ReadBytes(4);
                int userDataHeaderSize = BitConverter.ToInt32(buffer, 0);

                int dataType = reader.ReadByte(); // Should be 0x05 = Array w/ Keys

                int numElements = ParseVlfNumber(reader);

                // The first value is the words: "Starcraft II Replay 11"
                int index = ParseVlfNumber(reader);

                int type = reader.ReadByte(); // Should be 0x02 = binary data

                int    numValues  = ParseVlfNumber(reader);
                byte[] starcraft2 = reader.ReadBytes(numValues);

                int index2 = ParseVlfNumber(reader);
                int type2  = reader.ReadByte(); // Should be 0x05 = Array w/ Keys

                int numElementsVersion = ParseVlfNumber(reader);
                var version            = new int[numElementsVersion];

                while (numElementsVersion > 0)
                {
                    int i = ParseVlfNumber(reader);
                    int t = reader.ReadByte(); // Type;

                    if (t == 0x09)
                    {
                        // VLF
                        version[i] = ParseVlfNumber(reader);
                    }
                    else if (t == 0x06)
                    {
                        // Byte
                        version[i] = reader.ReadByte();
                    }
                    else if (t == 0x07)
                    {
                        // 4 Bytes
                        version[i] = BitConverter.ToInt32(reader.ReadBytes(4), 0);
                    }

                    numElementsVersion--;
                }

                // We now have the version. Just parse.
                replay.ReplayVersion = string.Format("{0}.{1}.{2}.{3}", version[0], version[1], version[2], version[3]);
                replay.ReplayBuild   = version[4];

                reader.Close();
            }
        }
        public AbilityEvent(BitReader bitReader, Replay replay, Player player, AbilityData abilityData, UnitData unitData)
        {
            uint flags;

            //   1.3.3 patch notes:
            //   - Fixed an issue where the APM statistic could be artificially increased.
            // This adds the "failed" flag, which is triggered usually by holding down a
            // hotkey, leading to key repeat spamming the event throughout a single tick.
            if (replay.ReplayBuild < 18574) // < 1.3.3
            {
                flags = bitReader.Read(17);
            }
            else if (replay.ReplayBuild < 22612) // < 1.5.0
            {
                flags = bitReader.Read(18);
            }
            else
            {
                flags = bitReader.Read(20);
            }
            Queued          = (flags & 2) != 0;
            RightClick      = (flags & 8) != 0;
            WireframeClick  = (flags & 0x20) != 0;
            ToggleAbility   = (flags & 0x40) != 0;
            EnableAutoCast  = (flags & 0x80) != 0;
            AbilityUsed     = (flags & 0x100) != 0;
            WireframeUnload = (flags & 0x200) != 0;
            WireframeCancel = (flags & 0x400) != 0;
            MinimapClick    = (flags & 0x10000) != 0;
            AbilityFailed   = (flags & 0x20000) != 0;

            // flags & 0xf815 -> Debug for unknown flags
            // Never found any across all test data.

            DefaultAbility = (bitReader.Read(1) == 0);
            DefaultActor   = true;
            if (!DefaultAbility)
            {
                AbilityType = abilityData.GetAbilityType(
                    (int)bitReader.Read(16),
                    (int)bitReader.Read(5));
                DefaultActor = (bitReader.Read(1) == 0);
                if (!DefaultActor)
                {   // I'm thinking this would be an array type... but I can't
                    // find anything that causes this bit to be set.
                    throw new InvalidOperationException("Unsupported: non-default actor");
                }
            }
            if (DefaultActor)
            {
                // Deep copy the current wireframe as the actor list
                // -----
                // If a user wants to deal with subgroups to get a more
                // concise actor list, the data is all here.  We're not
                // going to bother, though, because there are several
                // exceptions to account for in determining event actors.
                Actors = new List <Unit>(player.Wireframe.Count);
                foreach (var unit in player.Wireframe)
                {
                    Actors.Add(new Unit(unit));
                }
            }

            var targetType = bitReader.Read(2);

            if (targetType == 1) // Location target
            {
                var targetX = bitReader.Read(20);
                var targetY = bitReader.Read(20);
                var targetZ = bitReader.Read(32);
                TargetLocation = Location.FromEventFormat(targetX, targetY, targetZ);
            }
            else if (targetType == 2) // Unit + Location target
            {
                TargetFlags    = (int)bitReader.Read(8);
                WireframeIndex = (int)bitReader.Read(8);

                var unitId     = (int)bitReader.Read(32);
                var unit       = replay.GetUnitById(unitId);
                var unitTypeId = (int)bitReader.Read(16);
                if (unit == null)
                {
                    var unitType = unitData.GetUnitType(unitTypeId);
                    unit        = new Unit(unitId, unitType);
                    unit.typeId = unitTypeId;
                    replay.GameUnits.Add(unitId, unit);
                }

                TargetUnit = unit;

                var targetHasPlayer = bitReader.Read(1) == 1;
                if (targetHasPlayer)
                {
                    TargetPlayer = (int)bitReader.Read(4);
                }

                // 1.4.0 -- Don't really know what this was meant to fix
                if (replay.ReplayBuild >= 19595)
                {
                    var targetHasTeam = bitReader.Read(1) == 1;
                    if (targetHasTeam)
                    {
                        TargetTeam = (int)bitReader.Read(4);
                    }
                }

                var targetX = bitReader.Read(20);
                var targetY = bitReader.Read(20);
                var targetZ = bitReader.Read(32);
                TargetLocation = Location.FromEventFormat(targetX, targetY, targetZ);
            }
            else if (targetType == 3) // Unit target
            {
                var id = bitReader.Read(32);
                // Again, if the user wants to determine exactly which
                // queue item is canceled in the case of a queue cancel
                // event (the most common case of this target specifier's
                // occurence), they can; however, it requires an additional
                // data structure that I don't want to bother with; however,
                // all the underlying data is available in the events list.
                TargetId = id;
            }

            var lastBit = bitReader.Read(1); // Should be 0; if not, misalignment is likely

            if (!AbilityFailed)
            {
                if (RightClick)
                {
                    this.EventType = GameEventType.RightClick;
                }
                else
                {
                    this.EventType = EventData.GetInstance().GetEventType(this.AbilityType);
                }
            }
            else
            {
                this.EventType = GameEventType.Inactive;
            }
        }
        /// <summary>
        /// Applies the set of attributes to a replay.
        /// </summary>
        /// <param name="replay">Replay to apply the attributes to.</param>
        public void ApplyAttributes(Replay replay)
        {
            // I'm not entirely sure this is the right encoding here. Might be unicode...
            Encoding encoding = Encoding.UTF8;

            var attributes1   = new List <ReplayAttribute>();
            var attributes2   = new List <ReplayAttribute>();
            var attributes3   = new List <ReplayAttribute>();
            var attributes4   = new List <ReplayAttribute>();
            var attributesffa = new List <ReplayAttribute>();

            foreach (var attribute in this.Attributes)
            {
                switch (attribute.AttributeId)
                {
                case PlayerTypeAttribute:     // 500
                {
                    string type = encoding.GetString(attribute.Value.Reverse().ToArray());

                    if (type.ToLower().Equals("comp"))
                    {
                        replay.ClientList[attribute.PlayerId].PlayerType = PlayerType.Computer;
                    }
                    else if (type.ToLower().Equals("humn"))
                    {
                        replay.ClientList[attribute.PlayerId].PlayerType = PlayerType.Human;
                    }
                    else
                    {
                        throw new Exception("Unexpected value");
                    }

                    break;
                }

                case TeamSizeAttribute:
                {
                    // This fixes issues with reversing the string before encoding. Without this, you get "\01v1"
                    var teamSizeChar = encoding.GetString(attribute.Value, 0, 3).Reverse().ToArray();

                    replay.TeamSize = new string(teamSizeChar);
                    break;
                }

                case DifficultyLevelAttribute:
                {
                    string diffLevel = encoding.GetString(attribute.Value.Reverse().ToArray());
                    diffLevel = diffLevel.ToLower();

                    var player = replay.ClientList[attribute.PlayerId];

                    switch (diffLevel)
                    {
                    case "vyey":
                        player.Difficulty = Difficulty.VeryEasy;
                        break;

                    case "easy":
                        player.Difficulty = Difficulty.Easy;
                        break;

                    case "medi":
                        player.Difficulty = Difficulty.Medium;
                        break;

                    case "hard":
                        player.Difficulty = Difficulty.Hard;
                        break;

                    case "vyhd":
                        player.Difficulty = Difficulty.VeryHard;
                        break;

                    case "insa":
                        player.Difficulty = Difficulty.Insane;
                        break;
                    }

                    break;
                }

                case GameSpeedAttribute:
                {
                    string speed = encoding.GetString(attribute.Value.Reverse().ToArray());
                    speed = speed.ToLower();
                    switch (speed)
                    {
                    case "slor":
                        replay.GameSpeed = GameSpeed.Slower;
                        break;

                    case "slow":
                        replay.GameSpeed = GameSpeed.Slow;
                        break;

                    case "norm":
                        replay.GameSpeed = GameSpeed.Normal;
                        break;

                    case "fast":
                        replay.GameSpeed = GameSpeed.Fast;
                        break;

                    case "fasr":
                        replay.GameSpeed = GameSpeed.Faster;
                        break;

                        // Otherwise, Game Speed will remain "Unknown"
                    }

                    break;
                }

                case PlayerRaceAttribute:
                {
                    var race   = encoding.GetString(attribute.Value.Reverse().ToArray()).ToLower();
                    var player = replay.ClientList[attribute.PlayerId];

                    switch (race)
                    {
                    case "prot":
                        player.SelectedRace = Race.Protoss;
                        break;

                    case "zerg":
                        player.SelectedRace = Race.Zerg;
                        break;

                    case "terr":
                        player.SelectedRace = Race.Terran;
                        break;

                    case "rand":
                        player.SelectedRace = Race.Random;
                        break;
                    }

                    break;
                }

                case PlayerTeam1v1Attribute:
                {
                    attributes1.Add(attribute);
                    break;
                }

                case PlayerTeam2v2Attribute:
                {
                    attributes2.Add(attribute);
                    break;
                }

                case PlayerTeam3v3Attribute:
                {
                    attributes3.Add(attribute);
                    break;
                }

                case PlayerTeam4v4Attribute:
                {
                    attributes4.Add(attribute);
                    break;
                }

                case PlayerTeamFFAAttribute:
                {
                    attributesffa.Add(attribute);
                    break;
                }


                case GameTypeAttribute:
                {
                    string gameTypeStr = encoding.GetString(attribute.Value.Reverse().ToArray());
                    gameTypeStr = gameTypeStr.ToLower().Trim('\0');

                    switch (gameTypeStr)
                    {
                    case "priv":
                        replay.GameType = GameType.Private;
                        break;

                    case "amm":
                        replay.GameType = GameType.Open;
                        break;
                    }

                    break;
                }
                }
            }

            List <ReplayAttribute> currentList = null;

            if (replay.TeamSize.Equals("1v1"))
            {
                currentList = attributes1;
            }
            else if (replay.TeamSize.Equals("2v2"))
            {
                currentList = attributes2;
            }
            else if (replay.TeamSize.Equals("3v3"))
            {
                currentList = attributes3;
            }
            else if (replay.TeamSize.Equals("4v4"))
            {
                currentList = attributes4;
            }
            else if (replay.TeamSize.Equals("FFA"))
            {
                currentList = attributesffa;
            }

            if (currentList != null)
            {
                foreach (var att in currentList)
                {
                    // Reverse the values then parse, you don't notice the effects of this until theres 10+ teams o.o
                    var team = encoding.GetString(att.Value.Reverse().ToArray()).Trim('\0', 'T');
                    replay.ClientList[att.PlayerId].Team = int.Parse(team);
                }
            }

            // Skipping parsing the handicap, colors, and handicap since this is parsed elsewhere.
        }
        public static List<IGameEvent> Parse(Replay replay, byte[] buffer)
        {
            // The GameEvent file changes significantly after 16561.
            // This is sometime around the first patch after release. Since
            // parsing replays this old should be extremely rare, I don't believe
            // its worth the effort to try to support both. If it is, it should be
            // done in another method.
            if (replay.ReplayBuild < 16561)
            {
                throw new NotSupportedException(
                    "Replay builds under 16561 are not supported for parsing GameEvent log.");
            }

            var events = new List<IGameEvent>();

            using (var stream = new MemoryStream(buffer))
            {
                using (var reader = new BinaryReader(stream))
                {
                    var currentTime = 0;
                    var numEvents = 0;

                    while (reader.BaseStream.Position < reader.BaseStream.Length)
                    {
                        bool knownEvent = true;

                        var timestamp = Timestamp.Parse(reader).Value;
                        var nextByte = reader.ReadByte();

                        var eventType = nextByte >> 5; // 3 lowest bits
                        var globalEventFlag = nextByte & 16; // 4th bit
                        var playerId = nextByte & 15; // bits 5-8

                        Player player = null;
                        if (playerId > 0)
                        {
                            player = replay.GetPlayerById(playerId);
                        }

                        var eventCode = reader.ReadByte();

                        currentTime += timestamp;

                        var time = Timestamp.Create(currentTime);

                        numEvents++;

                        switch (eventType)
                        {
                            case 0x00: // initialization
                                switch (eventCode)
                                {
                                    case 0x0B: // Player enters game
                                    case 0x0C: // for build >= 17326
                                    case 0x17:
                                    case 0x1B:
                                    case 0x2B:
                                    case 0x2C:
                                        break;
                                    case 0x05: // game starts
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }

                                break;

                            case 0x01: // Action
                                switch (eventCode)
                                {
                                    case 0x09: // player quits the game
                                        events.Add(new PlayerLeftEvent(player, time));
                                        break;
                                    case 0x1B:
                                    case 0x2B:
                                    case 0x3B:
                                    case 0x4B:
                                    case 0x5B:
                                    case 0x6B:
                                    case 0x7B:
                                    case 0x8B:
                                    case 0x9B:
                                    case 0x0B: // player uses an ability
                                        int ability = -1;
                                        byte firstByte = reader.ReadByte();
                                        byte temp = reader.ReadByte();

                                        if (replay.ReplayBuild >= 18317)
                                        {
                                            byte lastTemp;

                                            ability = reader.Read() << 16 | reader.ReadByte() << 8
                                                      | (lastTemp = reader.ReadByte());

                                            // 18574 should be the correct build? not sure
                                            if ((firstByte & 0x0c) == 0x0c && (firstByte & 1) == 0)
                                            {
                                                reader.ReadBytes(4);
                                            }
                                            else if (temp == 64 || temp == 66)
                                            {
                                                if (lastTemp > 14)
                                                {
                                                    if ((lastTemp & 0x40) != 0)
                                                    {
                                                        reader.ReadBytes(2);
                                                        reader.ReadBytes(4);

                                                        reader.ReadBytes(2);
                                                    }
                                                    else
                                                    {
                                                        reader.ReadBytes(6);
                                                    }
                                                }
                                            }
                                            else if (temp == 8 || temp == 10)
                                            {
                                                reader.ReadBytes(7);
                                            }
                                            else if (temp == 136 || temp == 138)
                                            {
                                                reader.ReadBytes(15);
                                            }
                                            /*
                                            {
                                                    if ((temp & 0x80) == 0x80)
                                                    {
                                                        reader.ReadBytes(8);
                                                    }

                                                    reader.ReadBytes(10);
                                                    ability = 0;
                                                }
                                                else
                                                {
                                                    byte lastTemp;

                                                    ability = reader.Read() << 16 | reader.ReadByte() << 8
                                                              | (lastTemp = reader.ReadByte());

                                                    if ((temp & 0x60) == 0x60)
                                                    {
                                                        reader.ReadBytes(4);
                                                    }
                                                    else
                                                    {
                                                        var flaga = ability & 0xF0; // some kind of flag
                                                        if ((flaga & 0x20) == 0x20)
                                                        {
                                                            reader.ReadBytes(9);
                                                            if ((firstByte & 8) == 8)
                                                            {
                                                                reader.ReadBytes(9);
                                                            }
                                                        }
                                                        else if ((flaga & 0x10) == 0x10)
                                                        {
                                                            reader.ReadBytes(9);
                                                        }
                                                        else if ((flaga & 0x40) == 0x40)
                                                        {
                                                            reader.ReadBytes(18);
                                                        }
                                                    }
                                                }
                                            }
                                            */
                                            if (ability != -1)
                                            {
                                                events.Add(
                                                    new GameEventBase(
                                                        replay.GetPlayerById(playerId), Timestamp.Create(currentTime)));
                                            }
                                        }

                                        if (ability == -1)
                                        {
                                            ability = (reader.ReadByte() << 16) |
                                                            (reader.ReadByte() << 8) |
                                                            (reader.ReadByte() & 0x3F);

                                            if (temp == 0x20 || temp == 0x22)
                                            {
                                                var nByte = ability & 0xFF;

                                                if (nByte > 0x07)
                                                {
                                                    if (firstByte == 0x29 || firstByte == 0x19)
                                                    {
                                                        reader.ReadBytes(4); // Advance 4 bytes.
                                                        break;
                                                    }

                                                    reader.ReadBytes(9);

                                                    if ((nByte & 0x20) > 0)
                                                    {
                                                        reader.ReadBytes(9);
                                                    }
                                                }
                                            }
                                            else if (temp == 0x48 || temp == 0x4A)
                                            {
                                                reader.ReadBytes(7);
                                            }
                                            else if (temp == 0x88 || temp == 0x8A)
                                            {
                                                reader.ReadBytes(15);
                                            }

                                            if ((temp & 0x20) != 0)
                                            {
                                                // TODO: Record player ability.
                                                // This is wrong, right?
                                                events.Add(new GameEventBase(replay.GetPlayerById(playerId), Timestamp.Create(currentTime)));
                                            }

                                            events.Add(new GameEventBase(replay.GetPlayerById(playerId), Timestamp.Create(currentTime)));
                                        }

                                        break;
                                    case 0x0C: // automatic update of hotkey?
                                    case 0x1C:
                                    case 0x2C:
                                    case 0x3C: // 01 01 01 01 11 01 03 02 02 38 00 01 02 3c 00 01 00
                                    case 0x4C: // 01 02 02 01 0d 00 02 01 01 a8 00 00 01
                                    case 0x5C: // 01 01 01 01 16 03 01 01 03 18 00 01 00
                                    case 0x6C: // 01 04 08 01 03 00 02 01 01 34 c0 00 01
                                    case 0x7C: // 01 05 10 01 01 10 02 01 01 1a a0 00 01
                                    case 0x8C:
                                    case 0x9C:
                                    case 0xAC: // player changes selection
                                        if (replay.ReplayBuild >= 16561)
                                        {
                                            int bitmask = 0;
                                            byte nByte = 0;
                                            reader.ReadByte(); // skip flag byte
                                            var deselectFlags = reader.ReadByte();
                                            if ((deselectFlags & 3) == 1)
                                            {
                                                nByte = reader.ReadByte();
                                                var deselectionBits = (deselectFlags & 0xFC) | (nByte & 3);
                                                while (deselectionBits > 6)
                                                {
                                                    nByte = reader.ReadByte();
                                                    deselectionBits -= 8;
                                                }
                                                deselectionBits += 2;
                                                deselectionBits = deselectionBits % 8;

                                                bitmask = (int)Math.Pow(2, deselectionBits) - 1;
                                            }
                                            else if ((deselectFlags & 3) == 2 || (deselectFlags & 3) == 3)
                                            {
                                                nByte = reader.ReadByte();
                                                var deselectionBytes = (deselectFlags & 0xFC) | (nByte & 3);
                                                while (deselectionBytes > 0)
                                                {
                                                    nByte = reader.ReadByte();
                                                    deselectionBytes--;
                                                }

                                                bitmask = 3;
                                            }
                                            else if ((deselectFlags & 3) == 0)
                                            {
                                                bitmask = 3;
                                                nByte = deselectFlags;
                                            }

                                            int numUnitTypeIDs = 0;

                                            var prevByte = nByte;
                                            nByte = reader.ReadByte();

                                            if (bitmask > 0)
                                            {
                                                numUnitTypeIDs = (prevByte & (0xFF - bitmask)) | (nByte & bitmask);
                                            }
                                            else
                                            {
                                                numUnitTypeIDs = nByte;
                                            }

                                            for (int i = 0; i < numUnitTypeIDs; i++)
                                            {
                                                int unitTypeID = 0;
                                                int unitTypeCount = 0;

                                                for (int j = 0; j < 3; j++)
                                                {
                                                    byte by = 0;

                                                    prevByte = nByte;
                                                    nByte = reader.ReadByte();

                                                    if (bitmask > 0) // Line 610 of sc2replay.php
                                                    {
                                                        by = (byte)((prevByte & (0xFF - bitmask)) | (nByte & bitmask));
                                                    }
                                                    else
                                                    {
                                                        by = nByte;
                                                    }

                                                    unitTypeID = by << ((2 - j) * 8) | unitTypeID;
                                                }

                                                prevByte = nByte;
                                                nByte = reader.ReadByte();

                                                if (bitmask > 0)
                                                {
                                                    unitTypeCount = (prevByte & (0xFF - bitmask)) | (nByte & bitmask);
                                                }
                                                else
                                                {
                                                    unitTypeCount = nByte;
                                                }

                                                // $uType[$i + 1]['count'] = $unitTypeCount;
                                                // $uType[$i + 1]['id'] = $unitTypeID;
                                            }

                                            var numUnits = 0;
                                            prevByte = nByte;
                                            nByte = reader.ReadByte();
                                            if (bitmask > 0)
                                            {
                                                numUnits = (prevByte & (0xFF - bitmask)) | (nByte & bitmask);
                                            }
                                            else
                                            {
                                                numUnits = nByte;
                                            }

                                            for (int i = 0; i < numUnits; i++)
                                            {
                                                var unitID = 0;
                                                byte by = 0;

                                                for (int j = 0; j < 4; j++)
                                                {
                                                    prevByte = nByte;
                                                    nByte = reader.ReadByte();

                                                    if (bitmask > 0)
                                                    {
                                                        by =
                                                            (byte)((prevByte & (0xFF - bitmask)) | (nextByte & bitmask));
                                                    }
                                                    else
                                                    {
                                                        by = nByte;
                                                    }

                                                    if (j < 2)
                                                    {
                                                        unitID = (by << ((1 - j) * 8)) | unitID;
                                                    }
                                                }

                                                // TODO: Record unitID
                                                // unitIDs[] = unitID;
                                            }

                                            var a = 0;

                                            //foreach($uType as $unitType){
                                            //for($i = 1; $i <= $unitType['count']; $i++){
                                            //    $uid = $unitIDs[$a];
                                            //    //Bytes 3 + 4 contain flag info (perhaps same as in 1.00)
                                            //    $this->addSelectedUnit($uid, $unitType['id'], $playerId, floor($time / 16));
                                            //    if ($this->debug) {
                                            //        $this->debug(sprintf("  0x%06X -> 0x%04X", $unitType['id'], $uid));
                                            //    }
                                            //    $a++;
                                            //}

                                            if (eventCode == 0xAC)
                                            {
                                                events.Add(new GameEventBase(replay.GetPlayerById(playerId), Timestamp.Create(currentTime)));
                                                // $this->addPlayerAction($playerId, floor($time / 16));
                                            }

                                            break;
                                        } // sc2replay.php: Line 666

                                        throw new NotSupportedException("Event logic for builds < 16561 not implemented");
                                    case 0x0D: // manually uses hotkey
                                    case 0x1D:
                                    case 0x2D:
                                    case 0x3D:
                                    case 0x4D:
                                    case 0x5D:
                                    case 0x6D:
                                    case 0x7D:
                                    case 0x8D:
                                    case 0x9D: // sc2replay.php: Line 802
                                        HotkeyEvent hotkey = new HotkeyEvent(player, time);
                                        hotkey.Key = eventCode >> 4;
                                        var byte1 = reader.ReadByte();

                                        int flag = byte1 & 0x03;
                                        hotkey.Action = flag;

                                        if (flag == 2)
                                        {
                                            hotkey.EventType = GameEventType.Selection;
                                        }

                                        byte byte2 = 0;

                                        if ((byte1 < 16) && ((byte1 & 0x8) == 8))
                                        {
                                            byte b2 = (byte)(reader.ReadByte() & 0xF);
                                            reader.ReadBytes(b2);
                                        }
                                        else if (byte1 > 4)
                                        {
                                            int j;
                                            if (byte1 < 8)
                                            {
                                                j = reader.ReadByte();
                                                if ((j & 0x7) > 4)
                                                {
                                                    reader.ReadByte();
                                                }
                                                if ((j & 0x8) != 0)
                                                {
                                                    reader.ReadByte();
                                                }
                                            }
                                            else
                                            {
                                                j = reader.ReadByte();
                                                int shift = (byte1 >> 3) + ((j & 0xF) > 4 ? 1 : 0) +
                                                            ((j & 0xF) > 12 ? 1 : 0);
                                                reader.ReadBytes(shift);

                                                if (replay.ReplayBuild >= 18574)
                                                {
                                                    if (byte1 == 30 && j == 1)
                                                    {
                                                        reader.ReadBytes(14);
                                                    }
                                                }
                                            }
                                        }

                                        events.Add(hotkey);
                                        break;
                                    case 0x1F: // send resources
                                    case 0x2F:
                                    case 0x3F:
                                    case 0x4F:
                                    case 0x5F:
                                    case 0x6F:
                                    case 0x7F:
                                    case 0x8F:
                                        reader.ReadByte(); // 0x84
                                        var sender = playerId;
                                        var receiver = (eventCode & 0xF0) >> 4;
                                        // sent minerals
                                        var bytes = reader.ReadBytes(4);
                                        var mineralValue = (((bytes[0] << 20) | (bytes[1] << 12) | bytes[2] << 4 ) >> 1) + (bytes[3] & 0x0F);

                                        // sent gas
                                        bytes = reader.ReadBytes(4);
                                        var gasValue = (((bytes[0] << 20) | (bytes[1] << 12) | bytes[2] << 4 ) >> 1) + (bytes[3] & 0x0F);

                                        // last 8 bytes are unknown
                                        reader.ReadBytes(8);
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }
                                break;
                            case 0x02: // weird
                                switch (eventCode)
                                {
                                    case 0x06:
                                        reader.ReadBytes(8);
                                        break;
                                    case 0x07:
                                        reader.ReadBytes(4);
                                        break;
                                    case 0x49:
                                        // Unknown...
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }
                                break;
                            case 0x03: // replay
                                switch (eventCode)
                                {
                                    case 0x87:
                                        reader.ReadBytes(8);
                                        break;
                                    case 0x08:
                                        reader.ReadBytes(10);
                                        break;
                                    case 0x18:
                                        reader.ReadBytes(162);
                                        break;
                                    case 0x01: // camera movement
                                    case 0x11:
                                    case 0x21:
                                    case 0x31:
                                    case 0x41:
                                    case 0x51:
                                    case 0x61:
                                    case 0x71:
                                    case 0x81:
                                    case 0x91:
                                    case 0xA1:
                                    case 0xB1:
                                    case 0xC1:
                                    case 0xD1:
                                    case 0xE1:
                                    case 0xF1:
                                        reader.ReadBytes(3);
                                        var nByte = reader.ReadByte();

                                        var aByte = nByte & 0x70;
                                        switch (aByte)
                                        {
                                            case 0x10: // zoom camera up or down
                                            case 0x20:
                                            case 0x30: // only 0x10 matters, but due to 0x70 mask in comparison, check for this too
                                            case 0x40: // rotate camera
                                            case 0x50:

                                                if (aByte == 0x10 || aByte == 0x30 || aByte == 0x50)
                                                {
                                                    reader.ReadByte();
                                                    nByte = reader.ReadByte();
                                                }

                                                if (aByte != 0x40)
                                                {
                                                    if ((nByte & 0x20) > 0)
                                                    {
                                                        // zooming, if comparison is 0 max/min zoom reached
                                                        reader.ReadByte();
                                                        nByte = reader.ReadByte();
                                                    }

                                                    if ((nByte & 0x40) == 0) break;
                                                }

                                                reader.ReadBytes(2);
                                                //events.Add(new PlayerEvent(playerId, currentTime));
                                                break;
                                        }
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }
                                break;
                            case 0x04: // inaction
                                if ((eventCode & 0x0F) == 2)
                                {
                                    reader.ReadBytes(2);
                                    break;
                                }

                                if ((eventCode & 0x0C) == 2)
                                {
                                    break;
                                }

                                if ((eventCode & 0x0F) == 12)
                                {
                                    break;
                                }

                                switch(eventCode)
                                {
                                    case 0x16:
                                        reader.ReadBytes(24);
                                        break;
                                    case 0xC6:
                                        reader.ReadBytes(16);
                                        break;
                                    case 0x18:
                                        reader.ReadBytes(4);
                                        break;
                                    case 0x87:
                                        reader.ReadBytes(4);
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }

                                break;
                            case 0x05: // system
                                switch (eventCode)
                                {
                                    case 0x89: // automatic sync?
                                        reader.ReadBytes(4);
                                        break;
                                    default:
                                        knownEvent = false;
                                        break;
                                }

                                break;
                            default:
                                knownEvent = false;
                                break;
                        }

                        if (knownEvent == false)
                        {
                            Debug.WriteLine("Unknown Event: " + eventCode + "," + currentTime + "," + eventType);
                            throw new FormatException("An unknown event prevented the events file from being correctly parsed.");
                        }
                    }
                }
            }

            return events;
        }
        public static List<IGameEvent> Parse(Replay replay, byte[] buffer)
        {
            // The GameEvent file changes significantly after 16561.
            // This is sometime around the first patch after release. Since
            // parsing replays this old should be extremely rare, I don't believe
            // its worth the effort to try to support both. If it is, it should be
            // done in another method.
            //
            // Still a bitstream, but stuff's moved around and event codes are different.
            if (replay.ReplayBuild < 16561)
            {
                throw new NotSupportedException(
                    "Replay builds under 16561 are not supported for parsing GameEvent log.");
            }

            // Initialize Ability and Unit data.
            var effectiveBuild = BuildData.GetInstance().GetEffectiveBuild(replay.ReplayBuild);
            if (effectiveBuild == 0)
            {
                throw new NotSupportedException(
                    String.Format("Replay build {0} is not supported by the current event database", replay.ReplayBuild));
            }
            var abilityData = new AbilityData(effectiveBuild);
            var unitData = new UnitData(effectiveBuild);

            var events = new List<IGameEvent>();

            // Keep a reference to know the game length.
            var ticksElapsed = 0;

            using (var stream = new MemoryStream(buffer))
            {
                var bitReader = new BitReader(stream);

                var playersGone = new bool[0x10];

                while (!bitReader.EndOfStream)
                {
                    var intervalLength = 6 + (bitReader.Read(2) << 3);
                    var interval = bitReader.Read(intervalLength);
                    ticksElapsed += (int)interval;
                    var playerIndex = (int)bitReader.Read(5);
                    Player player;
                    if (playerIndex < 0x10)
                    {
                        player = replay.GetPlayerById(playerIndex);
                    }
                    else
                    {
                        player = Player.Global;
                    }

                    var eventType = bitReader.Read(7);
                    IGameEvent gameEvent;
                    switch (eventType)
                    {
                        case 0x05: // Game start
                            gameEvent = new GameStartEvent();
                            break;
                        case 0x0b:
                        case 0x0c: // Join game
                            gameEvent = new PlayerJoinEvent(bitReader, replay, playerIndex);
                            break;
                        case 0x19: // Leave game
                            gameEvent = new PlayerLeftEvent(player);
                            playersGone[playerIndex] = true;
                            DetectWinners(playersGone, replay);
                            break;
                        case 0x1b: // Ability
                            gameEvent = new AbilityEvent(bitReader, replay, player, abilityData, unitData);
                            break;
                        case 0x1c: // Selection
                            gameEvent = new SelectionEvent(bitReader, replay, player, unitData);
                            break;
                        case 0x1d: // Control groups
                            gameEvent = new HotkeyEvent(bitReader, replay, player);
                            break;
                        case 0x1f: // Send resources
                            gameEvent = new SendResourcesEvent(bitReader, replay);
                            break;
                        case 0x23: // ??
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            bitReader.Read(8);
                            break;
                        case 0x26: // ??
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            bitReader.Read(32);
                            bitReader.Read(32);
                            break;
                        case 0x27: // Target critter - special
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Selection;
                            var unitId = bitReader.Read(32);
                            break;
                        case 0x31: // Camera
                            gameEvent = new CameraEvent(bitReader, replay);
                            break;
                        case 0x37: // UI Event
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Other;
                            bitReader.Read(32);
                            bitReader.Read(32);
                            break;
                        case 0x38: // weird sync event
                            {
                                gameEvent = new GameEventBase();
                                gameEvent.EventType = GameEventType.Other;
                                for (var j = 0; j < 2; j++)
                                {
                                    var length = bitReader.Read(8);
                                    for (var i = 0; i < length; i++)
                                    {
                                        bitReader.Read(32);
                                    }
                                }
                                break;
                            }
                        case 0x3c: // ???
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            bitReader.Read(16);
                            break;
                        case 0x46: // Request resources
                            gameEvent = new RequestResourcesEvent(bitReader, replay);
                            break;
                        case 0x47: // ?? -- associated with send minerals
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            bitReader.Read(32);
                            break;
                        case 0x48: // ?? -- sync event
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            bitReader.Read(32);
                            break;
                        case 0x4C: // ?? -- seen with spectator
                            bitReader.Read(4);
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            break;
                        case 0x59: // ?? -- sync flags maybe?
                            bitReader.Read(32);
                            gameEvent = new GameEventBase();
                            gameEvent.EventType = GameEventType.Inactive;
                            break;
                        default: // debug
                            throw new InvalidOperationException(String.Format(
                                "Unknown event type {0:x} at {1:x} in replay.game.events",
                                eventType, bitReader.Cursor));
                    }

                    gameEvent.Player = player;
                    gameEvent.Time = Timestamp.Create(ticksElapsed);
                    events.Add(gameEvent);

                    bitReader.AlignToByte();
                }
            }

            replay.GameLength = Timestamp.Create(ticksElapsed).TimeSpan;

            return events;
        }
        /// <summary> Parses a .SC2Replay file and returns relevant replay information.  </summary>
        /// <param name="fileName"> Full path to a .SC2Replay file.  </param>
        /// <param name="noEvents"> True if you don't want to parse events (uses about 5~10 MB on a pro replay, half on an amateur replay) </param>
        /// <returns> Returns the fully parsed Replay object. </returns>
        public static Replay Parse(string fileName, bool noEvents = false)
        {
            if (File.Exists(fileName) == false)
            {
                throw new FileNotFoundException("The specified file does not exist.", fileName);
            }

            var replay = new Replay();

            // File in the version numbers for later use.
            MpqHeader.ParseHeader(replay, fileName);

            CArchive archive;

            try
            {
                archive = new CArchive(fileName);
            }
            catch (IOException)
            {
                // Usually thrown if the archive name contains korean. Copy it to a local file and open.
                var tmpPath = Path.GetTempFileName();

                File.Copy(fileName, tmpPath, true);

                archive = new CArchive(tmpPath);
            }

            try
            {
                var files = archive.FindFiles("replay.*");
                {
                    const string CurFile = "replay.initData";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayInitData.Parse(replay, buffer);
                }

                {
                    // Local scope allows the byte[] to be GC sooner, and prevents misreferences
                    const string CurFile = "replay.details";

                    var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayDetails.Parse(replay, buffer);
                }

                {
                    const string CurFile  = "replay.attributes.events";
                    var          fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);

                    ReplayAttributeEvents.Parse(replay, buffer);
                }

                {
                    const string CurFile  = "replay.message.events";
                    var          fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                    var buffer = new byte[fileSize];

                    archive.ExportFile(CurFile, buffer);
                    try
                    {
                        replay.ChatMessages = ReplayMessageEvents.Parse(buffer);
                    }
                    catch // Chat may have been removed without maintaining the structure
                          // Example:  LiquidHayPro vs MFTarga.SC2Replay from TLPro pack #36
                          // You can see a date on the file in MPQ editor, and viewing the
                          // replay in SC2 results in no chat at all.
                    {
                        replay.ChatMessages = new List <ChatMessage>();
                    }
                }

                try
                {
                    if (!noEvents)
                    {
                        const string CurFile = "replay.game.events";

                        var fileSize = (from f in files where f.FileName.Equals(CurFile) select f).Single().Size;

                        var buffer = new byte[fileSize];

                        archive.ExportFile(CurFile, buffer);

                        replay.PlayerEvents = ReplayGameEvents.Parse(replay, buffer);
                    }
                }
                catch (Exception)
                {
                    // Likely to happen with any non-standard (i.e. format isn't melee nvn, locked alliances) replay.
                }
            }
            finally
            {
                archive.Dispose();
            }

            replay.Timestamp = File.GetCreationTime(fileName);

            return(replay);
        }
Beispiel #26
0
        public HotkeyEvent(BitReader bitReader, Replay replay, Player player)
        {
            int wireframeLength = 8;

            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }
            this.EventType = GameEventType.Selection;

            ControlGroup = (int)bitReader.Read(4);

            // throws
            ActionType = (HotkeyActionType)(int)bitReader.Read(2);

            var updateType = (int)bitReader.Read(2);

            // This is an internal update that is somewhat asynchronous to
            // the main wireframe.
            var unitsRemovedList = new List <Unit>();

            if (updateType == 1) // Remove by flags
            {
                var numBits        = (int)bitReader.Read(wireframeLength);
                var unitsRemoved   = new bool[numBits];
                var wireframeIndex = 0;

                while (numBits >= 8)
                {
                    numBits -= 8;
                    var flags = bitReader.Read(8);
                    for (int i = 0; i < 8; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += 8;
                }
                if (numBits != 0)
                {
                    var flags = bitReader.Read(numBits);
                    for (int i = 0; i < numBits; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += numBits;
                }

                for (int i = 0; i < wireframeIndex; i++)
                {
                    if (unitsRemoved[i])
                    {
                        unitsRemovedList.Add(player.Hotkeys[ControlGroup][i]);
                    }
                }
            }
            else if (updateType == 2)
            {
                var numIndices = (int)bitReader.Read(wireframeLength);
                for (int i = 0; i < numIndices; i++)
                {
                    unitsRemovedList.Add(player.Hotkeys[ControlGroup][(int)bitReader.Read(wireframeLength)]);
                }
            }
            else if (updateType == 3) // Replace control group with portion of control group
            {
                // This happens fairly rarely, so I'll just invert the output
                unitsRemovedList = new List <Unit>(player.Hotkeys[ControlGroup]);

                var numIndices = (int)bitReader.Read(wireframeLength);
                for (int i = 0; i < numIndices; i++)
                {
                    unitsRemovedList.Remove(player.Hotkeys[ControlGroup][(int)bitReader.Read(wireframeLength)]);
                }
            }

            if (ActionType == HotkeyActionType.AddToControlGroup)
            {
                var         oldControlgroup = player.Hotkeys[ControlGroup];
                List <Unit> newControlgroup;
                if (oldControlgroup != null)
                {
                    newControlgroup = new List <Unit>(player.Wireframe.Count + oldControlgroup.Count);

                    foreach (Unit unit in oldControlgroup)
                    {
                        newControlgroup.Add(unit);
                    }
                }
                else
                {
                    newControlgroup = new List <Unit>(player.Wireframe.Count);
                }

                foreach (Unit unit in player.Wireframe)
                {
                    if (oldControlgroup == null || !oldControlgroup.Contains(unit))
                    {
                        newControlgroup.Add(unit);
                    }
                }
                newControlgroup.Sort((m, n) => m.Id - n.Id);

                player.Hotkeys[ControlGroup] = newControlgroup;
            }
            else if (ActionType == HotkeyActionType.SelectControlGroup)
            {
                player.Wireframe = new List <Unit>(player.Hotkeys[ControlGroup]);

                // Only see these two together because of the nature of it
                foreach (Unit unit in unitsRemovedList)
                {
                    player.Wireframe.Remove(unit);
                }
            }
            else if (ActionType == HotkeyActionType.SetControlGroup)
            {
                player.Hotkeys[ControlGroup] = new List <Unit>(player.Wireframe);
            }

            // Copy ref list to property.  Idk if this is a great idea, but it's likely
            // never more than 30 ish dwords per event?  Can't be more than another meg
            // or three per replay.  i.e. Can't be more than lolJava.
            ControlGroupUnits = new List <Unit>(player.Hotkeys[ControlGroup]);
        }
        private static void DetectWinners(bool[] playersGone, Replay replay)
        {
            var teamsStillActive = new bool[0x10];
            for (var i = 0; i < playersGone.Length; i++)
            {
                var player = replay.GetPlayerById(i);
                if (player != null && // player exists
                    player.Team != 0 && // player is not neutral
                    // -- Technically player team is 16 for spectators I think, but not defined here => 0
                    player.PlayerType != PlayerType.Spectator && // player is playing
                    playersGone[i] == false) // player is still in-game
                {
                    teamsStillActive[player.Team] = true;
                }
            }

            var winCandidate = 0;
            for (var i = 1; i < 0x10; i++)
            {
                if (teamsStillActive[i] && winCandidate == 0)
                {
                    winCandidate = i;
                }
                else if (teamsStillActive[i]) // .Count(n=>n) > 0
                {
                    winCandidate = -1;
                }
            }

            if (winCandidate > 0)
            {
                foreach (var player in replay.ClientList)
                {
                    if (player != null && player.Team == winCandidate)
                    {
                        player.IsWinner = true;
                    }
                }
            }
        }
        public HotkeyEvent(BitReader bitReader, Replay replay, Player player)
        {
            int wireframeLength = 8;
            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }
            this.EventType = GameEventType.Selection;

            ControlGroup = (int)bitReader.Read(4);

            // throws
            ActionType = (HotkeyActionType)(int)bitReader.Read(2);

            var updateType = (int)bitReader.Read(2);

            // This is an internal update that is somewhat asynchronous to
            // the main wireframe.
            var unitsRemovedList = new List<Unit>();
            if (updateType == 1) // Remove by flags
            {
                var numBits = (int)bitReader.Read(wireframeLength);
                var unitsRemoved = new bool[numBits];
                var wireframeIndex = 0;

                while (numBits >= 8)
                {
                    numBits -= 8;
                    var flags = bitReader.Read(8);
                    for (int i = 0; i < 8; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += 8;
                }
                if (numBits != 0)
                {
                    var flags = bitReader.Read(numBits);
                    for (int i = 0; i < numBits; i++)
                    {
                        unitsRemoved[wireframeIndex + i] = (flags & (1 << i)) != 0;
                    }
                    wireframeIndex += numBits;
                }

                for (int i = 0; i < wireframeIndex; i++)
                {
                    if (unitsRemoved[i])
                    {
                        unitsRemovedList.Add(player.Hotkeys[ControlGroup][i]);
                    }
                }
            }
            else if (updateType == 2)
            {
                var numIndices = (int)bitReader.Read(wireframeLength);
                for (int i = 0; i < numIndices; i++)
                {
                    unitsRemovedList.Add(player.Hotkeys[ControlGroup][(int)bitReader.Read(wireframeLength)]);
                }
            }
            else if (updateType == 3) // Replace control group with portion of control group
            {
                // This happens fairly rarely, so I'll just invert the output
                unitsRemovedList = new List<Unit>(player.Hotkeys[ControlGroup]);

                var numIndices = (int)bitReader.Read(wireframeLength);
                for (int i = 0; i < numIndices; i++)
                {
                    unitsRemovedList.Remove(player.Hotkeys[ControlGroup][(int)bitReader.Read(wireframeLength)]);
                }
            }

            if (ActionType == HotkeyActionType.AddToControlGroup)
            {
                var oldControlgroup = player.Hotkeys[ControlGroup];
                List<Unit> newControlgroup;
                if (oldControlgroup != null)
                {
                    newControlgroup = new List<Unit>(player.Wireframe.Count + oldControlgroup.Count);

                    foreach (Unit unit in oldControlgroup)
                    {
                        newControlgroup.Add(unit);
                    }
                }
                else
                {
                    newControlgroup = new List<Unit>(player.Wireframe.Count);
                }

                foreach (Unit unit in player.Wireframe)
                {
                    if (oldControlgroup == null || !oldControlgroup.Contains(unit))
                    {
                        newControlgroup.Add(unit);
                    }
                }
                newControlgroup.Sort((m, n) => m.Id - n.Id);

                player.Hotkeys[ControlGroup] = newControlgroup;
            }
            else if (ActionType == HotkeyActionType.SelectControlGroup)
            {
                player.Wireframe = new List<Unit>(player.Hotkeys[ControlGroup]);

                // Only see these two together because of the nature of it
                foreach (Unit unit in unitsRemovedList)
                {
                    player.Wireframe.Remove(unit);
                }
            }
            else if (ActionType == HotkeyActionType.SetControlGroup)
            {
                player.Hotkeys[ControlGroup] = new List<Unit>(player.Wireframe);
            }

            // Copy ref list to property.  Idk if this is a great idea, but it's likely
            // never more than 30 ish dwords per event?  Can't be more than another meg
            // or three per replay.  i.e. Can't be more than lolJava.
            ControlGroupUnits = new List<Unit>(player.Hotkeys[ControlGroup]);
        }
        /// <summary> Parses the replay.details file, applying it to a Replay object. </summary>
        /// <param name="replay"> The replay object to apply the parsed information to. </param>
        /// <param name="stream"> The stream containing the replay.details file. </param>
        public static void Parse(Replay replay, Stream stream)
        {
            using (var reader = new BinaryReader(stream))
            {
                reader.ReadBytes(6);
                var playerCount = reader.ReadByte() >> 1;

                var players = new Player[playerCount];

                // Parsing Player Info
                for (int i = 0; i < playerCount; i++)
                {
                    var parsedPlayer = PlayerDetails.Parse(reader);

                    // The references between both of these classes are the same on purpose.
                    // We want updates to one to propogate to the other.
                    players[i] = parsedPlayer;
                    replay.ClientList[i + 1] = parsedPlayer;
                }

                replay.Players = players;

                var mapNameLength = KeyValueStruct.Parse(reader).Value;

                var mapBytes = reader.ReadBytes(mapNameLength);

                replay.Map = Encoding.UTF8.GetString(mapBytes);

                var stringLength = KeyValueStruct.Parse(reader).Value;

                // This is typically an empty string, no need to decode.
                var unknownString = reader.ReadBytes(stringLength);

                reader.ReadBytes(3);

                var mapPreviewNameLength = KeyValueStruct.Parse(reader).Value;
                var mapPreviewNameBytes = reader.ReadBytes(mapPreviewNameLength);

                replay.MapPreviewName = Encoding.UTF8.GetString(mapPreviewNameBytes);

                reader.ReadBytes(3);

                var saveTime = KeyValueLongStruct.Parse(reader).Value;
                var saveTimeZone = KeyValueLongStruct.Parse(reader).Value;
                var time = DateTime.FromFileTime(saveTime);

                // Subtract the timezone to get the appropriate UTC time.
                time = time.Subtract(new TimeSpan(saveTimeZone));

                // We create a new timestamp so we can properly set this as UTC time.
                replay.Timestamp = new DateTime(time.Ticks, DateTimeKind.Utc);

                // don't know what the next 14 bytes are for, so we skip them
                reader.ReadBytes(14);

                var resources =  new List<ResourceInfo>();
                reader.ReadBytes(2); // there are 2 bytes before each "s2ma" string
                var s2ma = Encoding.UTF8.GetString(reader.ReadBytes(4));

                while(s2ma == "s2ma") {
                    reader.ReadBytes(2); // 0x00, 0x00

                    resources.Add(new ResourceInfo {
                        Gateway = Encoding.UTF8.GetString(reader.ReadBytes(2)),
                        Hash = reader.ReadBytes(32),
                    });

                    reader.ReadBytes(2);
                    s2ma = Encoding.UTF8.GetString(reader.ReadBytes(4));
                }

                var map = resources.Last();
                replay.MapGateway = map.Gateway;
                replay.MapHash = map.Hash;

                reader.Close();
            }
        }
        /// <summary>
        /// Reads the 8 {16, 8, 8}, 8 {32} struct; the result is in AddedUnits / AddedUnitTypes.
        /// </summary>
        void HandleUnitArrays(BitReader bitReader, Replay replay, UnitData data)
        {
            int wireframeLength = 8;
            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }

            var typesLength = (int)bitReader.Read(wireframeLength);
            AddedUnitTypes = new Dictionary<UnitType, int>(typesLength);

            // Guarantee order is maintained
            var subgroups = new List<KeyValuePair<UnitType, int>>(typesLength);

            for (int i = 0; i < typesLength; i++)
            {
                var unitTypeId = (int)bitReader.Read(16);
                var unitType = data.GetUnitType(unitTypeId);

                var unitSubtype = bitReader.Read(8);
                if (unitSubtype == 2) // hallucination -- cheers, Graylin
                {
                    unitType = data.GetHallucination(unitType);
                }

                var unitCountType = (int)bitReader.Read(wireframeLength);
                if (unitType == UnitType.Unknown && AddedUnitTypes.ContainsKey(UnitType.Unknown))
                {
                    AddedUnitTypes[UnitType.Unknown] += unitCountType;
                }
                else
                {
                    AddedUnitTypes.Add(unitType, unitCountType);
                }
                subgroups.Add(new KeyValuePair<UnitType, int>(unitType, unitCountType));
            }

            var idsLength = (int)bitReader.Read(wireframeLength);
            AddedUnits = AddedUnits ?? new List<Unit>(idsLength);
            if (idsLength == 0) return;

            var subgroupsEnumerator = subgroups.GetEnumerator();

            int currentSubgroupIndex;
            if (subgroupsEnumerator.MoveNext())
            {
                currentSubgroupIndex = subgroupsEnumerator.Current.Value;
            }
            else return;

            for (int i = 0; i < idsLength; i++)
            {
                var unitId = (int)bitReader.Read(32);
                var unit = replay.GetUnitById(unitId);
                var unitType = subgroupsEnumerator.Current.Key;
                if (unit == null)
                {
                    unit = new Unit(unitId, unitType);
                    replay.GameUnits.Add(unitId, unit);
                }
                else
                {
                    unit.UpdateType(unitType);
                }
                AddedUnits.Add(unit);

                if (--currentSubgroupIndex <= 0)
                {
                    if (subgroupsEnumerator.MoveNext())
                    {
                        currentSubgroupIndex = subgroupsEnumerator.Current.Value;
                    }
                }
            }
        }
        /// <summary>
        /// Applies the set of attributes to a replay.
        /// </summary>
        /// <param name="replay">Replay to apply the attributes to.</param>
        public void ApplyAttributes(Replay replay)
        {
            // I'm not entirely sure this is the right encoding here. Might be unicode...
            Encoding encoding = Encoding.UTF8;

            var attributes1 = new List<ReplayAttribute>();
            var attributes2 = new List<ReplayAttribute>();
            var attributes3 = new List<ReplayAttribute>();
            var attributes4 = new List<ReplayAttribute>();
            var attributesffa = new List<ReplayAttribute>();

            foreach (var attribute in this.Attributes)
            {
                switch (attribute.AttributeId)
                {
                    case PlayerTypeAttribute: // 500
                        {
                            string type = encoding.GetString(attribute.Value.Reverse().ToArray());

                            if (type.ToLower().Equals("comp"))
                            {
                                replay.Players[attribute.PlayerId].PlayerType = PlayerType.Computer;
                            }
                            else if (type.ToLower().Equals("humn"))
                            {
                                replay.Players[attribute.PlayerId].PlayerType = PlayerType.Human;
                            }
                            else
                            {
                                throw new Exception("Unexpected value");
                            }

                            break;
                        }

                    case TeamSizeAttribute:
                        {
                            // This fixes issues with reversing the string before encoding. Without this, you get "\01v1"
                            var teamSizeChar = encoding.GetString(attribute.Value, 0, 3).Reverse().ToArray();

                            replay.TeamSize = new string(teamSizeChar);
                            break;
                        }

                    case DifficultyLevelAttribute:
                        {
                            string diffLevel = encoding.GetString(attribute.Value.Reverse().ToArray());
                            diffLevel = diffLevel.ToLower();

                            var player = replay.Players[attribute.PlayerId];

                            switch (diffLevel)
                            {
                                case "vyey":
                                    player.Difficulty = Difficulty.VeryEasy;
                                    break;
                                case "easy":
                                    player.Difficulty = Difficulty.Easy;
                                    break;
                                case "medi":
                                    player.Difficulty = Difficulty.Medium;
                                    break;
                                case "hard":
                                    player.Difficulty = Difficulty.Hard;
                                    break;
                                case "vyhd":
                                    player.Difficulty = Difficulty.VeryHard;
                                    break;
                                case "insa":
                                    player.Difficulty = Difficulty.Insane;
                                    break;
                            }

                            break;
                        }

                    case GameSpeedAttribute:
                        {
                            string speed = encoding.GetString(attribute.Value.Reverse().ToArray());
                            speed = speed.ToLower();
                            switch (speed)
                            {
                                case "slor":
                                    replay.GameSpeed = GameSpeed.Slower;
                                    break;
                                case "slow":
                                    replay.GameSpeed = GameSpeed.Slow;
                                    break;
                                case "norm":
                                    replay.GameSpeed = GameSpeed.Normal;
                                    break;
                                case "fast":
                                    replay.GameSpeed = GameSpeed.Fast;
                                    break;
                                case "fasr":
                                    replay.GameSpeed = GameSpeed.Faster;
                                    break;

                                // Otherwise, Game Speed will remain "Unknown"
                            }

                            break;
                        }

                    case PlayerRaceAttribute:
                        {
                            var race = encoding.GetString(attribute.Value.Reverse().ToArray()).ToLower();
                            var player = replay.Players[attribute.PlayerId];

                            switch (race)
                            {
                                case "prot":
                                    player.SelectedRace = Race.Protoss;
                                    break;
                                case "zerg":
                                    player.SelectedRace = Race.Zerg;
                                    break;
                                case "terr":
                                    player.SelectedRace = Race.Terran;
                                    break;
                                case "rand":
                                    player.SelectedRace = Race.Random;
                                    break;
                            }

                            break;
                        }

                    case PlayerTeam1v1Attribute:
                        {
                            attributes1.Add(attribute);
                            break;
                        }

                    case PlayerTeam2v2Attribute:
                        {
                            attributes2.Add(attribute);
                            break;
                        }

                    case PlayerTeam3v3Attribute:
                        {
                            attributes3.Add(attribute);
                            break;
                        }

                    case PlayerTeam4v4Attribute:
                        {
                            attributes4.Add(attribute);
                            break;
                        }

                    case PlayerTeamFFAAttribute:
                        {
                            attributesffa.Add(attribute);
                            break;
                        }

                    case GameTypeAttribute:
                        {
                            string gameTypeStr = encoding.GetString(attribute.Value.Reverse().ToArray());
                            gameTypeStr = gameTypeStr.ToLower().Trim('\0');

                            switch (gameTypeStr)
                            {
                                case "priv":
                                    replay.GameType = GameType.Private;
                                    break;
                                case "amm":
                                    replay.GameType = GameType.Open;
                                    break;
                            }

                            break;
                        }

                }
            }

            List<ReplayAttribute> currentList = null;

            if (replay.TeamSize.Equals("1v1"))
            {
                currentList = attributes1;
            }
            else if (replay.TeamSize.Equals("2v2"))
            {
                currentList = attributes2;
            }
            else if (replay.TeamSize.Equals("3v3"))
            {
                currentList = attributes3;
            }
            else if (replay.TeamSize.Equals("4v4"))
            {
                currentList = attributes4;
            }
            else if (replay.TeamSize.Equals("FFA"))
            {
                currentList = attributesffa;
            }

            if (currentList != null)
            {
                foreach (var att in currentList)
                {
                    // Reverse the values then parse, you don't notice the effects of this until theres 10+ teams o.o
                    var team = encoding.GetString(att.Value.Reverse().ToArray()).Trim('\0', 'T');
                    replay.Players[att.PlayerId].Team = int.Parse(team);
                }
            }

            // Skipping parsing the handicap, colors, and handicap since this is parsed elsewhere.
        }
Beispiel #32
0
        /// <summary>
        /// Reads the 8 {16, 8, 8}, 8 {32} struct; the result is in AddedUnits / AddedUnitTypes.
        /// </summary>
        void HandleUnitArrays(BitReader bitReader, Replay replay, UnitData data)
        {
            int wireframeLength = 8;

            if (replay.ReplayBuild >= 22612)
            {
                wireframeLength = 9; // Maximum selection size has been increased to 500, up from 255.
            }

            var typesLength = (int)bitReader.Read(wireframeLength);

            AddedUnitTypes = new Dictionary <UnitType, int>(typesLength);

            // Guarantee order is maintained
            var subgroups = new List <KeyValuePair <UnitType, int> >(typesLength);

            for (int i = 0; i < typesLength; i++)
            {
                var unitTypeId = (int)bitReader.Read(16);
                var unitType   = data.GetUnitType(unitTypeId);

                var unitSubtype = bitReader.Read(8);
                if (unitSubtype == 2) // hallucination -- cheers, Graylin
                {
                    unitType = data.GetHallucination(unitType);
                }

                var unitCountType = (int)bitReader.Read(wireframeLength);
                if (unitType == UnitType.Unknown && AddedUnitTypes.ContainsKey(UnitType.Unknown))
                {
                    AddedUnitTypes[UnitType.Unknown] += unitCountType;
                }
                else
                {
                    AddedUnitTypes.Add(unitType, unitCountType);
                }
                subgroups.Add(new KeyValuePair <UnitType, int>(unitType, unitCountType));
            }

            var idsLength = (int)bitReader.Read(wireframeLength);

            AddedUnits = AddedUnits ?? new List <Unit>(idsLength);
            if (idsLength == 0)
            {
                return;
            }

            var subgroupsEnumerator = subgroups.GetEnumerator();

            int currentSubgroupIndex;

            if (subgroupsEnumerator.MoveNext())
            {
                currentSubgroupIndex = subgroupsEnumerator.Current.Value;
            }
            else
            {
                return;
            }

            for (int i = 0; i < idsLength; i++)
            {
                var unitId   = (int)bitReader.Read(32);
                var unit     = replay.GetUnitById(unitId);
                var unitType = subgroupsEnumerator.Current.Key;
                if (unit == null)
                {
                    unit = new Unit(unitId, unitType);
                    replay.GameUnits.Add(unitId, unit);
                }
                else
                {
                    unit.UpdateType(unitType);
                }
                AddedUnits.Add(unit);

                if (--currentSubgroupIndex <= 0)
                {
                    if (subgroupsEnumerator.MoveNext())
                    {
                        currentSubgroupIndex = subgroupsEnumerator.Current.Value;
                    }
                }
            }
        }