Exemple #1
0
        private void ReceivePlayerAnnounce(PlayerAnnounceMessage message)
        {
            PlayerName = message.PlayerName;

            BroadcastToClients(new PlayerListMessage()
            {
                PlayerName = PlayerName, PlayerNames = AllPlayerNames
            });
        }
Exemple #2
0
        public static void Parse(StormReplay replay, ReadOnlySpan <byte> source)
        {
            if (source.Length <= 1)
            {
                return;
            }

            BitReader bitReader = new BitReader(source, EndianType.BigEndian);

            uint ticksElapsed = 0;

            while (bitReader.Index < source.Length)
            {
                ticksElapsed += bitReader.ReadBits(6 + ((int)bitReader.ReadBits(2) << 3));
                TimeSpan timeStamp = TimeSpan.FromSeconds(ticksElapsed / 16.0);

                int playerIndex = (int)bitReader.ReadBits(5);

                StormMessageEventType messageEventType = (StormMessageEventType)bitReader.ReadBits(4);

                StormMessage?message = null;

                switch (messageEventType)
                {
                case StormMessageEventType.SChatMessage:
                    ChatMessage chatMessage = new ChatMessage
                    {
                        MessageTarget = (StormMessageTarget)bitReader.ReadBits(3), // m_recipient (the target)
                        Message       = bitReader.ReadBlobAsString(11),            // m_string
                    };

                    message = new StormMessage(chatMessage);

                    break;

                case StormMessageEventType.SPingMessage:
                    PingMessage pingMessage = new PingMessage()
                    {
                        MessageTarget = (StormMessageTarget)bitReader.ReadBits(3),                                                                                                   // m_recipient (the target)
                        Point         = new Point((double)(bitReader.ReadInt32Unaligned() - (-2147483648)) / 4096, ((double)bitReader.ReadInt32Unaligned() - (-2147483648)) / 4096), // m_point x and m_point y
                    };

                    message = new StormMessage(pingMessage);

                    break;

                case StormMessageEventType.SLoadingProgressMessage:
                    LoadingProgressMessage loadingProgressMessage = new LoadingProgressMessage()
                    {
                        LoadingProgress = bitReader.ReadInt32Unaligned() - (-2147483648),     // m_progress
                    };

                    message = new StormMessage(loadingProgressMessage);

                    break;

                case StormMessageEventType.SServerPingMessage:
                    break;

                case StormMessageEventType.SReconnectNotifyMessage:
                    bitReader.ReadBits(2);     // m_status; is either a 1 or a 2
                    break;

                case StormMessageEventType.SPlayerAnnounceMessage:
                    PlayerAnnounceMessage playerAnnounceMessage = new PlayerAnnounceMessage()
                    {
                        AnnouncementType = (AnnouncementType)bitReader.ReadBits(2),
                    };

                    switch (playerAnnounceMessage.AnnouncementType)
                    {
                    case AnnouncementType.None:
                        break;

                    case AnnouncementType.Ability:
                        int abilityLink  = bitReader.ReadInt16Unaligned();     // m_abilLink
                        int abilityIndex = (int)bitReader.ReadBits(5);         // m_abilCmdIndex
                        int buttonLink   = bitReader.ReadInt16Unaligned();     // m_buttonLink
                        playerAnnounceMessage.AbilityAnnouncement = new AbilityAnnouncement(abilityIndex, abilityLink, buttonLink);

                        break;

                    case AnnouncementType.Behavior:
                        bitReader.ReadInt16Unaligned();         // m_behaviorLink
                        bitReader.ReadInt16Unaligned();         // m_buttonLink
                        break;

                    case AnnouncementType.Vitals:
                        playerAnnounceMessage.VitalAnnouncement = new VitalAnnouncement((VitalType)(bitReader.ReadInt16Unaligned() - (-32768)));
                        break;

                    default:
                        throw new NotImplementedException();
                    }

                    if (replay.ReplayBuild > 45635)
                    {
                        // m_announceLink
                        bitReader.ReadInt16Unaligned();
                    }

                    bitReader.ReadInt32Unaligned();     // m_otherUnitTag
                    bitReader.ReadInt32Unaligned();     // m_unitTag

                    message = new StormMessage(playerAnnounceMessage);
                    break;

                default:
                    throw new NotImplementedException();
                }

                if (message != null)
                {
                    message.MessageEventType = messageEventType;
                    message.Timestamp        = timeStamp;

                    if (playerIndex != 16)
                    {
                        message.MessageSender = replay.ClientListByUserID[playerIndex];
                    }

                    replay.MessagesInternal.Add(message);
                }

                bitReader.AlignToByte();
            }
        }
Exemple #3
0
        /// <summary> Parses the Replay.Messages.Events file. </summary>
        /// <param name="buffer"> Buffer containing the contents of the replay.messages.events file. </param>
        /// <returns> A list of messages parsed from the buffer. </returns>
        public static void Parse(Replay replay, byte[] buffer)
        {
            if (buffer.Length <= 1)
            {
                // Chat has been removed from this replay
                return;
            }

            var ticksElapsed = 0;

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

                while (!bitReader.EndOfStream)
                {
                    var message = new Message();

                    ticksElapsed     += (int)bitReader.Read(6 + (bitReader.Read(2) << 3));
                    message.Timestamp = new TimeSpan(0, 0, (int)Math.Round(ticksElapsed / 16.0));

                    var playerIndex = (int)bitReader.Read(5);
                    if (playerIndex != 16)
                    {
                        message.MessageSender = replay.ClientListByUserID[playerIndex];
                    }

                    message.MessageEventType = (MessageEventType)bitReader.Read(4);
                    switch (message.MessageEventType)
                    {
                    case MessageEventType.SChatMessage:
                    {
                        ChatMessage chatMessage = new ChatMessage();

                        chatMessage.MessageTarget = (MessageTarget)bitReader.Read(3);                                  // m_recipient (the target)
                        chatMessage.Message       = Encoding.UTF8.GetString(bitReader.ReadBlobPrecededWithLength(11)); // m_string

                        message.ChatMessage = chatMessage;
                        replay.Messages.Add(message);
                        break;
                    }

                    case MessageEventType.SPingMessage:
                    {
                        PingMessage pingMessage = new PingMessage();

                        pingMessage.MessageTarget = (MessageTarget)bitReader.Read(3);         // m_recipient (the target)

                        pingMessage.XCoordinate = bitReader.ReadInt32() - (-2147483648);      // m_point x
                        pingMessage.YCoordinate = bitReader.ReadInt32() - (-2147483648);      // m_point y

                        message.PingMessage = pingMessage;
                        replay.Messages.Add(message);
                        break;
                    }

                    case MessageEventType.SLoadingProgressMessage:
                    {
                        // can be used to keep track of how fast/slow players are loading
                        // also includes players who are reloading the game
                        var progress = bitReader.ReadInt32() - (-2147483648);         // m_progress
                        break;
                    }

                    case MessageEventType.SServerPingMessage:
                    {
                        break;
                    }

                    case MessageEventType.SReconnectNotifyMessage:
                    {
                        bitReader.Read(2);         // m_status; is either a 1 or a 2
                        break;
                    }

                    case MessageEventType.SPlayerAnnounceMessage:
                    {
                        PlayerAnnounceMessage announceMessage = new PlayerAnnounceMessage();

                        announceMessage.AnnouncementType = (AnnouncementType)bitReader.Read(2);

                        switch (announceMessage.AnnouncementType)
                        {
                        case AnnouncementType.None:
                        {
                            break;
                        }

                        case AnnouncementType.Ability:
                        {
                            AbilityAnnouncment ability = new AbilityAnnouncment();
                            ability.AbilityLink  = bitReader.ReadInt16();               // m_abilLink
                            ability.AbilityIndex = (int)bitReader.Read(5);              // m_abilCmdIndex
                            ability.ButtonLink   = bitReader.ReadInt16();               // m_buttonLink

                            announceMessage.AbilityAnnouncement = ability;
                            break;
                        }

                        case AnnouncementType.Behavior:            // no idea what triggers this
                        {
                            bitReader.ReadInt16();                 // m_behaviorLink
                            bitReader.ReadInt16();                 // m_buttonLink
                            break;
                        }

                        case AnnouncementType.Vitals:
                        {
                            VitalAnnouncment vital = new VitalAnnouncment();
                            vital.VitalType = (VitalType)(bitReader.ReadInt16() - (-32768));

                            announceMessage.VitalAnnouncement = vital;
                            break;
                        }

                        default:
                            throw new NotImplementedException();
                        }

                        if (replay.ReplayBuild > 45635)
                        {
                            // m_announceLink
                            bitReader.ReadInt16();
                        }

                        bitReader.ReadInt32();         // m_otherUnitTag
                        bitReader.ReadInt32();         // m_unitTag

                        message.PlayerAnnounceMessage = announceMessage;
                        replay.Messages.Add(message);
                        break;
                    }

                    default:
                        throw new NotImplementedException();
                    }

                    bitReader.AlignToByte();
                }
            }
        }