/// <summary>
/// Deserializes all active <see cref="ReplayEvent"/> from the state and dispatches any events to the <see cref="OnReplayEvent(ReplayEvent)"/> handler.
/// </summary>
/// <param name="state">The <see cref="ReplayState"/> to read the variable data from</param>
protected virtual void ReplayDeserializeEvents(ReplayState state)
{
// Read the event size
short size = state.Read16();
// Read all events
for (int i = 0; i < size; i++)
{
// Create the event
ReplayEvent evt = new ReplayEvent();
// Read the event id
evt.eventID = state.ReadByte();
// Read the data size
byte dataSize = state.ReadByte();
// Read the event data
evt.eventData = state.ReadState(dataSize);
try
{
// Trigger the event callback
OnReplayEvent(evt);
}
catch (Exception e)
{
Debug.LogException(e);
}
}
}
/// <summary>
/// Called by the replay system when a replay event has occured.
/// </summary>
/// <param name="replayEvent">The <see cref="ReplayEvent"/> that was triggered</param>
public override void OnReplayEvent(ReplayEvent replayEvent)
{
switch ((ReplayEvents)replayEvent.eventID)
{
// Listen for sound event
case ReplayEvents.PlaySound:
{
// We cannot replay sounds during reverse playback
if (PlaybackDirection == PlaybackDirection.Backward)
{
break;
}
// Require valid source
if (observedAudioSource != null)
{
// Set the audio source to play at the playback speed
observedAudioSource.pitch = ReplayTime.TimeScale;
// Play the audio
observedAudioSource.Play();
}
break;
}
}
}
public void AddEvent(float eventTime, ReplayEvent.EventType eventType)
{
if (_canRecord || Registry.replayViewer.enabled)
{
ReplayEvent newEvent = (ReplayEvent)ScriptableObject.CreateInstance("ReplayEvent");
newEvent.Initialize(eventTime - _startTime, eventType);
_eventList.Add(newEvent);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
JObject obj = JToken.ReadFrom(reader) as JObject;
Type type = Type.GetType(obj["type"].Value <string>());
ReplayEvent replayEvent = Activator.CreateInstance(type) as ReplayEvent;
replayEvent.Deserialize(obj["data"] as JObject);
return(replayEvent);
}
public void AddCustomEvent()
{
var @event = new ReplayEvent();
@event.AdminId = SyncManager.Instance.UserId;
@event.Camera = CameraControl.GetCurrentCameraSessionTime();
@event.Type = ReplayEvent.EventTypes.Interesting;
this.AddEvent(@event);
}
private void UpdateEvent(ReplayEvent @event)
{
var existing = this.State.Events.SingleOrDefault(e => e.Id == @event.Id);
if (existing != null)
{
this.State.Events.Remove(existing);
}
this.State.Events.Add(@event);
}
IEnumerator Replay()
{
_isPlayingReplay = true;
int index = 0;
float replayStartTime = Time.time;
while (index < _eventList.Count)
{
ReplayEvent currentEvent = _eventList[index];
yield return(new WaitForSeconds(replayStartTime + currentEvent.timeTriggered - Time.time));
if (currentEvent.eventType == ReplayEvent.EventType.PressedRight)
{
Registry.inputHandler.OnPressedRight();
}
else if (currentEvent.eventType == ReplayEvent.EventType.ReleasedRight)
{
Registry.inputHandler.OnReleasedRight();
}
else if (currentEvent.eventType == ReplayEvent.EventType.PressedLeft)
{
Registry.inputHandler.OnPressedLeft();
}
else if (currentEvent.eventType == ReplayEvent.EventType.ReleasedLeft)
{
Registry.inputHandler.OnReleasedLeft();
}
else if (currentEvent.eventType == ReplayEvent.EventType.PressedJump)
{
Registry.inputHandler.OnPressedJump();
}
else if (currentEvent.eventType == ReplayEvent.EventType.ReleasedJump)
{
Registry.inputHandler.OnReleasedJump();
}
else if (currentEvent.eventType == ReplayEvent.EventType.PressedUse)
{
Registry.inputHandler.OnPressedUse();
}
else if (currentEvent.eventType == ReplayEvent.EventType.PressedPickUp)
{
Registry.inputHandler.OnPressedPickUp();
}
else if (currentEvent.eventType == ReplayEvent.EventType.PressedReset)
{
Registry.inputHandler.OnPressedReset();
}
index++;
}
_isPlayingReplay = false;
Debug.Log("Replay has ended");
}
public void AddEvent(ReplayEvent @event)
{
var container = new ReplayEventContainer(@event);
container.RelativePosition = @event.Camera.SessionTime / this.SessionTime;
this.Events.Add(container);
this.UpdateEventPosition(container);
var command = SyncCommandHelper.AddEvent(@event);
SyncManager.Instance.SendStateUpdate(command);
}
public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
ReplayEvent replayEvent = value as ReplayEvent;
writer.WriteStartObject();
{
writer.WritePropertyName("type"); writer.WriteValue(value.GetType().ToString());
writer.WritePropertyName("data"); writer.WriteStartObject();
{
replayEvent.Serialize(writer);
}
writer.WriteEndObject();
}
writer.WriteEndObject();
}
/// <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(byte eventID, ReplayState state = null)
{
// Create the replay event
ReplayEvent evt = new ReplayEvent
{
eventID = eventID,
eventData = state,
};
// Check for null state
if (evt.eventData == null)
{
evt.eventData = new ReplayState();
}
// Push to event queue
replayEvents.Enqueue(evt);
}
public void ReplaySubject()
{
var rs = new ReplayEvent <int>(2);
var l1 = new List <int>();
var l2 = new List <int>();
var l3 = new List <int>();
var d = rs.Subscribe(l1.Add);
rs.OnNext(1);
rs.OnNext(2);
rs.Subscribe(l2.Add);
rs.OnNext(3);
rs.OnNext(4);
rs.Subscribe(l3.Add);
d.Dispose();
rs.OnNext(5);
ListEq(l1, new[] { 1, 2, 3, 4 });
ListEq(l2, new[] { 1, 2, 3, 4, 5 });
ListEq(l3, new[] { 3, 4, 5 });
}
public void AddOfftrackPenalty(DriverOfftrackLimit limit)
{
Penalty penalty;
penalty = Penalty.Create();
penalty.Reason = "Ignoring track limits";
penalty.Camera = CameraControl.GetCurrentCameraSessionTime();
penalty.Lap = limit.Driver.Driver.Live.Lap.ToString();
SyncManager.Instance.State.Penalties.Add(penalty);
// Create incident event
var @event = new ReplayEvent();
@event.Type = ReplayEvent.EventTypes.Incident;
@event.AdminId = SyncManager.Instance.UserId;
@event.Camera = penalty.Camera;
// _mainModel.ReplayBarModel.AddEvent(@event);
penalty.StartInvestigation(limit.Driver.Driver.Id, SyncManager.Instance.User);
SyncManager.Instance.SendStateUpdate(SyncCommandHelper.AddPenalty(penalty));
}
/// <summary>
/// Serializes all awaiting <see cref="ReplayEvent"/> to the state.
/// </summary>
/// <param name="state">The <see cref="ReplayState"/> to write the varaible data to</param>
protected virtual void ReplaySerializeEvents(ReplayState state)
{
// Get the number of events
short size = (short)replayEvents.Count;
// Write the size to the state
state.Write(size);
// Write all events
while (replayEvents.Count > 0)
{
// Get the next event
ReplayEvent evt = replayEvents.Dequeue();
// Write the event id
state.Write(evt.eventID);
// Write the size and event data
state.Write((byte)evt.eventData.Size);
state.Write(evt.eventData);
}
}
private void UpdateEvents()
{
this.Events.Clear();
#if DEBUG
var debugEvents = new List <ReplayEvent>();
var ev = new ReplayEvent();
ev.AdminId = SyncManager.Instance.UserId;
ev.Camera = CameraDetails.ChangeReplayTime(400, 4);
ev.Type = ReplayEvent.EventTypes.Interesting;
ev.Text = "Test event 1";
debugEvents.Add(ev);
ev = new ReplayEvent();
ev.AdminId = SyncManager.Instance.UserId;
ev.Camera = CameraDetails.ChangeReplayTime(500, 7);
ev.Type = ReplayEvent.EventTypes.Incident;
ev.Text = "Test event 2";
debugEvents.Add(ev);
ev = new ReplayEvent();
ev.AdminId = SyncManager.Instance.UserId;
ev.Camera = CameraDetails.ChangeReplayTime(850, 7);
ev.Type = ReplayEvent.EventTypes.Interesting;
ev.Text = "Test event 3";
debugEvents.Add(ev);
foreach (var @event in debugEvents)
{
#else
foreach (var @event in SyncManager.Instance.State.Events)
{
#endif
var container = new ReplayEventContainer(@event);
container.RelativePosition = @event.Camera.SessionTime / this.SessionTime;
this.Events.Add(container);
}
this.UpdateEventPositions();
}
public void AddDriver(DriverContainer driver, PenaltyContainer parentPenalty = null)
{
Penalty penalty;
if (parentPenalty == null)
{
penalty = Penalty.Create();
penalty.Camera = CameraControl.GetCurrentCameraSessionTime();
penalty.Lap = driver.Driver.Live.Lap.ToString();
SyncManager.Instance.State.Penalties.Add(penalty);
// Create incident event
var @event = new ReplayEvent();
@event.Type = ReplayEvent.EventTypes.Incident;
@event.AdminId = SyncManager.Instance.UserId;
@event.Camera = penalty.Camera;
//_mainModel.ReplayBarModel.AddEvent(@event);
}
else
{
penalty = parentPenalty.Penalty;
}
penalty.StartInvestigation(driver.Driver.Id, SyncManager.Instance.User);
if (parentPenalty == null)
{
SyncManager.Instance.SendStateUpdate(SyncCommandHelper.AddPenalty(penalty));
EditPenalty(penalty);
}
else
{
SyncManager.Instance.SendPenaltyUpdate(penalty);
}
this.UpdatePenalties();
}
public void ActionReplay()
{
ReplayEvent?.Invoke();
}
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));
}
/// <summary>
/// Called by the replay system when an event has been received during playback.
/// </summary>
/// <param name="replayEvent">The event that was received</param>
public virtual void OnReplayEvent(ReplayEvent replayEvent)
{
}
public ReplayEventContainer(ReplayEvent @event)
{
_event = @event;
this.Admin = SyncManager.Instance.Users.FromId(@event.AdminId);
}
