public void StoreCommand(int tick) { if (m_LocalPlayer.playerState == null) { return; } m_LocalPlayer.command.checkTick = tick; var lastBufferTick = m_LocalPlayer.commandBuffer.LastTick(); if (tick != lastBufferTick && tick != lastBufferTick + 1) { m_LocalPlayer.commandBuffer.Clear(); GameDebug.Log(string.Format("Trying to store tick:{0} but last buffer tick is:{1}. Clearing buffer", tick, lastBufferTick)); } if (tick == lastBufferTick) { m_LocalPlayer.commandBuffer.Set(ref m_LocalPlayer.command, tick); } else { m_LocalPlayer.commandBuffer.Add(ref m_LocalPlayer.command, tick); } #if UNITY_EDITOR StateHistory.SetCommand(tick, ref m_LocalPlayer.command); #endif }
public void ShowHistory(GameWorld world) { StateHistory.Enabled = true; var state = new CharacterPredictedState.StateData(); var count = DebugOverlay.Height - 4; for (var iEntry = 0; iEntry < count; iEntry++) { var tick = world.worldTime.tick - count + 1 + iEntry; StateHistory.GetPredictedState(this, tick, ref state); var y = 2 + iEntry; { var color = (Color32)Color.HSVToRGB(0.21f * (int)state.locoState, 1, 1); var colorRGB = ((color.r >> 4) << 8) | ((color.g >> 4) << 4) | (color.b >> 4); DebugOverlay.Write(2, y, "^{0}{1}", colorRGB.ToString("X3"), state.locoState.ToString()); } DebugOverlay.Write(14, y, state.sprinting ? "Sprint" : "no-sprint"); { var color = (Color32)Color.HSVToRGB(0.21f * (int)state.action, 1, 1); var colorRGB = ((color.r >> 4) << 8) | ((color.g >> 4) << 4) | (color.b >> 4); DebugOverlay.Write(26, y, "^{0}{1}", colorRGB.ToString("X3"), state.action.ToString()); } } }
void UpdateChampions(double dt) { // Use the time elapsed since our last snapshot as a delta time double time = StateHistory.IsEmpty() ? dt : Server.Instance.GetTime().TotalSeconds - StateHistory.GetLast().Key; foreach (ServerClient client in Clients.Values) { if (time > 0.0) { Match.CurrentState.ApplyPhysicsUpdate(client.Champion.ID, (float)time); } UpdateChampionHealth(client); // Check to go out of combat if (client.ChampStats.ShouldGoOutOfCombat()) { client.ChampStats.GoOutOfCombat(); } client.Champion.Animation = client.Champion.GetAnim(!client.ChampStats.Alive, //TODO: replace with actual HP Match.CurrentState.IsOnGround(client.Champion.ID), client.ChampStats.IsCastingSpell(client.Champion.Type, PlayerActionType.Spell1), client.ChampStats.IsCastingSpell(client.Champion.Type, PlayerActionType.Spell2), client.ChampStats.IsCastingSpell(client.Champion.Type, PlayerActionType.Spell3), client.ChampStats.IsCastingSpell(client.Champion.Type, PlayerActionType.Spell4), client.AnimData.Movement, client.AnimData.Idle, client.Champion.Animation); } }
public override void AuthoritativeChangePosition(StateUpdateData data, double time) { ServerPosition = data.Position; StateHistory.AddSnapshot( data, GetCurrentTimeSeconds()); }
public void UpdateForChangedVoxel(VoxelCell changedVoxel) { SolutionState state = FirstState.GetWithChangedCell(changedVoxel); StateHistory.Clear(); StateHistory.Add(state); }
public void ChangeState(string stateName) { Form _cur = StateHistory.Peek(); _cur.Hide(); Form _new; if (stateName == "AddSales") { _new = new frmAddSales(); } else if (stateName == "Stock") { _new = new frmStock(); } else if (stateName == "Sales") { _new = new frmSales(); } else { throw new System.NotImplementedException(); } _new.Show(); _new.Activate(); _new.Closed += new EventHandler(OnFormClosed); StateHistory.Push(_new); }
public void Deserialize(ref NetworkReader reader, IEntityReferenceSerializer refSerializer, int tick) { m_lastServerState.Deserialize(ref reader, refSerializer, tick); #if UNITY_EDITOR StateHistory.SetState(this, tick, ref m_lastServerState); #endif }
private void AddState(string state) { if (this.StateHistory == null) { this.StateHistory = new List <History>(); } StateHistory.Add(new History(state)); }
void StoreGameState(double dt) { if (TimeSinceLastGameHistory >= STORE_HISTORY_INTERVAL.TotalSeconds) { StateHistory.AddSnapshot(Match.CurrentState.Clone() as MatchState, Server.Instance.GetTime().TotalSeconds); TimeSinceLastGameHistory = 0.0; } TimeSinceLastGameHistory += dt; }
public void AdvanceOneStep() { if (StateHistory.Count < SolverLimit && !LastState.IsEverythingSolved) { SolutionState nextState = LastState.GetNextState(); StateHistory.Add(nextState); Status = GetSolverStatus(); } }
public void NextState() { var deadCount = 0; var currentBoard = StateHistory.Last(); var ghosts = GhostMovement(currentBoard.Ghosts); var newPlayers = new List <PacManPlayer>(); var coins = new List <Coin>(currentBoard.Coins); foreach (var player in currentBoard.Players) { var newPlayer = player.Copy(); //Check if player is alive if (!newPlayer.Alive) { continue; } PlayerMovement(newPlayer); var coin = CheckCoin(newPlayer, coins); if (coin != null) { coins.Remove(coin); } if (CheckPlayerWallCollision(newPlayer)) { newPlayer.Alive = false; deadCount++; continue; } if (CheckPlayerGhostCollision(newPlayer, ghosts)) { deadCount++; newPlayer.Alive = false; } newPlayers.Add(newPlayer); } if (deadCount == numberPlayers) { GameEnded = true; } NewMovements.Clear(); StateHistory.Add(new Board(currentBoard.RoundID + 1, ghosts, newPlayers, coins)); }
public void Deserialize(ref NetworkReader reader, IEntityReferenceSerializer refSerializer, int tick) { var state = new State(); state.Deserialize(ref reader); stateHistory.Add(tick, state); #if UNITY_EDITOR StateHistory.SetState(this, tick, ref state); #endif }
private SolverStatus GetSolverStatus() { if (StateHistory.Any() && LastState.IsEverythingSolved) { return(SolverStatus.Solved); } if (StateHistory.Count >= SolverLimit) { return(SolverStatus.AtLimit); } return(SolverStatus.Solving); }
public void Back() { Form _cur = StateHistory.Pop(); _cur.Hide(); _cur.Dispose(); Form _new = StateHistory.Peek(); _new.Show(); _new.Activate(); _new.Closed += new EventHandler(OnFormClosed); }
/// <summary> /// Clears the state history and adds the "uninitialized" state /// </summary> private void SetUninitializedState() { StateHistory.Clear(); PresentableMD5State uninitializedState = new PresentableMD5State(); uninitializedState.State = MD5StateDescription.UNINITIALIZED; StateHistory.Add(uninitializedState); CurrentState = uninitializedState; CurrentStateNumber = 0; }
/// <summary> /// Create entity. /// </summary> public StateHistory Create(StateHistory entity) { using (var connection = _dbConnectionFactory.CreateConnection()) { connection.Open(); using (var transaction = connection.BeginTransaction()) { var parameters = new DynamicParameters(); parameters.Add("@Name", entity.Name, DbType.String); parameters.Add("@dpdOrderNr", entity.dpdOrderNr, DbType.String); parameters.Add("@dpdParcelNr", entity.dpdParcelNr, DbType.String); parameters.Add("@newState", entity.newState, DbType.String); parameters.Add("@transitionTime", entity.transitionTime, DbType.DateTime2); parameters.Add("@terminalCode", entity.terminalCode, DbType.String); parameters.Add("@terminalCity", entity.terminalCity, DbType.String); parameters.Add("@incidentCode", entity.incidentCode, DbType.String); parameters.Add("@incidentName", entity.incidentName, DbType.String); parameters.Add("@consignee ", entity.consignee, DbType.String); // Configure outputs parameters.Add("@EntityId", dbType: DbType.Int32, direction: ParameterDirection.Output); parameters.Add("@ErrorMessage", dbType: DbType.String, size: 1000, direction: ParameterDirection.Output); // Execute query int result = connection.Execute( sql: StateHistoryInsert_Proc, commandType: CommandType.StoredProcedure, transaction: transaction, param: parameters ); // Check for errors string errorMessage = parameters.Get <string>("@ErrorMessage"); if (!string.IsNullOrEmpty(errorMessage)) { throw new RepositoryException(errorMessage); } // Set the id entity.Id = parameters.Get <int>("@EntityId"); transaction.Commit(); return(entity); } } }
/// <summary> /// Create states /// </summary> /// <param name="states">Pool of all states</param> public override void CreateStates(StatePool states) { if (states == null) { throw new ArgumentNullException(nameof(states)); } // We just need a history without integration here StateChargeBe = states.CreateDerivative(); StateChargeBc = states.CreateDerivative(); StateChargeCs = states.CreateDerivative(); StateChargeBx = states.CreateDerivative(); StateExcessPhaseCurrentBc = states.CreateHistory(); }
/// <summary> /// Adds a new state to the history and sets it as the current state /// </summary> protected void AddNewState() { if (CurrentStateNumber == -1) { CurrentState = new PresentableMD5State(); } else { CurrentState = new PresentableMD5State(StateHistory[CurrentStateNumber]); } StateHistory.Add(CurrentState); CurrentStateNumber = StateHistory.Count - 1; }
protected override void OnUpdate() { Profiler.BeginSample("StoreStateHistory.Update"); for (var i = 0; i < Group.characters.Length; i++) { // Only store data from full ticks if (m_world.worldTime.tickDuration != m_world.worldTime.tickInterval) { return; } StateHistory.SetPredictedState(Group.characters[i], m_world.worldTime.tick, ref Group.characters[i].State); } Profiler.EndSample(); }
public LevelInfo() { Title = "Untitled"; MusicPath = null; SkyPath = null; ScriptPath = null; ItemPath = null; RandomSeed = 0; InEditor = false; InMenu = false; TotalPlacements = 0; m_history = new StateHistory <State>(0.0f); m_history.PushState(new State(0)); }
private static void OnUpdateEvent() { if (m_captureRequested) { m_captureRequested = false; // Capture CaptureResult capture = new CaptureResult(StateHistory.HighestTick - StateHistory.BufferSize + 1, StateHistory.BufferSize); // Commands { for (int i = 0; i < capture.count; i++) { int tick = i + capture.firstTick; capture.commands[i] = StateHistory.GetCommand <UserCommand>(tick); } } // Components List <Component> components = StateHistory.GetComponents(); foreach (var component in components) { if (component == null || component.gameObject == null) { continue; } var data = StateHistory.GetComponentData(component); var componentData = new ComponentData(component, capture.count); capture.componentData.Add(componentData); for (int i = 0; i < StateHistory.BufferSize; i++) { int tick = i + capture.firstTick; componentData.states[i] = data.GetState(tick); componentData.predictedStates[i] = data.GetPredicted(tick); componentData.predictionValid[i] = !data.mispredictedTicks.Contains(tick); } } // Sort componts by gameObject capture.componentData.Sort((a, b) => (a.component.gameObject.name.CompareTo(b.component.gameObject.name))); Capture?.Invoke(capture); } }
/// <summary> /// Create states /// </summary> /// <param name="method"></param> public override void CreateStates(IntegrationMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } // We just need a history without integration here StateChargeBe = method.CreateDerivative(); StateChargeBc = method.CreateDerivative(); StateChargeCs = method.CreateDerivative(); // Spice 3f5 does not include this state for LTE calculations StateChargeBx = method.CreateDerivative(false); StateExcessPhaseCurrentBc = method.CreateHistory(); }
public void SetCurrentState(IState state) { if (state != null) { Definition.CheckState(state); } StateHistory.Add(CurrentStateId, state.id); PreviousStateId = CurrentStateId; CurrentState = state; CurrentStateId = state.id; if (state.EndPoint) { Finished = true; } }
/// <summary> /// Create states /// </summary> /// <param name="method"></param> public override void CreateStates(IntegrationMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } _vgs = method.CreateHistory(); _vds = method.CreateHistory(); _vbs = method.CreateHistory(); _capgs = method.CreateHistory(); _capgd = method.CreateHistory(); _capgb = method.CreateHistory(); _qgs = method.CreateDerivative(); _qgd = method.CreateDerivative(); _qgb = method.CreateDerivative(); _qbd = method.CreateDerivative(); _qbs = method.CreateDerivative(); }
/// <summary> /// Create states /// </summary> /// <param name="states">States</param> public override void CreateStates(StatePool states) { if (states == null) { throw new ArgumentNullException(nameof(states)); } _vgs = states.CreateHistory(); _vds = states.CreateHistory(); _vbs = states.CreateHistory(); _capgs = states.CreateHistory(); _capgd = states.CreateHistory(); _capgb = states.CreateHistory(); _qgs = states.CreateDerivative(); _qgd = states.CreateDerivative(); _qgb = states.CreateDerivative(); _qbd = states.CreateDerivative(); _qbs = states.CreateDerivative(); }
/// <summary> /// Create states /// </summary> /// <param name="states">States</param> public override void CreateStates(StatePool states) { if (states == null) { throw new ArgumentNullException(nameof(states)); } ChargeGs = states.CreateDerivative(); ChargeGd = states.CreateDerivative(); ChargeGb = states.CreateDerivative(); ChargeBd = states.CreateDerivative(); ChargeBs = states.CreateDerivative(); CapGs = states.CreateHistory(); CapGd = states.CreateHistory(); CapGb = states.CreateHistory(); VoltageGs = states.CreateHistory(); VoltageDs = states.CreateHistory(); VoltageBs = states.CreateHistory(); }
/// <summary> /// Create states /// </summary> /// <param name="method"></param> public override void CreateStates(IntegrationMethod method) { if (method == null) { throw new ArgumentNullException(nameof(method)); } ChargeGs = method.CreateDerivative(); ChargeGd = method.CreateDerivative(); ChargeGb = method.CreateDerivative(); ChargeBd = method.CreateDerivative(); ChargeBs = method.CreateDerivative(); CapGs = method.CreateHistory(); CapGd = method.CreateHistory(); CapGb = method.CreateHistory(); VoltageGs = method.CreateHistory(); VoltageDs = method.CreateHistory(); VoltageBs = method.CreateHistory(); }
void InterpolateInThePast() { double targetTime = GetCurrentTimeSeconds() - LERP_TIME_IN_THE_PAST.TotalSeconds; if (!StateHistory.IsEmpty()) { KeyValuePair <double, StateUpdateData> before = StateHistory.GetSnapshotBefore(targetTime); KeyValuePair <double, StateUpdateData>?after = StateHistory.GetNext(before); if (after.HasValue) { Debug.Assert(targetTime <= after.Value.Key); Debug.Assert(before.Key <= after.Value.Key); if (targetTime < before.Key) // if we have a too small history { ILogger.Log(String.Format("Remote history too small. Snapping time {0} to {1}", targetTime, before.Key), LogPriority.High); targetTime = before.Key; } double progress = (targetTime - before.Key) / (after.Value.Key - before.Key); Debug.Assert(0.0 - double.Epsilon <= progress && progress <= 1.0 + double.Epsilon); Position = Vec2.Lerp(before.Value.Position, after.Value.Value.Position, (float)progress); // Take animation of closest state var closestState = after.Value.Value; Animation = closestState.Animation; FacingLeft = closestState.FacingLeft; } else { Position = before.Value.Position; //TODO: extrapolation here } } }
private void StateChanged(object sender, Events.StateChangedArgs e) { //todo: this should be pushed directly to a queue to minimize time in method. the queue can be picked up by a processor that does what this method is currently doing. Dispatcher.Invoke((state) => { State = state as ITelloState; StateHistory.Add(state as ITelloState); if (StateHistory.Count > 500) { StateHistory.RemoveAt(0); } }, e.State); var group = _repository.NewEntity <ObservationGroup>(_session); _repository.Insert(new StateObservation(group, e.State)); _repository.Insert(new AirSpeedObservation(group, e.State)); _repository.Insert(new AttitudeObservation(group, e.State)); _repository.Insert(new BatteryObservation(group, e.State)); _repository.Insert(new HobbsMeterObservation(group, e.State)); _repository.Insert(new PositionObservation(group, e.State)); }
void HandleMovementAction(ulong id, PlayerAction action) { double now = Server.Instance.GetTime().TotalSeconds; double time = action.Time; // Make sure we're not using weird times time = ValidateActionTime(action, now); // Go to the given action time if we have a state history if (!StateHistory.IsEmpty()) { // Go to the game snapshot before the action that we're simulating KeyValuePair <double, MatchState> stateBefore = StateHistory.GetSnapshotBefore(time); KeyValuePair <double, MatchState> state = new KeyValuePair <double, MatchState>( stateBefore.Key, stateBefore.Value.Clone() as MatchState); // Simulate from our previous snapshot to our current action to be up-to-date if (state.Value.ContainsEntity(id)) { var player = (ICharacter)state.Value.GetEntity(id); float deltaT = (float)(time - state.Key); if (deltaT > 0f) // if we have something to simulate... { state.Value.ApplyPhysicsUpdate(id, deltaT); } // Make sure we're not using hacked positions player.Position = ValidateActionPosition(player, action); // Actually execute the action on our currently simulated state DoAction(state.Value, player, action); // Store our intermediate state at the action time. state = StateHistory.AddSnapshot(state.Value, time); } // Resimulate all the states up to now so that they are affected // by the player's action. var nextState = StateHistory.GetNext(state); while (nextState.HasValue) { // get how much time we have to simulate for next state float timeUntilNextState = (float)(nextState.Value.Key - time); Debug.Assert(timeUntilNextState >= 0f); // simulate the next state if (nextState.Value.Value.ContainsEntity(id)) { nextState.Value.Value.GetEntity(id).Clone(state.Value.GetEntity(id)); if (timeUntilNextState > 0f) { nextState.Value.Value.ApplyPhysicsUpdate(id, timeUntilNextState); } } // switch to the next state state = nextState.Value; time = state.Key; nextState = StateHistory.GetNext(state); } // Modify our current game state to apply our simulation modifications. var last = StateHistory.GetLast(); if (Match.CurrentState.ContainsEntity(id) && last.Value.ContainsEntity(id)) { Match.CurrentState.GetEntity(id).Clone(last.Value.GetEntity(id)); } } }