private void SaveObjectState(bool initialState) { NetDataWriter writer = new NetDataWriter(true); foreach (var player in MatchSystem.instance.Scene.AllPlayers) { player.WriteData(writer, initialState); } foreach (var netObj in MatchSystem.instance.Scene.NetworkObjects) { writer.Put(netObj.Key); //Network ID netObj.Value.WriteData(writer, initialState); } NetDataReader reader = new NetDataReader(); reader.SetSource(writer); ReplayState state = new ReplayState { initialState = initialState, timestamp = Time.ElapsedTime, reader = reader }; States.Add(state); }
public void PostSimulate() { if (Game.instance == null) { return; } if (Game.instance.state != GameState.PlayingLevel) { state = ReplayState.None; SubtitleManager.instance.ClearRecording(); } if (state == ReplayState.None) { return; } if (state == ReplayState.Record) { CaptureFrame(); return; } PlaybackFrame(currentFrame); if (state == ReplayState.PlayForward) { currentFrame++; } else if (state == ReplayState.PlayBackward) { currentFrame--; } currentFrame = Mathf.Clamp(currentFrame, 0, lastFrame); }
public void GetRacersAndStartRecording(Statistics[] allRacers) { //Get the racer's vehicle controllers and start recording the replay racers.RemoveRange(allRacers.Length, racers.Count - allRacers.Length); for (int i = 0; i < racers.Count; i++) { racers[i].racer = allRacers[i].transform; if (racers[i].racer.GetComponent <Car_Controller>()) { racers[i].carController = racers[i].racer.GetComponent <Car_Controller>(); } if (racers[i].racer.GetComponent <Motorbike_Controller>()) { racers[i].motorbikeController = racers[i].racer.GetComponent <Motorbike_Controller>(); if (racers[i].motorbikeController.chassis) { racers[i].motorbikeChassis = racers[i].motorbikeController.chassis.transform; } } } replayState = ReplayState.Recording; }
// Token: 0x06000D44 RID: 3396 RVA: 0x0003A540 File Offset: 0x00038740 public SingleCopyReplayConfiguration(IADDatabaseAvailabilityGroup dag, IADDatabase database, IADServer server, LockType lockType) { try { if (database == null) { throw new NullDatabaseException(); } if (server == null) { throw new ErrorNullServerFromDb(database.Name); } this.m_database = database; this.m_type = ReplayConfigType.SingleCopySource; this.m_server = server; this.m_sourceNodeFqdn = server.Fqdn; this.m_replayState = ReplayState.GetReplayState(this.m_sourceNodeFqdn, this.m_sourceNodeFqdn, lockType, this.Identity, this.Database.Name); this.m_activationPreference = 1; base.PopulatePropertiesFromDag(dag); } finally { this.BuildDebugString(); } }
IEnumerator Reverse() { while (state == ReplayState.Reverse) { int previousIndex = timeIndex; timeIndex--; int currentIndex = timeIndex; if (currentIndex < 0) { state = ReplayState.Pause; timeIndex = 0; } else { ReplayData prev, cur; prev.time = replay.TimeLookup(previousIndex); prev.messages = replay.MessagesLookup(previousIndex); cur.time = replay.TimeLookup(currentIndex); cur.messages = replay.MessagesLookup(currentIndex); ReplayEventData ed = new ReplayEventData(prev, cur); yield return(StartCoroutine(ReplayTransition(ed, false))); } } print("Finished Playing"); }
void SetReplayState(ReplayState newState) { if (this.bestReplayState == newState) { return; } switch (newState) { case ReplayState.Stopped: dialogComponent.ReplayButton.gameObject.SetActive(true); dialogComponent.ReplayButtonText.text = StringConstants.ButtonReplayPlay; DestroyReplayAnimator(); break; case ReplayState.Downloading: dialogComponent.ReplayButton.gameObject.SetActive(true); dialogComponent.ReplayButtonText.text = StringConstants.ButtonReplayWait; break; case ReplayState.Playing: dialogComponent.ReplayButton.gameObject.SetActive(true); dialogComponent.ReplayButtonText.text = StringConstants.ButtonReplayStop; SpawnReplayAnimator(); break; default: dialogComponent.ReplayButton.gameObject.SetActive(false); dialogComponent.ReplayButtonText.text = ""; break; } this.bestReplayState = newState; }
private int CalculateMemoryBufferSize() { int requiredBytes = 0; // Create a temp storage container ReplayState state = new ReplayState(); // Get all active components foreach (ReplayBehaviour replay in Component.FindObjectsOfType <ReplayBehaviour>()) { // Calculate the required size replay.OnReplaySerialize(state); } // Multiply by record fps ReplayManager manager = Component.FindObjectOfType <ReplayManager>(); // Default to 24 fps requiredBytes = (manager != null) ? state.Size * manager.recordFPS : state.Size * 24; // Take into account the number of seconds in the memory buffer requiredBytes = (int)(requiredBytes * Replay.recordSeconds); return(requiredBytes); }
// Methods public IEnumerator Start() { while (true) { // Wait until we are recording if (IsRecording == false) { yield return(null); } // Record event type 1 yield return(new WaitForSeconds(1f)); RecordEvent((ushort)MyEventType.Event1); // Record event type 2 yield return(new WaitForSeconds(1f)); RecordEvent((ushort)MyEventType.Event2); // Record event type 3 with extra data ReplayState eventData = ReplayState.pool.GetReusable(); eventData.Write("Hello World"); yield return(new WaitForSeconds(1f)); RecordEvent((ushort)MyEventType.Event3, eventData); } }
private void addAction(bool hitting, bool hardhit = false) { if (wasHit == hitting) { return; } wasHit = hitting; var state = new ReplayState <TauAction> { PressedActions = new List <TauAction>() }; if (hitting) { if (hardhit) { state.PressedActions.Add(TauAction.HardButton); } else { state.PressedActions.Add(wasLeft ? TauAction.LeftButton : TauAction.RightButton); wasLeft = !wasLeft; } } state.Apply(tauInputManager.CurrentState, tauInputManager); }
public void DrawGUI(ReplayState state) { switch (state) { case ReplayState.MainMenu: MenuRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Passive), MenuRect, MenuWindow, "ReplayEditor Menu"); break; case ReplayState.LoadMenu: LoadRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Passive), LoadRect, LoadWindow, "Load Replay"); break; case ReplayState.SaveMenu: SaveRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Passive), SaveRect, SaveWindow, "Save Replay"); break; case ReplayState.SettingsMenu: SettingsRect = GUILayout.Window(GUIUtility.GetControlID(FocusType.Passive), SettingsRect, SettingsWindow, "Settings"); break; } if (GUI.Button(new Rect(CurrentRect.xMax, CurrentRect.y, 30, 30), "X")) { ReplayManager.CurrentState = ReplayState.Playback; } }
private IEnumerator ReplayCoroutine(Vector3 goalPos) { Debug.Log("Replay cor is started"); MatchSystem.instance.blockIncomingData = true; Replaying = true; //specCam.transform.position = goalPos + new Vector3(goalPos.z / 1.2f, 5, 0); MatchSystem.instance.ReadOwnerAsNormal = true; ReplayState initialState = States[0]; RemoveAllInitialStates(); float currentTime = initialState.timestamp; LoadObjectState(initialState); CameraMaster.instance.StopReplay(); CameraMaster.instance.StartReplay(); MatchSystem.instance.Pause(); while (States.Count > 0) { while (currentTime < States[0].timestamp) { currentTime += Time.ActualDeltaTime; yield return(null); } LoadObjectState(States[0]); States.RemoveAt(0); } Replaying = false; _Replay = null; MatchSystem.instance.ReadOwnerAsNormal = false; MatchSystem.instance.blockIncomingData = false; CameraMaster.instance.StopReplay(); MatchSystem.instance.UnPause(); }
/// <summary> /// Requests that the <see cref="CurrentState"/> changes to the specified <see /// cref="ReplayState"/>.</summary> /// <param name="state"> /// The requested new value for the <see cref="CurrentState"/> property.</param> /// <remarks><para> /// <b>RequestState</b> does nothing if the specified <paramref name="state"/> already /// equals <see cref="CurrentState"/> or <see cref="RequestedState"/>. /// </para><para> /// <b>RequestState</b> also does nothing if <see cref="CurrentState"/> equals <see /// cref="ReplayState.Skip"/> or <see cref="ReplayState.Stop"/>. Skipping ahead prevents all /// input, and clients must call <see cref="Start"/> to start replays. /// </para><para> /// Otherwise, <b>RequestState</b> sets the <see cref="RequestedState"/> to the specified /// <paramref name="state"/>, and also sets the <see cref="SessionExecutor.AbortSignal"/> to /// speed up <see cref="Command"/> replay until the background thread gets around to check /// the new <see cref="RequestedState"/>.</para></remarks> public void RequestState(ReplayState state) { // quit if state already current or requested if (state == CurrentState || state == RequestedState) { return; } // quit if currently skipping or stopped if (CurrentState == ReplayState.Skip || CurrentState == ReplayState.Stop) { return; } // pause current replay if requested if (CurrentState == ReplayState.Play && state == ReplayState.Pause) { _playSignal.Reset(); } else { _playSignal.Set(); } // let background thread enter requested state RequestedState = state; SessionExecutor.AbortSignal.Set(); }
public void OnReplayDeserialize(ReplayState state) { int size = state.Read32(); for (int i = 0; i < size; i++) { // Read the target identity ReplayIdentity identity = state.ReadIdentity(); int localSize = state.Read32(); // Read all states for (int j = 0; j < localSize; j++) { // Create empty data container ReplayInitialData data = new ReplayInitialData(); // Deserialize data data.OnReplayDeserialize(state); // Register state if (initialStates.ContainsKey(identity) == false) { initialStates.Add(identity, new List <ReplayInitialData>()); } initialStates[identity].Add(data); } } }
GameStateBase getState(GameState state) { GameStateBase gameState; if (states.TryGetValue(state, out gameState)) { return(gameState); } switch (state) { case GameState.Enter: gameState = new GameEnterState(this); break; case GameState.Ready: gameState = new GameReadyState(this); break; case GameState.Gaming: gameState = new GamingState(this); break; case GameState.Goal: gameState = new GoalState(this); break; case GameState.Replay: gameState = new ReplayState(this); break; case GameState.Over: gameState = new GameOverState(this); break; } states.Add(state, gameState); return(gameState); }
// Methods public override void PrepareForPlayback(Animator component, ReplayState additionalData) { // Write the component state additionalData.Write(component.enabled); // Disable the animator - it could interfere with playback component.enabled = false; }
public override void PrepareForGameplay(Animator component, ReplayState additionalData) { // Read the component state bool initialState = additionalData.ReadBool(); // Reset the animator state component.enabled = initialState; }
// Methods public override void PrepareForPlayback(Rigidbody component, ReplayState additionalData) { // Store the initial value additionalData.Write(component.isKinematic); // Make the body kinematic to avoid movement by the physics engine component.isKinematic = true; }
// Methods public override void PrepareForPlayback(Behaviour component, ReplayState additionalData) { // Store the initial value additionalData.Write(component.enabled); // Make the body kinematic to avoid movement by the physics engine component.enabled = false; }
public override void PrepareForGameplay(Behaviour component, ReplayState additionalData) { // Read the default value bool initialState = additionalData.ReadBool(); // Reset the kinematic state component.enabled = initialState; }
private void BeginRecording() { state = ReplayState.Record; recordingStartTime = Time.time; lastFrame = 0; currentFrame = 0; capture.Clear(); }
/// <summary> /// Registers the specified replay state with this snapshot. /// The specified identity is used during playback to ensure that the replay objects receives the correct state to deserialize. /// </summary> /// <param name="identity">The identity of the object that was serialized</param> /// <param name="state">The state data for the object</param> public void RecordSnapshot(ReplayIdentity identity, ReplayState state) { // Register the state if (states.ContainsKey(identity) == false) { states.Add(identity, state); } }
public override void PrepareForGameplay(Rigidbody component, ReplayState additionalData) { // Read the default value bool initialState = additionalData.ReadBool(); // Reset the kinematic state component.isKinematic = initialState; }
private void ResumeUsingState(ReplayConfiguration replayConfiguration) { ReplayState replayState = replayConfiguration.ReplayState; replayState.SuspendLockRemote.TryLeaveSuspend(); replayState.SuspendMessage = null; this.m_fSuccess = true; }
void Start() { if (state == null) { state = new ReplayState(); state.initPos = transform.position; } }
private void Awake() { Ins = this; Log = new Log(); ActiveState = new List <PersistState>(); GameOverlay = new GameOverlayDialogState(); FightState = new FightState(); ReplayState = new ReplayState(); NickNameDialogState = new NickNameDialogState(); BattleStatusDialogState = new BattleStatusDialogState(); PlayerDialogState = new PlayerDialogState(); ChatDialogState = new ChatDialogState(); PsdEditDialogState = new PsdEditDialogState(); RoomChatDialogState = new RoomChatDialogState(); LoadingEx = new LoadingEXDialogState(); ItemInfoDialogState = new ItemInfoDialogState(); GunShootDialogStatus = new GunShootDialogStatus(); //面板管理器. DialogStateManager = new MainDialogStateManager(); //顺序排队弹出框. PopupStateManager = new MainPopupStateManager(); //各类游戏数据. GameStateMgr = new GameStateMgr(); UpdateHelper = new UpdateHelper(); AppInfo = new AppInfo(); CombatData = new CombatData(); GameNotice = new GameNotice(); MeteorManager = new MeteorManager(); ScriptMng = new ScriptMng(); SFXLoader = new SFXLoader(); ActionInterrupt = new ActionInterrupt(); BuffMng = new BuffMng(); EventBus = new EventBus(); NetWorkBattle = new NetWorkBattle(); SceneMng = new SceneMng(); FrameSync = new FrameSync(); MeteorBehaviour = new MeteorBehaviour(); DropMng = new DropMng(); //原版相关资源的加载器. MenuResLoader = new MenuResLoader(); SkcLoader = new SkcLoader(); BncLoader = new BncLoader(); FMCLoader = new FMCLoader(); GMBLoader = new GMBLoader(); GMCLoader = new GMCLoader(); DesLoader = new DesLoader(); FMCPoseLoader = new FMCPoseLoader(); DataMgr = new DataMgr(); SfxMeshGenerator = new SfxMeshGenerator(); RoomMng = new RoomMng(); SoundManager = new SoundManager(); ResMng = new ResMng(); DlcMng = new DlcMng(); DontDestroyOnLoad(gameObject); Log.WriteError(string.Format("GameStart AppVersion:{0}", Main.Ins.AppInfo.AppVersion())); }
private Thread BeginSuspendUsingState(ReplayConfiguration replayConfiguration) { ReplayState replayState = replayConfiguration.ReplayState; Thread thread = new Thread(new ParameterizedThreadStart(this.SuspendStateThreadProc)); thread.IsBackground = true; thread.Start(replayState); return(thread); }
public void Suspend() { if ((_state == ReplayState.Done) || (!_replayer.IsAlive)) { throw new InvalidOperationException(); } _state = ReplayState.Suspend; }
// Methods /// <summary> /// Called by the replay system when the variable should be serialized. /// </summary> /// <param name="state">The <see cref="ReplayState"/> to serialize the data into</param> public void OnReplaySerialize(ReplayState state) { try { // Write the current field value state.TryWriteObject(Value); } catch { } }
/* * 回复切磋邀请 */ public IEnumerator ContestReplayInvite(int replayinviteId, ReplayState state) { var packet = new KBEngine.PacketHolder(); var load = CGContestReplayInvite.CreateBuilder(); load.ReplyInviteId = replayinviteId; load.ReplyState = state; yield return(StartCoroutine(KBEngine.Bundle.sendSimple(this, load, packet))); }
public void Update() { if (replayState != ReplayState.Playing) { for (int padIndex = 0; padIndex < 8; padIndex++) { CheckKey(ref allControllers[padIndex].moveUp); CheckKey(ref allControllers[padIndex].moveDown); CheckKey(ref allControllers[padIndex].moveLeft); CheckKey(ref allControllers[padIndex].moveRight); CheckKey(ref allControllers[padIndex].jump); CheckKey(ref allControllers[padIndex].attack); CheckKey(ref allControllers[padIndex].escape); allControllers[padIndex].xMovement = 0.0f; if (allControllers[padIndex].moveRight.isDown) { allControllers[padIndex].xMovement = 1.0f; } if (allControllers[padIndex].moveLeft.isDown) { allControllers[padIndex].xMovement = -1.0f; } } } if (replayState == ReplayState.Recording) { if (Time.frameCount >= controllerHistory.Length) { Debug.LogWarning("Max recording limit reached"); replayState = ReplayState.None; SaveReplay(); } else { controllerHistory[Time.frameCount].contollerOne = allControllers[(int)ControllerType.KeyboardWASD]; controllerHistory[Time.frameCount].contollerTwo = allControllers[(int)ControllerType.KeyboardArrows]; controllerHistory[Time.frameCount].contollerThree = allControllers[(int)ControllerType.Controller0]; controllerHistory[Time.frameCount].contollerFour = allControllers[(int)ControllerType.Controller1]; controllerHistory[Time.frameCount].contollerFive = allControllers[(int)ControllerType.Controller2]; controllerHistory[Time.frameCount].contollerSix = allControllers[(int)ControllerType.Controller3]; controllerHistory[Time.frameCount].contollerSeven = allControllers[(int)ControllerType.Controller4]; } } if (replayState == ReplayState.Playing) { allControllers[(int)ControllerType.KeyboardWASD] = controllerHistory[Time.frameCount].contollerOne; allControllers[(int)ControllerType.KeyboardArrows] = controllerHistory[Time.frameCount].contollerTwo; allControllers[(int)ControllerType.Controller0] = controllerHistory[Time.frameCount].contollerThree; allControllers[(int)ControllerType.Controller1] = controllerHistory[Time.frameCount].contollerFour; allControllers[(int)ControllerType.Controller2] = controllerHistory[Time.frameCount].contollerFive; allControllers[(int)ControllerType.Controller3] = controllerHistory[Time.frameCount].contollerSix; allControllers[(int)ControllerType.Controller4] = controllerHistory[Time.frameCount].contollerSeven; } }
public void StopRecording() { state = ReplayState.None; SaveToFile(filename); }
public void StartReplaying(Game game) { game.Input = staticInput = new StaticInput(); state = ReplayState.Replaying; Game.Random = new Random(0); game.SpawnRandomizer = new Random(0); mainCharPositionReplay = new Common.Interpolator3(); groundPosition = new Common.Interpolator3(); planePosition = new Common.Interpolator3(); }
public void StartRecording(Game game) { state = ReplayState.Recording; Game.Random = new Random(0); game.SpawnRandomizer = new Random(0); }
void AddReplay(ReplayMetadata replay, ScrollItemWidget template) { var item = ScrollItemWidget.Setup(template, () => selectedReplay == replay, () => SelectReplay(replay), () => WatchReplay()); replayState[replay] = new ReplayState { Item = item, Visible = true }; item.Text = Path.GetFileNameWithoutExtension(replay.FilePath); item.Get<LabelWidget>("TITLE").GetText = () => item.Text; item.IsVisible = () => replayState[replay].Visible; replayList.AddChild(item); }
IEnumerator Forward() { while(state == ReplayState.Forward) { int previousIndex = timeIndex; timeIndex++; int currentIndex = timeIndex; if(currentIndex >= replay.SessionDict.Keys.Count) { state = ReplayState.Pause; timeIndex = replay.SessionDict.Keys.Count - 1; } else { ReplayData prev, cur; prev.time = replay.TimeLookup(previousIndex); prev.messages = replay.MessagesLookup(previousIndex); cur.time = replay.TimeLookup(currentIndex); cur.messages = replay.MessagesLookup(currentIndex); ReplayEventData ed = new ReplayEventData(prev, cur); yield return StartCoroutine(ReplayTransition(ed, true)); } } }
void Pause() { state = ReplayState.Pause; forwardButton.sprite = pauseSprite; }
IEnumerator Replay() { state = ReplayState.Forward; elapsed = 0f; timeIndex = 0; while(state != ReplayState.Stop) { if(state == ReplayState.Forward) { yield return StartCoroutine(Forward()); } else if(state == ReplayState.Reverse) { yield return StartCoroutine(Reverse()); } else { yield return null; // Pause... don't tick up or down } } elapsed = 0f; // reset elapsed for the ui }
IEnumerator Reverse() { while(state == ReplayState.Reverse) { int previousIndex = timeIndex; timeIndex--; int currentIndex = timeIndex; if(currentIndex < 0) { state = ReplayState.Pause; timeIndex = 0; } else { ReplayData prev, cur; prev.time = replay.TimeLookup(previousIndex); prev.messages = replay.MessagesLookup(previousIndex); cur.time = replay.TimeLookup(currentIndex); cur.messages = replay.MessagesLookup(currentIndex); ReplayEventData ed = new ReplayEventData(prev, cur); yield return StartCoroutine(ReplayTransition(ed, false)); } } print ("Finished Playing"); }
void Unpause(ReplayState newState) { state = newState; forwardButton.sprite = playSprite; }