public void UpdateTransitions(List <TransitionInfo> groups) { transitions.Clear(); m_acceptKeys = 0; foreach (var group in groups) { var trans = group.GetTransitions(info.ID); if (trans == null) { continue; } foreach (var tran in trans) { var t = StateMachineTransition.Create(stateMachine, tran); if (!t) { continue; } transitions.Add(t); if (t.info.acceptKeyMask == 0) { continue; } m_acceptKeys |= t.info.acceptKeyMask; } } }
public static List <EmbeddedInputModel> GetTransitionInputs(this StateMachineTransition transition) { bool moreToEvaluate = true; List <EmbeddedInputModel> _inputsForTransition = new List <EmbeddedInputModel>(); while (moreToEvaluate) { /*Check the conditions of the transition and assemble a list of the relevant inputs.*/ if (transition.Condition.ConditionType == ConditionType.Input) { _inputsForTransition.Add(new EmbeddedInputModel(transition.Condition.SourceInputId)); moreToEvaluate = false; } else { foreach (var condition in transition.Condition.Conditions) { if (condition.ConditionType == ConditionType.Input) { if (!transition.IsInputInList(condition.SourceInputId, _inputsForTransition)) { _inputsForTransition.Add(new EmbeddedInputModel(transition.Condition.SourceInputId)); } } } moreToEvaluate = false; } } return(_inputsForTransition); }
protected override StateMachineTransition <PracticeGameStates> Transition(Entity entity, PracticeGameStateComponent stateMachine) { return(StateMachineTransition <PracticeGameStates> .None()); // TODO ADD CHECKS FOR WHEN ALL PLAYERS JOINED // AND FOR WHEN ALL PLAYERS ARE ON ZONES OR NOT }
/*Gets a list of references to inputs relevant to a given transition.*/ public static void AddInputsForTransition(StateMachineTransition transition, StateMachine parentStateMachine, List <StateMachineInput> inputList) { List <StateMachineCondition> conditionList = new List <StateMachineCondition>(); conditionList.Add(transition.Condition); AccumulateInputsFromConditionList(conditionList, inputList, parentStateMachine); }
protected override StateMachineTransition <CharacterChoiceStates> Transition(Entity entity, CharacterChoiceStateMachineComponent stateMachine) { var input = entity.getComponent <PlayerInputComponent>(); var state = stateMachine.State; if (state.StateEnum == CharacterChoiceStates.Idle && Math.Abs(input.MovementStick.X) > CharacterChoiceState.MOVEMENT_THRESHOLD) { if (input.MovementStick.X > 0) { Console.WriteLine($"rotating right!"); return(StateMachineTransition <CharacterChoiceStates> .Replace(CharacterChoiceStates.RotatingRight)); } else { Console.WriteLine($"rotating left!"); return(StateMachineTransition <CharacterChoiceStates> .Replace(CharacterChoiceStates.RotatingLeft)); } } else if (state.StateEnum == CharacterChoiceStates.RotatingLeft || state.StateEnum == CharacterChoiceStates.RotatingRight) { if (Time.time - state.LastRotatedTime > CharacterChoiceState.ROTATION_TIME) { Console.WriteLine($"done rotating!! back to idle"); return(StateMachineTransition <CharacterChoiceStates> .Replace(CharacterChoiceStates.Idle)); // back into idle } } return(StateMachineTransition <CharacterChoiceStates> .None()); }
private void Reload(StateMachineTransition model) { Parent.DirtyService.MarkDirty(); _model = model; ModelInitialize(); RaisePropertyChanged(null); _parent.SaveUndoState(); }
/// <inheritdoc /> public override void Dispose() { if (IsDisposing) { return; } _transition = null; base.Dispose(); }
public TransitionViewModel(StateMachineViewModel parent, StateMachineTransition model, IViewService viewService, IMessageBoxService messageBoxService) { _parent = parent ?? throw new ArgumentNullException(nameof(parent)); _model = model ?? throw new ArgumentNullException(nameof(model)); _viewService = viewService ?? throw new ArgumentNullException(nameof(viewService)); _messageBoxService = messageBoxService ?? throw new ArgumentNullException(nameof(messageBoxService)); _propertyGridSource = new Lazy <TransitionPropertyGridSource>(() => new TransitionPropertyGridSource(this)); CommandInitialize(); ModelInitialize(); }
public static bool IsInputInList(this StateMachineTransition transition, Guid?id, List <EmbeddedInputModel> inputList) { foreach (var input in inputList) { if (id == input.Id) { return(true); } } return(false); }
public StringBuilder Generate(StateMachineTransition transition, StateMachineInput[] inputs) { _conditionGuids = new List <Guid>(); StringBuilder s = new StringBuilder(); if (transition.Condition != null) { s.Append(AddCondition(transition.Condition, inputs)); } return(s); }
protected override StateMachineTransition <GameStates> Transition(Entity entity, GameStateComponent stateMachine) { var state = stateMachine.State; var gameStateTimer = entity.getComponent <TimerComponent>(); switch (state.StateEnum) { case GameStates.Ready: return(StateMachineTransition <GameStates> .Replace(GameStates.Service)); case GameStates.Service: var ballVelocity = state.Ball.getComponent <VelocityComponent>(); var ballState = state.Ball.getComponent <BallStateComponent>(); if (!ballVelocity.Freeze) { ballVelocity.Velocity = ballVelocity.Velocity / ballState.HitBoost; ballState.HitBoost = 1.0f; return(StateMachineTransition <GameStates> .Replace(GameStates.Play)); } break; case GameStates.Play: var knockedOutTeam = isOneTeamKnockedOut(state.Players); switch (knockedOutTeam) { case Gameplay.Side.LEFT: return(StateMachineTransition <GameStates> .Replace(GameStates.PointScoredRight)); case Gameplay.Side.RIGHT: return(StateMachineTransition <GameStates> .Replace(GameStates.PointScoredLeft)); case Gameplay.Side.NONE: break; default: throw new ArgumentOutOfRangeException(); } break; case GameStates.PointScoredRight: case GameStates.PointScoredLeft: if (gameStateTimer.Finished) { return(StateMachineTransition <GameStates> .Replace(GameStates.Service)); } break; default: throw new ArgumentOutOfRangeException(); } return(StateMachineTransition <GameStates> .None()); }
/// <summary> /// Initializes a new instance of the <see cref="TransitionEditor"/> class. /// </summary> /// <param name="transition">The transition.</param> public TransitionEditor(StateMachineTransition transition) { _transition = transition ?? throw new ArgumentNullException(nameof(transition)); // Context menu dimensions const float width = 280.0f; const float height = 220.0f; Size = new Vector2(width, height); // Title var title = new Label(2, 2, width - 4, 23.0f) { Font = new FontReference(Style.Current.FontLarge), Text = transition.SurfaceName, Parent = this }; // Buttons float buttonsWidth = (width - 8.0f) * 0.5f; float buttonsHeight = 20.0f; var editRuleButton = new Button(2.0f, title.Bottom + 2.0f, buttonsWidth, buttonsHeight) { Text = "Edit Rule", Parent = this }; editRuleButton.Clicked += OnEditRuleButtonClicked; var deleteButton = new Button(editRuleButton.Right + 2.0f, editRuleButton.Y, buttonsWidth, buttonsHeight) { Text = "Delete", Parent = this }; deleteButton.Clicked += OnDeleteButtonClicked; // Actual panel var panel1 = new Panel(ScrollBars.Vertical) { Bounds = new Rectangle(0, deleteButton.Bottom + 2.0f, width, height - deleteButton.Bottom - 2.0f), Parent = this }; var editor = new CustomEditorPresenter(null); editor.Panel.DockStyle = DockStyle.Top; editor.Panel.IsScrollable = true; editor.Panel.Parent = panel1; editor.Select(_transition); }
private StringBuilder AddOutputActions(StateMachineTransition transition, StateMachineOutputAction[] actions) { StringBuilder s = new StringBuilder($"##### No Output Actions"); if (transition.TransitionActions != null && transition.TransitionActions.Any()) { s = new StringBuilder($"##### Output Actions"); s.Append(Environment.NewLine); foreach (var item in transition.TransitionActions) { s.Append($"* {(actions.First(x => x.Id == item).Name)}"); } } return(s); }
public static List <StateMachineOutputAction> GetAllAssociatedActions(this StateMachineTransition transition, StateMachine parent) { var associatedActions = new List <StateMachineOutputAction>(); /*Get a list of actions associated with the transition.*/ /*First, get the exit actions for this transitions source state.*/ var sourceState = parent.GetState(transition.SourceStateId); foreach (var actionItem in sourceState.ExitActions) { } /*Second, get the actions for this transition itself.*/ /*Finally, get the entry actions for this transitions' target state.*/ return(associatedActions); }
public TransitionEditorViewModel( StateMachineTransition model, StateMachineViewModel parent, Action <StateMachineTransition> updateParentModel, IMessageBoxService messageBoxService) { _model = model ?? throw new ArgumentNullException(nameof(model)); _updateParentModel = updateParentModel; _parent = parent ?? throw new ArgumentNullException(nameof(parent)); _messageBoxService = messageBoxService ?? throw new ArgumentNullException(nameof(messageBoxService)); Inputs = new ObservableCollection <StateMachineInputViewModel>(parent.Inputs); Outputs = new ObservableCollection <StateMachineOutputActionViewModel>(parent.Outputs); _transition = ApplicationContainer.Container.Resolve <TransitionViewModel>( new TypedParameter(typeof(StateMachineViewModel), parent), new TypedParameter(typeof(StateMachineTransition), model) ); Actions = new OrderedListDesigner <StateMachineOutputActionViewModel>(NewFactory, parent.Outputs.Where(o => _transition.Actions.Contains(o.Id))); _actions.ListChanged += ActionsOnListChanged; Name = Transition.Name; Criteria = new CriteriaTransitionViewModel(this, _messageBoxService); OkCommand = new RelayCommand(Ok); _dirtyService.MarkClean(); RecalculateConditionText(); Criteria.PropertyChanged += CriteriaPropertyChanged; if (Criteria.RootCondition != null) { Criteria.RootCondition.ConditionChanged += RootConditionChanged; } }
public Erros Event(string et, params object[] args) { if (this.transition != null) { return(new Erros("InTransitionError", 4)); } string dst = ""; if (this.transitions.TryGetValue(new eKey(et, this.current), out dst) == false) { foreach (var ekey in this.transitions) { if (ekey.Key.et == et) { return(new Erros("InvalidEventError", 0)); } } return(new Erros("UnknownEventError", 5)); } var e = new Event(); e.fsm = this; e.src = this.current; e.dst = dst; e.args = args; e.canceled = false; e.async = false; var err = this.BeforeEventCallbacks(e); if (err != null) { return(err); } if (this.current == dst) { this.AfterEventCallbacks(e); return(new Erros("NoTransitionError", 4)); } // Setup the transition, call it later. this.transition = new StateMachineTransition(); this.transition.current = this.current; this.transition.fsm = this; this.transition.e = e; err = this.LeaveStateCallbacks(e); if (err != null) { if (err.ec == 1) { this.transition = null; } return(err); } err = this.doTransition(); if (e != null) { return(new Erros("InternalError", 6)); } return(null); }
protected override StateMachineTransition <KnightStates> Transition(Entity entity, KnightStateMachineComponent stateMachine) { var input = entity.getComponent <PlayerInputComponent>(); var events = entity.getComponent <EventComponent>(); var playerState = entity.getComponent <PlayerStateComponent>(); var knightState = stateMachine.State; if (knightState.StateEnum != KnightStates.KO && knightState.StateEnum != KnightStates.Eliminated && playerState.IsKilled) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.KO)); } switch (knightState.StateEnum) { case KnightStates.Idle: if (input.AttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.Charge)); } else if (input.HeavyAttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.ChargeHeavy)); } else if (input.DashPressed && knightState.SprintRemaining >= KnightState.MIN_START_SPRINT) { return(StateMachineTransition <KnightStates> .Push(KnightStates.Dash)); } else if (input.MovementStick.LengthSquared() > PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.Walk)); } break; case KnightStates.Walk: if (input.AttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.Charge)); } else if (input.HeavyAttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.ChargeHeavy)); } else if (input.DashPressed && input.DashPressed && knightState.SprintRemaining >= KnightState.MIN_START_SPRINT) { return(StateMachineTransition <KnightStates> .Push(KnightStates.Dash)); } else if (input.MovementStick.LengthSquared() < PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.Idle)); } break; case KnightStates.Dash: if (!input.DashPressed || knightState.SprintRemaining <= 0.01) { return(StateMachineTransition <KnightStates> .Pop()); } else if (input.AttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.Charge)); } else if (input.HeavyAttackPressed) { return(StateMachineTransition <KnightStates> .Push(KnightStates.ChargeHeavy)); } else if (playerState.DashFinished) { return(StateMachineTransition <KnightStates> .Pop()); } break; case KnightStates.Charge: if (!input.AttackPressed) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.Swing)); } break; case KnightStates.Swing: playerState.SwingFinished = events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_SWING_END); if (playerState.SwingFinished) { return(StateMachineTransition <KnightStates> .Pop()); } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_START)) { playerState.HitActive = true; } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_END)) { playerState.HitActive = false; } break; case KnightStates.KO: if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.KO_END)) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.Eliminated)); } break; case KnightStates.Eliminated: if (!playerState.IsKilled) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.Idle)); } break; case KnightStates.ChargeHeavy: if (!input.HeavyAttackPressed) { return(StateMachineTransition <KnightStates> .Replace(KnightStates.SwingHeavy)); } break; case KnightStates.SwingHeavy: playerState.SwingFinished = events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_SWING_END); if (playerState.SwingFinished) { return(StateMachineTransition <KnightStates> .Pop()); } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_START)) { playerState.HitActive = true; } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_END)) { playerState.HitActive = false; } break; default: throw new ArgumentOutOfRangeException(); } return(StateMachineTransition <KnightStates> .None()); }
/// <inheritdoc /> public override void OnDestroy() { _transition = null; base.OnDestroy(); }
protected override StateMachineTransition <SpacemanStates> Transition(Entity entity, SpacemanStateMachineComponent stateMachine) { var input = entity.getComponent <PlayerInputComponent>(); var events = entity.getComponent <EventComponent>(); var playerState = entity.getComponent <PlayerStateComponent>(); var spacemanState = stateMachine.State; if (spacemanState.StateEnum != SpacemanStates.KO && spacemanState.StateEnum != SpacemanStates.Eliminated && playerState.IsKilled) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.KO)); } switch (spacemanState.StateEnum) { case SpacemanStates.Idle: if (input.AttackPressed) { return(StateMachineTransition <SpacemanStates> .Push(SpacemanStates.Attack)); } else if (input.HeavyAttackPressed && spacemanState.ShieldCooldown >= SpacemanState.SHIELD_COOLDOWN) { return(StateMachineTransition <SpacemanStates> .Push(SpacemanStates.Shield)); } else if (input.MovementStick.LengthSquared() > PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.Walk)); } break; case SpacemanStates.Walk: if (input.AttackPressed) { return(StateMachineTransition <SpacemanStates> .Push(SpacemanStates.Attack)); } else if (input.HeavyAttackPressed && spacemanState.ShieldCooldown >= SpacemanState.SHIELD_COOLDOWN) { return(StateMachineTransition <SpacemanStates> .Push(SpacemanStates.Shield)); } else if (input.MovementStick.LengthSquared() < PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.Idle)); } break; case SpacemanStates.Attack: playerState.SwingFinished = events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_SWING_END); if (playerState.SwingFinished) { return(StateMachineTransition <SpacemanStates> .Pop()); } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_START)) { playerState.HitActive = true; } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_END)) { playerState.HitActive = false; } break; case SpacemanStates.KO: if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.KO_END) || Time.time - spacemanState.KoTime > SpacemanState.KO_ANIM_PLACEHOLDER_LENGTH) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.Eliminated)); } break; case SpacemanStates.Eliminated: if (!playerState.IsKilled) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.Idle)); } break; case SpacemanStates.Shield: if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.BLOCK_END)) { return(StateMachineTransition <SpacemanStates> .Replace(SpacemanStates.Idle)); } break; default: throw new ArgumentOutOfRangeException(); } return(StateMachineTransition <SpacemanStates> .None()); }
protected override StateMachineTransition <WizardStates> Transition(Entity entity, WizardStateMachineComponent stateMachine) { var input = entity.getComponent <PlayerInputComponent>(); var events = entity.getComponent <EventComponent>(); var wizardState = stateMachine.State; var playerState = entity.getComponent <PlayerStateComponent>(); if (wizardState.StateEnum != WizardStates.KO && wizardState.StateEnum != WizardStates.Eliminated && playerState.IsKilled) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.KO)); } switch (wizardState.StateEnum) { case WizardStates.Idle: if (input.AttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Charge)); } else if (input.HeavyAttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.ChargeHeavy)); } else if (input.DashPressed && wizardState.GlideCooldown >= WizardState.GLIDE_COOLDOWN) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.PreGlide)); } else if (input.MovementStick.LengthSquared() > PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Walk)); } break; case WizardStates.Walk: if (input.AttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Charge)); } else if (input.HeavyAttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.ChargeHeavy)); } else if (input.DashPressed && wizardState.GlideCooldown >= WizardState.GLIDE_COOLDOWN) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.PreGlide)); } else if (input.MovementStick.LengthSquared() < PlayerStateComponent.DEAD_ZONE) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Idle)); } break; case WizardStates.Charge: if (!input.AttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Attack)); } break; case WizardStates.ChargeHeavy: if (!input.HeavyAttackPressed) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.AttackHeavy)); } break; case WizardStates.AttackHeavy: case WizardStates.Attack: playerState.SwingFinished = events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_SWING_END); if (playerState.SwingFinished) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Idle)); } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_START)) { playerState.HitActive = true; } if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.PLAYER_HIT_END)) { playerState.HitActive = false; } break; case WizardStates.PreGlide: if (wizardState.GlideTime >= WizardState.GLIDE_DELAY) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Glide)); } break; case WizardStates.Glide: if (input.AttackPressed) { wizardState.GlideTime = 10000; // kill the glide so it pops back to glide -> instantly to ilde return(StateMachineTransition <WizardStates> .Replace(WizardStates.Charge)); } else if (input.HeavyAttackPressed) { wizardState.LastGlideTime = wizardState.GlideTime; return(StateMachineTransition <WizardStates> .Replace(WizardStates.ChargeHeavy)); } else if (wizardState.GlideTime >= WizardState.MAX_GLIDE_TIME) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Idle)); } break; case WizardStates.KO: if (events.ConsumeEventAndReturnIfPresent(PlayerEvents.KO_END)) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Eliminated)); } break; case WizardStates.Eliminated: if (!playerState.IsKilled) { return(StateMachineTransition <WizardStates> .Replace(WizardStates.Idle)); } break; default: throw new ArgumentOutOfRangeException(); } return(StateMachineTransition <WizardStates> .None()); }
private void CreateTransitions() { anyStateTransitions.Clear(); preStateTransitions.Clear(); m_globalKeys.Clear(); var groups = new List <TransitionInfo>(); var g = ConfigManager.Get <TransitionInfo>(transtionGroupId); if (g) { groups.Add(g); } foreach (var sub in subStateMachines) { g = ConfigManager.Get <TransitionInfo>(sub.transitionGroup); if (g) { groups.Add(g); } } foreach (var group in groups) { var pre = group.GetTransitions(-1); foreach (var tran in pre) { var t = StateMachineTransition.Create(this, tran); if (!t) { continue; } preStateTransitions.Add(t); if (t.info.acceptKeyMask == 0) { continue; } if (t.info.acceptGroupMask == 0) { var nk = m_globalKeys.Get(0); m_globalKeys.Set(0, nk | t.info.acceptKeyMask); } else { var gm = t.info.acceptGroupMask; for (var i = 1; i < 64; ++i) { if (!gm.BitMask(i)) { continue; } var nk = m_globalKeys.Get(i); m_globalKeys.Set(i, nk | t.info.acceptKeyMask); } } } var any = group.GetTransitions(0); foreach (var tran in any) { var t = StateMachineTransition.Create(this, tran); if (!t) { continue; } anyStateTransitions.Add(t); if (t.info.acceptKeyMask == 0) { continue; } if (t.info.acceptGroupMask == 0) { var nk = m_globalKeys.Get(0); m_globalKeys.Set(0, nk | t.info.acceptKeyMask); nk = m_globalKeys.Get(0); } else { var gm = t.info.acceptGroupMask; for (var i = 1; i < 64; ++i) { if (!gm.BitMask(i)) { continue; } var nk = m_globalKeys.Get(i); m_globalKeys.Set(i, nk | t.info.acceptKeyMask); } } } } foreach (var state in states) { state.UpdateTransitions(groups); } }
private int CheckTransition(StateMachineTransition trans) { var r = trans.Check(currentState); if (r.Low8() != 0) { return(r); } #region Debug log #if (DEVELOPMENT_BUILD || UNITY_EDITOR) && DETAIL_BATTLE_LOG if (creature.isCombat) { var ps = ""; foreach (var pair in m_cachedParams) { ps += pair.Key + ": " + GetDouble(pair.Value) + "\n"; } Logger.LogWarning("[{3}:{4}-{5}], [{6}:{7}] Enter state {0} from {1}, type:{8}, trans:\n{2}", trans.target.name, currentState.name, trans.info.ToXml(), Level.levelTime, creature.frameTime, creature.frameCount, creature.id, creature.name, 0); Logger.LogWarning("Params: {0}", ps); } #endif #if AI_LOG //if (creature.isCombat) //{ // var dps = ""; // foreach (var pair in m_cachedParams) // dps += pair.Key + ": " + GetDouble(pair.Value) + "\n"; // Module_AI.LogBattleMsg(creature,true, "[Enter state {0} from {1}, type:{3}, trans:\n{2}", trans.target.name, currentState.name, trans.info.ToXml(), 0); // Module_AI.LogBattleMsg(creature, "[Params: {0}]", dps); //} #endif #endregion if (trans.rageCost > 0) { creature.rage -= trans.rageCost; } if (trans.rageRateCost > 0) { creature.rage -= creature.maxRage * trans.rageRateCost; } if (trans.energyCost > 0) { creature.energy -= trans.energyCost; } if (trans.energyRateCost > 0) { creature.energy -= (int)(creature.maxEnergy * trans.energyRateCost); } if (trans.forceTurn) { trans.target.preventNextTurn = true; creature.TurnBack(); } TranslateTo(trans.target, 0, false, trans.blendTime); trans.target.preventNextTurn = false; if (trans.info.preventInputReset) { m_forceTransitionUpdate = true; } return(r); }