public void OnTick(TickMessage message) { if (_animationIndicies?.Any() ?? false) { var nextIndex = _animationIndicies.First(); CurrentBitmapIndex = nextIndex; _animationIndicies.Remove(nextIndex); return; } }
protected void OnTick(TickMessage message) { //NPCs should only move if we're in the right state if (GameModel.Instance.State == GameState.InMap) { if (_throttleTicks == 0) { //we're not throttling, let's see if we can move var moved = MovementBehavior.TryExecuteBehavior(this); if (moved) { _throttleTicks = Constants.MAP_MOVE_CHARACTER_TICKS; } } else { //decrement the throttle counter _throttleTicks = Math.Max(0, _throttleTicks - 1); } } }
protected virtual void OnTick(TickMessage message) { //decrement the throttle counter _throttleTicks = Math.Max(-1, _throttleTicks - 1); //if we're no longer throttling, see if we have anything queued / to repeat if (_throttleTicks == 0) //we specifically check 0 here, as we only do this for 1 tick before the value goes to -1 and 'resets' { lock (_locker) //we don't want to dequeue a message or set last handled message to null while we're handling one already { _lastHandledMessage = null; //any queued message takes precedent if (_messageQueue.Count > 0) { var queuedMessage = _messageQueue.Dequeue(); //we have something in queue. Only handle it if we should be handling input at all if (HandledStates.Contains(GameModel.Instance.State)) { //we don't want to broadcast this, as it's already been broadcast, so just execute the handler OnUserInput(queuedMessage); } } //otherwise, check immediately to see if there is any key already being pressed, and broadcast that else { //only consider rebroadcasting if we're still in the state we handled originally, and we support repeating this input automatically var downInput = InputUtility.SupportedUserInput.FirstOrDefault(x => UiThread.Execute(() => Keyboard.IsKeyDown(x)) && HandledStates.Contains(GameModel.Instance.State) && (SupportedRepeatableInput?.Contains(InputUtility.MapUserInput(x)) ?? false)); if (InputUtility.IsSupportedUserInput(downInput)) { Bus.Broadcast<UserInputMessage>( UserInputMessage.New( GameModel.Instance.State, InputUtility.MapUserInput(downInput))); } } } } }
protected void OnTick2(TickMessage message) { //only try to display characters if we're in dialog, and have a currently displayed page if (_currentMessage != null && HandledStates.Contains(GameModel.Instance.State)) { var numberOfCharactersToShow = 0; switch (SettingsModel.Instance.MessageSpeed) { case MessageSpeed.Slow: numberOfCharactersToShow = message.Ticks % 2 == 0 ? 1 : 0; break; case MessageSpeed.Normal: numberOfCharactersToShow = 1; break; case MessageSpeed.Instant: numberOfCharactersToShow = 99999; //just some arbitrary large number (that isn't Int32.MaxValue, because that will cause overflow) break; default: break; } _currentMessage.Model.TryDisplayNextCharacters(numberOfCharactersToShow); } }
protected void OnTick(TickMessage message) { //are we in battle (as opposed to in battle dialog, or no input) if (GameModel.Instance.State == GameState.InBattle && BattleModel.Instance?.BattlefieldData != null) { //are we waiting on a battle ability to finish executing? if (BattleModel.Instance.BattlefieldData.ExecutingAbility != null) { //we want to pause while abilities are firing. If we don't, on long-running animations, a fast character may be able to lock //in an ability and have to wait 20 seconds, while a slow character would get 20 seconds of extra time to tick away and lock //in as well, effectively boosting the ability of a slower character, and penalizing the fast character return; } //do we have any queued abilities that need to be triggered? var queuedAbilityToFire = _queuedAbilities.FirstOrDefault(x => x.RemainingDelayTicks <= 0); if (queuedAbilityToFire != null) { //remove from the queue, handle ability activation, set state to waiting to finish if we've activated an ability _queuedAbilities.Remove(queuedAbilityToFire); HandleQueuedAbilityActivation(queuedAbilityToFire); return; } //do we have any enemies that are ready? foreach (var readyEnemy in BattleModel.Instance.BattleData.AllAliveEnemiesInBattle.Where(x => x.ActionStatus == BattleActionStatus.ReadyForInput)) { //get the enemy's next action, create a queued ability from that, and queue it up var enemyAction = readyEnemy.Enemy.Ai.GetNextAction(readyEnemy, BattleModel.Instance.BattleData); QueueAbility(readyEnemy, enemyAction.Ability, enemyAction.Target); } //are we waiting on user input? if (BattleModel.Instance.BattleData.AllAlivePartyMembersInBattle.Any(x => x.ActionStatus == BattleActionStatus.ReadyForInput) && SettingsModel.Instance.BattleSpeed == BattleSpeed.Wait) { return; } //time ticks on //advance action counters var actionMultiplier = BattleModel.Instance.BattleData.GetActionMultiplier(); foreach (var battleEntityInBattle in BattleModel.Instance.BattleData.AllAliveBattleEntitiesInBattle) { battleEntityInBattle.IncreaseActionCounter(actionMultiplier); } //advance queued ability ticks foreach (var queuedAbility in _queuedAbilities) { queuedAbility.RemainingDelayTicks--; } } }
protected void OnTick(TickMessage message) { _resetStepFrameDelay = Math.Max(-1, _resetStepFrameDelay - 1); if (_resetStepFrameDelay == 0) { Look(_currentDirection); } }
protected void OnTick(TickMessage message) { TicksPlayed++; }
protected void OnTick(TickMessage message) { SlowBlinkOn = TimerUtility.BlinkOn(message.Ticks, Constants.TIMING_BLINK_TICKS); FastBlinkOn = TimerUtility.BlinkOn(message.Ticks, Constants.TIMING_QUICK_BLINK_TICKS); }