void Update() { switch(timeState) { case TimeState.Normal: Time.timeScale = 1.0f; break; case TimeState.Slowed: StartCoroutine(SlowdownTime()); timeState = TimeState.Speeding; break; case TimeState.Slowing: while(Time.timeScale - targetScale > 0.001f) Time.timeScale = Mathf.Lerp(Time.timeScale, targetScale, warpSpeed); timeState = TimeState.Slowed; break; case TimeState.Speeding: while(1.0f - Time.timeScale > 0.001f) Time.timeScale = Mathf.Lerp(Time.timeScale, 1.0f, warpSpeed); timeState = TimeState.Normal; break; default: break; } print (Time.timeScale); //smooth out the framerate during the slowdown Time.fixedDeltaTime = Time.timeScale * 0.02f; }
/// <summary> /// (协程)白天到黑夜 /// </summary> /// <param name="per"></param> /// <returns></returns> public IEnumerator DayToNight(float per) { for (float i = daySprt[0].color.a; curTime == TimeState.Day; i -= per) { //每次必然是遍历了一遍的,所以取值只要开头的,终止判断只要最后的。 //减弱 for (int imask = 0; imask < GreenMask.Count; imask++) { GreenMask[imask].color = GreenMask[imask].color - new Color(0, 0, 0, per * 2); } //减弱 for (int index = 0; index < daySprt.Count; index++) { daySprt[index].color = new Color(daySprt[index].color.r, daySprt[index].color.g, daySprt[index].color.b, i); } //加强 for (int index = 0; index < nightSprt.Count; index++) { if (nightSprt[index].gameObject.tag.Equals("Light")) { nightSprt[index].color = new Color(nightSprt[index].color.r, nightSprt[index].color.g, nightSprt[index].color.b, nightLightIntensity[index] - i); continue; } nightSprt[index].color = new Color(nightSprt[index].color.r, nightSprt[index].color.g, nightSprt[index].color.b, 1 - i); } //加强 for (int imask = 0; imask < BlueMask.Count; imask++) { //如果Alpha的值小于完全值,则加强 if (BlueMask[imask].color.a <= BlueAlpha[imask]) { BlueMask[imask].color = BlueMask[imask].color + new Color(0, 0, 0, per * 2); } } //如果放开改变时间的按钮 //if (!isChanging) //{ // ChangeTimeLock = false; // yield break; //} if (daySprt[daySprt.Count - 1].color.a <= 0) { curTime = TimeState.Night; } yield return(null); } ChangeTimeLock = false; //释放锁 isChanging = false; }
public void progressTimeState() { switch (currentTimeState) { case TimeState.Morning: lightingObjects[0].SetActive(false); lightingObjects[1].SetActive(true); currentTimeState = TimeState.Lunch; transitionManager.makeTransition(Transition.Lunch); break; case TimeState.Lunch: lightingObjects[1].SetActive(false); lightingObjects[2].SetActive(true); currentTimeState = TimeState.Afternoon; transitionManager.makeTransition(Transition.Afternoon); break; case TimeState.Afternoon: lightingObjects[2].SetActive(false); lightingObjects[3].SetActive(true); currentTimeState = TimeState.DateSelection; transitionManager.makeTransition(Transition.DateSelection); break; case TimeState.DateSelection: if (isLastDay()) { currentTimeState = TimeState.End; transitionManager.makeTransition(Transition.Ending, 0); } else { currentTimeState = TimeState.Date; transitionManager.makeTransition(Transition.Date); } setUpDateGameObjects(); break; case TimeState.Date: lightingObjects[3].SetActive(false); lightingObjects[0].SetActive(true); currentTimeState = TimeState.Morning; cleanUpDateGameObjects(); advancetoNextDay(); break; } }
public void RewindTime(int customRewindSpeed = -1) { if (customRewindSpeed == -1) { currentRewindSpeed = RewindSpeed; } else { currentRewindSpeed = customRewindSpeed; } ApplyToEveryInstance((timeInteractable) => { timeInteractable.RewindTime(currentRewindSpeed); }); timeState = TimeState.Rewind; }
public void SlowTime(int customSlowFactor = -1) { if (customSlowFactor == -1) { currentSlowFactor = SlowTimeFactor; } else { currentSlowFactor = customSlowFactor; } ApplyToEveryInstance((timeInteractable) => { timeInteractable.SlowTime(currentSlowFactor); }); timeState = TimeState.Slow; }
private void PerformSwap() { m_PerformingSwap = false; Time.timeScale = 1f; Time.fixedDeltaTime = 0.02F * Time.timeScale; CurrentState = CurrentState == TimeState.PAST ? TimeState.FUTURE : TimeState.PAST; OnTimeSwap(); if (!m_FirstSwapDone) { m_FirstSwapDone = true; DialogueController.Instance.StartDialogue(DialogueEvent.FIRST_WARP); } }
public void Time_Record_Play() { Physics.autoSimulation = false; if (state == TimeState.None) { state = TimeState.Freeze; foreach (var u in units) { u.Record_Play(); } onRecordPlay.Invoke(); } state = TimeState.Freeze; }
public static void ChangeState(TimeState newState) { //singleton.state = newState; if (newState == TimeState.Slow) { Time.timeScale = singleton.slowScale; } else if (newState == TimeState.Normal) { Time.timeScale = singleton.normalScale; } Time.fixedDeltaTime = 0.02f * Time.timeScale; }
public void Time_Direction(float dir) { if (dir > 0) { state = TimeState.Flow; } else if (dir < 0) { state = TimeState.Rewind; } else { state = TimeState.Freeze; } }
public void Closed(TimeState ts) { if (ts == TimeState.Past && past.SpriteSheet.Name.ToLower().Contains("door")) { past = pastClosed; pastCollidable = true; open = false; } else if (future.SpriteSheet.Name.ToLower().Contains("door")) { future = futureClosed; futureCollidable = true; open = false; } }
public static void FastForwardStep() { State = TimeState.FastForward; if (!Running) { return; } timeGame++; SafeSetPixel(timeGame, getLoopUniverse(Universe * 5), FastForwardColor); LastState = State; }
private void timeWindow(int windowID) { GUILayout.Label("Set Time:"); foreach (var en in Enum.GetValues(typeof(TimeState))) { TimeState e = (TimeState)en; if (GUILayout.Button(e.ToString())) { SetTime(e); } } GUI.DragWindow(); }
// 시간 되돌리기 public void ReverseTime( TimeState beforeTS, TimeState dbBeforeTS, float linear, GameObject target, Components components ) { Vector2 vec2 = Vector2.Lerp( dbBeforeTS.TObjectSt.Position, beforeTS.TObjectSt.Position, linear); target.transform.position = vec2; }
void CheckForNightTime() { //Has our day ended? if (FL_actionPointsUsed >= FL_actionPointsAvailable) { FL_actionPointsUsed = FL_actionPointsAvailable; FL_morning = FL_actionPointsAvailable * FL_dayHours / FL_workHours; FL_time = FL_actionPointsAvailable; BL_pause = true; BL_playerControlledEvent = false; State = TimeState.Nighttime; } }
private void SlowTimeInternal() { switch (_currentState) { case TimeState.Stopping: break; case TimeState.Slow: _nextStateChange = Time.time + _slowHoldDuration; break; default: _currentState = TimeState.Stopping; _nextStateChange = Time.time + _slowDownDuration; break; } }
public override void TimeStateChange(TimeState old, TimeState nu) { if (nu == TimeState.Normal) { GetComponent <NavMeshAgent>().Resume(); } if (old != TimeState.Normal && nu == TimeState.Normal) { GetComponent <NavMeshAgent>().velocity = lastVelocity; } if (nu != TimeState.Normal) { GetComponent <NavMeshAgent>().velocity = Vector3.zero; GetComponent <NavMeshAgent>().Stop(); } }
public Gamestate(PlayerUnit playerUnit, Unit unit, Scenery scenery, EventsState events, InputState input, PhysicsState physics, VideoState video, AudioState audio, TimeState time) { Assert.Ref(playerUnit, unit, scenery, events, input, physics, video, audio, time); PlayerUnit = playerUnit; Scenery = scenery; Unit = unit; Events = events; Input = input; Physics = physics; Video = video; Audio = audio; Time = time; }
// 시간 되돌리기 public void ReverseTime( TimeState beforeTS, TimeState dbBeforeTS, float linear, GameObject target, Components components ) { components.GetRigidBody2D().velocity = Vector2.up * Mathf.Lerp(dbBeforeTS.TActorSt.JumpHeight, beforeTS.TActorSt.JumpHeight, linear); components.GetAnimator().SetBool("isMove", beforeTS.TActorSt.IsMoveAnimator); target.transform.rotation = Quaternion.Euler(0, RotateYFloat, 0); }
public void Pause() { if (currentState != TimeState.Paused) { //Freeze Timescale and make note of previous scale //Assumes nothing else has control over time previousTimescale = Time.timeScale; Time.timeScale = 0.0f; if (pauseScreen) { pauseScreen.gameObject.SetActive(true); } this.currentState = TimeState.Paused; } }
private TimeSpan?LookForDelimiter(TimeState state) { while (true) { char c = _stream.Peek(0); if (c == EOF) { return(Finish(state)); } switch (c) { case ':': _stream.ReadChar(); return(LookForMinuteChar(state)); case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return(LookForMinuteChar(state)); case 'p': case 'P': case 'a': case 'A': return(LookForAmPm(state)); case ' ': case '\t': case '\r': case '\n': _stream.ReadChar(); continue; default: return(null); } } }
// 시간과 관련된 정보를 등록한다. void RegisterTimeState() { // 상속을 사용해서 해결해본다? TimeState timeState = new TimeState(); // 이동 관련 정보 Vector2 vec2Pos = new Vector2(transform.position.x, transform.position.y); for (int i = 0; i < components.Properties.Length; i++) { switch (components.Properties[i]) { case Components.EnumProperty.OBJECT: TObjectState tos = new TObjectState { Position = vec2Pos, DeltaTime = Time.deltaTime, RealPlayTime = Time.realtimeSinceStartup }; timeState.TObjectSt = tos; tos.AttachEvent(timeState); break; case Components.EnumProperty.ACTOR: TActorState tas = new TActorState { JumpHeight = rb2D.velocity.y, IsMoveAnimator = components.GetAnimator().GetBool("isMove"), RotateYFloat = transform.rotation.eulerAngles.y }; timeState.TActorSt = tas; tas.AttachEvent(timeState); break; } } if (OtherRegisterEvent != null) { OtherRegisterEvent(); } TimeStates.Add(timeState); }
public void toggle_pause() { if (Input.anyKeyDown) { return; } if (_state == TimeState.Running) { _state = TimeState.Paused; _stopwatch.Stop(); } else if (_state == TimeState.Paused) { _state = TimeState.Running; _stopwatch.Start(); } }
private void SlowTimeInternal() { switch (_currentState) { case TimeState.Stopping: break; case TimeState.Slow: _nextStateChange = Time.time + _slowHoldDuration; break; default: _currentState = TimeState.Stopping; _nextStateChange = Time.time + _slowDownDuration; break; } }
public override void TimeStateChange(TimeState old, TimeState nu) { Rigidbody rb = GetComponent <Rigidbody>(); if (old != TimeState.Normal && nu == TimeState.Normal) { rb.isKinematic = false; rb.angularVelocity = m_lastAngularVelocity; rb.velocity = m_lastVelocity; } if (old == TimeState.Normal && nu != TimeState.Normal) { m_lastAngularVelocity = rb.angularVelocity; m_lastVelocity = rb.velocity; rb.isKinematic = true; } }
public void CallReverseTimeEvent( TimeState beforeTS, TimeState dbBeforeTS, float linear, GameObject gameObject, Components components) { if (reverseTimeEvent != null) { reverseTimeEvent( beforeTS, dbBeforeTS, linear, gameObject, components); } }
public void SlowTime(Transform hierarchy, int customSlowFactor = -1) { if (customSlowFactor == -1) { currentSlowFactor = SlowTimeFactor; } else { currentSlowFactor = customSlowFactor; } TraverseAndApplyToTimeHierarchy(hierarchy, (timeInteractable) => { timeInteractable.SlowTime(currentSlowFactor); }); timeState = TimeState.Slow; }
public void Open(TimeState ts) { //check the time that we're activating the door //make sure that the tile is a door in that time state and not a wall if (ts == TimeState.Past && past.SpriteSheet.Name.ToLower().Contains("door")) { past = pastOpen; pastCollidable = false; open = true; } else if (future.SpriteSheet.Name.ToLower().Contains("door")) { future = futureOpen; futureCollidable = false; open = true; } }
void ResetTimer() { if (IN_currentDay < 10) { Days.text = string.Format("0" + IN_currentDay); } else { Days.text = string.Format("" + IN_currentDay); } FL_actionPointsUsed = 0; BL_pause = false; State = TimeState.Daytime; BL_playerControlledEvent = true; }
public void RewindTime(Transform hierarchy, int customRewindSpeed = -1) { if (customRewindSpeed == -1) { currentRewindSpeed = RewindSpeed; } else { currentRewindSpeed = customRewindSpeed; } TraverseAndApplyToTimeHierarchy(hierarchy, (timeInteractable) => { timeInteractable.RewindTime(currentRewindSpeed); }); timeState = TimeState.Rewind; }
private void Initialise() { int hour = GetHour(time); int minute = GetMin(time); if (hour > hourNight || hour == hourNight && minute >= minNight || hour < hourDay || hour == hourDay && minute < minDay) { cycle = TimeState.NIGHT; if (HasNode("Canvas_DayNight")) { CanvasModulate CM = GetNode <CanvasModulate>("Canvas_DayNight"); CM.Color = MODCAN_N; } if (HasNode("fog")) { Material mat = GetNode <Sprite>("fog").Material; mat.Set("shader_param/mult", FOG_N); } if (GetTree().GetNodesInGroup("Player").Count == 1) { Light2D light = ((Node)GetTree().GetNodesInGroup("Player")[0]).GetNode <Light2D>("light"); light.Energy = PLAYERLIGHT_N; } } else { cycle = TimeState.DAY; if (HasNode("Canvas_DayNight")) { CanvasModulate CM = GetNode <CanvasModulate>("Canvas_DayNight"); CM.Color = MODCAN_D; } if (HasNode("fog")) { Material mat = GetNode <Sprite>("fog").Material; mat.Set("shader_param/mult", FOG_D); } if (GetTree().GetNodesInGroup("Player").Count == 1) { Light2D light = ((Node)GetTree().GetNodesInGroup("Player")[0]).GetNode <Light2D>("light"); light.Energy = PLAYERLIGHT_D; } } }
private void SwitchTimeState() { if (gamePaused) { return; } if (playerRB.velocity.x > 1f || playerRB.velocity.x < -1f || playerRB.velocity.y > 1f || playerRB.velocity.y < -1f) { timeState = TimeState.Normal; } else { timeState = TimeState.Stopped; } // if (Input.anyKey) timeState = TimeState.Normal; // else timeState = TimeState.Stopped; TimeShift(); }
private void UpdateColorManagement() { if (_isIgnoreUpdateWhileAnimation || _isIgnoreUpdates) { return; } TimeState timeState = GetTimeState(); if (_currentTimeState != timeState) { CurrentTimeState = timeState; } else { StartCoroutine(IgnoringUpdateUntilNextHour()); } }
private void Update() { if (Time.time > _nextStateChange) { switch (_currentState) { case TimeState.Stopping: _currentState = TimeState.Slow; _nextStateChange = Time.time + _slowHoldDuration; break; case TimeState.Slow: _currentState = TimeState.SpeedingUp; _nextStateChange = Time.time + _speedUpDuration; break; default: _currentState = TimeState.Regular; break; } } switch (_currentState) { case TimeState.Stopping: _timeScale = Mathf.Lerp(_timeScale, _slowTime, 1 - (_nextStateChange - Time.time)/_slowDownDuration); break; case TimeState.Slow: _timeScale = _slowTime; break; case TimeState.SpeedingUp: _timeScale = Mathf.Lerp(_timeScale, 1, 1 - (_nextStateChange - Time.time)/_speedUpDuration); break; default: _timeScale = 1; break; } Time.timeScale = _timeScale; Time.fixedDeltaTime = _initialFixedDelta*_timeScale; }
private TimeSpan? LookForHourChar(TimeState state, bool beenHere = false) { while (true) { char c = _stream.ReadChar(); if (c == EOF) return beenHere && state.IsComplete ? state.ToTimeSpan() : null; switch (c) { case '0': case '1': case '2': if (beenHere) { state.Hour *= 10; state.Hour += c - ZERO_CHAR; return LookForDelimiter(state); } else { state.Hour = c - ZERO_CHAR; beenHere = true; continue; } case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (beenHere) { state.Hour *= 10; state.Hour += c - ZERO_CHAR; } else state.Hour = c - ZERO_CHAR; return LookForDelimiter(state); case ' ': case '\t': case '\r': case '\n': beenHere = false; continue; default: return null; } } }
// Update is called once per frame void Update() { float currentTime = GlobalTime.getTime(); m_currentDeltaTime = currentTime - m_oldTime; // Check if inside buffer, then read from it setTimescaleStateBasedOnTime(currentTime); // Try to read from buffer if (isReadingFromBuffer()) { float t=0.0f; int deltaSign = getDeltaSign(); int currentPos = getBufferPosFromTime(currentTime, out t); // int nextPos = getBufferPosFromTime(GlobalTime.getTime(),out t); if (currentPos >= 0 && currentPos<m_buffer.Count) { TimeState currentState = m_buffer[currentPos]; // TimeState nextState = m_buffer[currentPos]; transform.position = new Vector3(currentState.m_position.x,currentState.m_position.y,transform.position.z); if (m_frameData == null) { transform.rotation = new Quaternion(currentState.m_rotation.x, currentState.m_rotation.y, currentState.m_rotation.z, currentState.m_rotation.w); } else { m_frameData.m_frameData = new Vector2(currentState.m_rotation.x, currentState.m_rotation.y); } transform.localScale = currentState.m_scale; } else // outside buffer, resume realtime { setTimescaleStateBasedOnTime(currentTime); } } // second check in case it was not read if (isWritingToBuffer()) { float t = 0.0f; int currentPos = getBufferPosFromTime(currentTime, out t); // TimeState newState = null; if (m_frameData == null) { newState = new TimeState(transform.position, transform.rotation, transform.localScale); } else { newState = new TimeState(transform.position, m_frameData.m_frameData, transform.localScale); } if (currentPos > m_buffer.Count-1) { m_buffer.Add(newState); m_endTime = currentTime; } else if (currentPos>=0) { m_buffer[currentPos] = newState; } // do not allow more than the specified amount of seconds if (m_buffer.Count > m_maxBufferLength) { m_startTime += m_stepSizeSec; m_buffer.RemoveAt(0); } } if (m_hideWhenNotSpawned) hideWhenNotExisting(); m_oldTime = currentTime; }
private TimeSpan? LookForAmPm(TimeState state) { while (true) { char c = _stream.ReadChar(); if (c == EOF) return Finish(state); switch (c) { case 'a': case 'A': state.Is24Hour = false; state.IsPM = false; return LookForAmPmEnd(state); case 'p': case 'P': state.Is24Hour = false; state.IsPM = true; return LookForAmPmEnd(state); case ' ': case '\t': case '\r': case '\n': continue; default: return null; } } }
public async Task OnSuccess(TimeState timeState) { await this._backgroundTileClient.NotificationManager.ShowDialogAsync( BandConstants.TileId, CTime2CoreResources.Get("BandService.ApplicationName"), CTime2CoreResources.Get("BandService.StampedSuccessfully")); }
private TimeSpan? LookForHourChar(TimeState state, bool beenHere = false) { char c = stream.ReadChar(); if (c == EOF) return beenHere && state.IsComplete ? state.ToTimeSpan() : null; switch (c) { case '0': case '1': case '2': if (beenHere) { state.Hour *= 10; state.Hour += ((int)c) - zeroChar; return LookForDelimiter(state); } else { state.Hour = ((int)c) - zeroChar; return LookForHourChar(state, true); } case '3': case '4': case '5': case '6': case '7': case '8': case '9': if (beenHere) { state.Hour *= 10; state.Hour += ((int)c) - zeroChar; } else state.Hour = ((int)c) - zeroChar; return LookForDelimiter(state); case ' ': case '\t': case '\r': case '\n': return LookForHourChar(state, false); default: return null; } }
/// <summary> /// Starts the new turn. /// </summary> /// <returns> /// The new turn. /// </returns> protected IEnumerator startNewTurn(AWebCoroutine a){ WWW www = WWWX.Get(WebRequests.urlGetTurnState,WebRequests.authenticatedParameters); while (!www.isDone) { ProcessIsRunning = true; yield return www; } yield return new WaitForSeconds(5); m_TimeState = JSONDecoder.Decode<TimeState>(www.text); timer = m_TimeState.time_left; string state = m_TimeState.state; if(state == "processing"){ //make sure that the game had passed through "processing phase" isPutting = true; } if(state == "playing" && isPutting == true){ isAfterProcessing = true; } ProcessIsRunning = false; Debug.Log ("New Turn"); TimeIsRunning = false; yield break; }
public static Color GetHighlightColorByTimeState(TimeState state) { return Instance.GetColorByTimeState(state); }
private async Task OnSuccess(TimeState timeState) { var message = new VoiceCommandUserMessage { DisplayMessage = timeState.IsEntered() ? CTime2VoiceCommandServiceResources.Get("SuccessfullyCheckedIn") : CTime2VoiceCommandServiceResources.Get("SuccessfullyCheckedOut"), SpokenMessage = timeState.IsEntered() ? CTime2VoiceCommandServiceResources.Get("SuccessfullyCheckedIn") : CTime2VoiceCommandServiceResources.Get("SuccessfullyCheckedOut"), }; var response = VoiceCommandResponse.CreateResponse(message); await this._connection.ReportSuccessAsync(response); }
private TimeSpan? LookForMinuteChar(TimeState state, bool beenHere = false) { while (true) { char c = _stream.ReadChar(); if (c == EOF) return beenHere && state.IsComplete ? state.ToTimeSpan() : null; switch (c) { case 'a': case 'A': case 'p': case 'P': _stream.Backup(1); return LookForAmPm(state); case ' ': case '\t': case '\r': case '\n': beenHere = false; continue; case '0': case '1': case '2': case '3': case '4': case '5': if (beenHere) { state.Minute *= 10; state.Minute += c - ZERO_CHAR; return LookForAmPm(state); } else { state.Minute = c - ZERO_CHAR; beenHere = true; continue; } case '6': case '7': case '8': case '9': if (!beenHere) return null; // minutes can't start with 6-9 state.Minute *= 10; state.Minute += c - ZERO_CHAR; return LookForAmPm(state); default: return null; // invalid character } } }
public TimeSpan? Parse() { var state = new TimeState(); return LookForHourChar(state); }
public async Task SaveTimer(string employeeGuid, string rfidKey, DateTime time, string companyId, TimeState state, bool withGeolocation) { try { Geopoint location = withGeolocation ? await this._geoLocationService.TryGetGeoLocationAsync() : null; var responseJson = await this.SendRequestAsync("V2/SaveTimerV2.php", new Dictionary<string, string> { {"TimerKind", ((int) state).ToString()}, {"TimerText", string.Empty}, {"TimerTime", time.ToString("yyyy-MM-dd HH:mm:ss")}, {"EmployeeGUID", employeeGuid}, {"GUID", companyId}, {"RFID", rfidKey}, {"lat", location?.Position.Latitude.ToString(CultureInfo.InvariantCulture) ?? string.Empty }, {"long", location?.Position.Longitude.ToString(CultureInfo.InvariantCulture) ?? string.Empty } }); if (responseJson?.Value<int>("State") == 0) { this._eventAggregator.PublishOnCurrentThread(new UserStamped()); } } catch (Exception exception) { Logger.Warn($"Exception in method {nameof(this.SaveTimer)}. Employee: {employeeGuid}, Time: {time}, Company Id: {companyId}, State: {(int)state}"); Logger.Error(exception); throw new CTimeException(CTime2CoreResources.Get("CTimeService.ErrorWhileStamp"), exception); } }
public Task OnSuccess(TimeState timeState) => this._onSuccess(timeState);
private static TimeSpan? Finish(TimeState state) { return state.IsComplete ? state.ToTimeSpan() : null; }
private string GetSpriteNameByTimeState(TimeState timeState) { return _colorStates[(int)timeState].SpriteName; }
public static async Task SaveTimer(this ICTimeService self, User user, TimeState state) { await self.SaveTimer(user.Id, string.Empty, DateTime.Now, user.CompanyId, state, user.SupportsGeoLocation); }
/// <summary> /// Gets the turn time left. /// </summary> /// <returns> /// The turn time left. /// </returns> protected IEnumerator GetTurnTimeLeft(AWebCoroutine a) { WWW www = WWWX.Get(WebRequests.urlGetTurnState,WebRequests.authenticatedParameters); while (!www.isDone) { TimeIsRunning = true; yield return www; } yield return new WaitForSeconds(5); m_TimeState = JSONDecoder.Decode<TimeState>(www.text); timer = m_TimeState.time_left; TimeIsRunning = false; if(timer <= 0){ isTurnOver = true; } yield break; }
private Color GetColorByTimeState(TimeState timeState) { Color color = _colorStates[(int)timeState].Color; //print("ColorManagementSystemController.GetColorByTimeState: timeState -" + timeState + " color - " + color); return color; }
public async Task Stamp(ICTimeStampHelperCallback callback, TimeState timeState) { await this._applicationStateService.RestoreStateAsync(); if (this._applicationStateService.GetCurrentUser() == null) { Logger.Info("User is not logged in."); await callback.OnNotLoggedIn(); return; } bool checkedIn = await this._cTimeService.IsCurrentlyCheckedIn(this._applicationStateService.GetCurrentUser().Id); if (checkedIn && timeState.IsEntered()) { if (callback.SupportsQuestions()) { Logger.Info("User wants to check-in. But he is already. Asking him if he wants to check-out instead."); var checkOutResult = await callback.OnAlreadyCheckedInWannaCheckOut(); if (checkOutResult == false) { Logger.Info("User does not want to check-out. Doing nothing."); await callback.OnDidNothing(); return; } timeState = TimeState.Left; } else { Logger.Info("User wants to check-in. But he is already. Doing nothing."); await callback.OnAlreadyCheckedIn(); return; } } if (checkedIn == false && timeState.IsLeft()) { if (callback.SupportsQuestions()) { Logger.Info("User wants to check-out. But he is already. Asking him if he wants to check-in instead."); var checkInResult = await callback.OnAlreadyCheckedOutWannaCheckIn(); if (checkInResult == false) { Logger.Info("User does not want to check-in. Doing nothing."); await callback.OnDidNothing(); return; } timeState = TimeState.Entered; } else { Logger.Info("User wants to check-out. But he is already. Doing nothing."); await callback.OnAlreadyCheckedOut(); return; } } Logger.Info("Saving the timer."); await this._cTimeService.SaveTimer( this._applicationStateService.GetCurrentUser(), timeState); Logger.Info("Finished voice command."); await callback.OnSuccess(timeState); }
//dilate: begin the slowdown process public void dilate(float targetScale, float duration) { this.targetScale = targetScale; this.duration = duration; timeState = TimeState.Slowing; }
private TimeSpan? LookForDelimiter(TimeState state) { while (true) { char c = _stream.Peek(0); if (c == EOF) return Finish(state); switch (c) { case ':': _stream.ReadChar(); return LookForMinuteChar(state); case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': return LookForMinuteChar(state); case 'p': case 'P': case 'a': case 'A': return LookForAmPm(state); case ' ': case '\t': case '\r': case '\n': _stream.ReadChar(); continue; default: return null; } } }
private TimeSpan? LookForAmPmEnd(TimeState state) { char c = _stream.ReadChar(); if (c == EOF) return Finish(state); switch (c) { case 'm': case 'M': return Finish(state); default: return null; } }
private void Start() { _instance = this; _initialFixedDelta = Time.fixedDeltaTime; _currentState = TimeState.Regular; }