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);
}
