void OnReplayEvents(ReplayEvents replayEvents)
        {
            using (var dataContext = new CommandServiceDataContext(dbContextOptions))
            {
                var query = dataContext.Events
                            .Where(evt => evt.Seq >= replayEvents.From)
                            .AsQueryable();
                if (replayEvents.To.HasValue)
                {
                    query = query.Where(evt => evt.Seq <= replayEvents.To);
                }

                var events = query
                             .OrderBy(evt => evt.Seq)
                             .ToArray();

                foreach (var @event in events)
                {
                    var message = ConstructMessage <IMessage <object> >(@event);
                    messageQueue.Publish(message);
                }
            }
        }
Esempio n. 2
0
 /// <summary>
 /// Push an event to the replay system for recording.
 /// </summary>
 /// <param name="eventID">The event id to uniquley identify the event type</param>
 /// <param name="state">The state data for the event or null if no state data is required</param>
 public void ReplayRecordEvent(ReplayEvents eventID, ReplayState state = null)
 {
     // Call through
     ReplayRecordEvent((byte)eventID, state);
 }
Esempio n. 3
0
    public IEnumerator FinalKillCam(ReplayEvents killCamEvents)
    {
        mainPlayer.EnableShooting(false);
        yield return(new WaitForSeconds(3));

        enemyManager.KillAllEnemies();

        gameStatus     = GameStatus.KillCam;
        Time.timeScale = 0.5f;
        uiManager.SetScreensActive(gameStatus);

        //init enemies
        Dictionary <long, string> enemyDeathDelay = killCamEvents.killTimes.ToDictionary(item => long.Parse(item.Key), item => item.Value);
        long initialTime = long.Parse(killCamEvents.events.First().Value.First().Key);

        enemyManager.Initialize(killCamEvents.enemies, levels[currentLevel].transform, levels[currentLevel].GetPlayerPads(), true, enemyDeathDelay, initialTime);
        enemyManager.StartGame();
        yield return(enemyManager);

        Dictionary <string, ReplayEvent> events;
        long timestamp;

        foreach (KeyValuePair <string, Dictionary <string, ReplayEvent> > playerEvent in killCamEvents.events)
        {
            var    split   = playerEvent.Key.Split(':');
            string enemyId = split[0];
            string id      = split[1];
            events = playerEvent.Value;

            Debug.Log($"Replaying enemy {enemyId} kill event by player {id}");

            //set camera
            mainCamera.position = allPlayers[id].playerCamera.position;
            mainCamera.rotation = allPlayers[id].playerCamera.rotation;
            mainCamera.SetParent(allPlayers[id].playerCamera, true);

            long prevTime = long.Parse(events.Keys.First());
            foreach (string ts in events.Keys)
            {
                timestamp = long.Parse(ts);
                yield return(new WaitForSeconds((timestamp - prevTime) / 1000f));

                prevTime = timestamp;
                ReplayEvent e = events[ts];
                if (e.type == "remoteState")
                {
                    RemoteStateUpdateReceived(e.remoteState);
                }
                else if (e.type == "enemyKilled")
                {
                    EnemyKilledMessageReceived(e.enemyKilled);
                }
            }

            allPlayers[id].SetShooting(false);
        }


        Time.timeScale = 1f;
        yield return(new WaitForSeconds(3));

        currentLevel++;
        StartCoroutine(TransitionFromLevel(false));
    }
Esempio n. 4
0
 private void KillCamEventsReceived(ReplayEvents replayEvents)
 {
     StartCoroutine(FinalKillCam(replayEvents));
 }
Esempio n. 5
0
        void RequestReplay()
        {
            var replayEvents = new ReplayEvents(seq + 1);

            messageQueue.Publish(replayEvents);
        }