// Update is called once per frame void Update() { if (playerStateHandler.current != null) { if (playerStateHandler.current.GetType().Equals(nonCorporeal.GetType()) && !(this.gameObject.layer == LayerMask.NameToLayer("Transparent")) && CanSeePlayer()) { //Debug.Log("baboi"); Renderer.material = material; this.gameObject.layer = LayerMask.NameToLayer("Transparent"); player.layer = LayerMask.NameToLayer("PlayerNonCorporeal"); } else if (!(playerStateHandler.current.GetType().Equals(nonCorporeal.GetType())) && this.gameObject.layer == LayerMask.NameToLayer("Transparent") || !CanSeePlayer()) { if (PlayerInWall) { player.transform.position = EnterPoint; PlayerInWall = false; } Renderer.material = originalMaterial; this.gameObject.layer = LayerMask.NameToLayer("Geometry"); player.layer = LayerMask.NameToLayer("PlayerCorporeal"); } } }
/// <summary> /// Switch the currentstate to a specific new State. /// </summary> /// <param name="newState"> /// The state object to set as the currentState</param> /// <returns></returns> protected virtual State SetState(State newState) { if (newState && newState != currentState) { lastState = currentState; currentState = newState; if (lastState) { lastState.StateExit(); } currentState.StateEnter(); if (enableDebug) { try { Debug.Log($"{lastState.GetType()} to {currentState.GetType()}"); } catch (NullReferenceException) { Debug.Log($"{currentState.GetType()}"); } } return(currentState); } return(null); }
private void OnEnable(){ if (!(target is State)) { return; } state = (State)target; stateList = new ReorderableList (state.GetType().ToString().Split('.').Last()); stateFields = state.GetType () .GetFields (BindingFlags.Public | BindingFlags.Instance) .Where (x => x.DeclaringType.IsSubclassOf (typeof(State))) .ToArray(); object[] attributes=state.GetType().GetCustomAttributes(true); bool isTrigger=false; foreach(object attribute in attributes){ if(attribute is TriggerAttribute){ isTrigger=true; } } if (!isTrigger) { actionList = new ReorderableList (state.actions, "Actions", true); actionList.onAddCallback = AddAction; actionList.onRemoveCallback = RemoveAction; actionList.drawElementCallback = DrawActionElement; actionList.onHeaderClick = OnActionHeaderClick; } transitionList = new ReorderableList (state.transitions, "Transitions", true,false,false); transitionList.onRemoveCallback = RemoveTransition; transitionList.drawElementCallback = DrawTransitionElement; transitionList.onSelectCallback = TransitionSelected; }
public bool IsInState(State <T> s) { if (m_CurrentState.GetType() == s.GetType()) { return(true); } return(false); }
public bool IsInState(State <EntityType> st) { if (st.GetType() == _curstate.GetType()) { return(true); } return(false); }
//Function to handle statemachine public void ChangeState( State<EnemySniperScript> s ) { if(s.GetType().Name == "Sniper_AttackPlayer"){ CurrentState = StateID.attacking; } if(s.GetType().Name == "Sniper_MoveToPlayer"){ CurrentState = StateID.moving; } StateMachine.ChangeState ( s ); }
public void AddTransition(State from, State to, Func <bool> predicate) { if (transitions.TryGetValue(from.GetType(), out var t) == false) { t = new List <Transition>(); transitions[from.GetType()] = t; } t.Add(new Transition(to, predicate)); }
/// <summary> /// Llama al execute del estado actual. /// </summary> public void Update() { if (_currentState != null) { if (SearchState(_currentState.GetType()) >= 0) { _currentState.Execute(); } } }
public void OnStateChanged(State newState) { if (newState.GetType() == typeof(ActionMachineState)) { Action(); } else if (newState.GetType() == typeof(AwaitMachineState)) { ActionDone(); } }
protected virtual void SwitchState(State newState) //cambia de un estado a otro { if (_currentState != null && _currentState.GetType() == newState.GetType()) { return; } _currentState?.ExitState(); _currentState = newState; _currentState.InitState(); _updateState = _currentState.UpdateState; }
public void OnClick() { State currentState = gameController.GetCurrentState(); if (currentState.GetType().Equals(typeof(IdleState))) { Select(); } if (currentState.GetType().Equals(typeof(SelectState))) { Swap(); } }
public void PayInterest() { State.PayInterest(); Console.WriteLine("Interest Paid --- "); Console.WriteLine(" Balance = {0:C}", Balance); Console.WriteLine(" Status = {0}\n", State.GetType().Name); }
public void Deposit(decimal amount) { State.Deposit(amount); Console.WriteLine("Deposited {0:C} --- ", amount); Console.WriteLine(" Balance = {0:C}", Balance); Console.WriteLine(" Status = {0}\n", State.GetType().Name); }
public void Register(State state) { if (state != null) { states[state.GetType()] = state; } }
public StateMachine(State <T> initialState) { initialState.SetMachine(this); states.Add(initialState.GetType(), initialState); currentState = initialState; initialState.EnterState(); }
protected virtual void Transition(State value) { if (_currentState == value || _inTransition) { if (_inTransition) { Debug.LogWarning("~StateMachineNet is in transition: " + _currentState.GetType().Name); } return; } _inTransition = true; if (_currentState != null) { _currentState.Exit(); } _currentState = value; _inTransition = false; if (_currentState != null) { _currentState.Enter(); } }
public void LoadHitObjects() { if (Timer.Ticks < Duration.TotalMilliseconds && Timer.IsStarted == true) { foreach (HitObject o in Level.Beatmap.HitObjects) { if (Timer.Ticks == o.StartTime - (Level.Beatmap.DifficultyApproachRate * Speed[0])) { int index = HitObjects.FindIndex(f => f.X == o.StartPosition.X); if (index == -1) { TotalHits++; HitObjects.Add(new Cube(DefaultColor, o.StartPosition.X, -50, Size, Size, false, false)); Random gen = new Random(); if (gen.Next(100) < 40) { HitObjects.Add(new Cube(DefaultColor, o.StartPosition.X + 10, -150, 20, 20, false, true)); } } } } } else if (Timer.Ticks > Duration.TotalMilliseconds && State.GetType() != typeof(GameEnded)) { Timer.Stop(); SplashKit.StopMusic(); SetState(new GameEnded()); } }
CallTreeNode GetStateNode(State st, Stack <object> stack) { if (!stack.Contains(st)) { stack.Push(st); var rootNode = new CallTreeNode(st, CallTreeNodeType.State, st.gameObject.name); var type = st.GetType(); foreach (var field in type.GetFields()) { // Find Fields that are Callable[] if (field.FieldType.IsAssignableFrom(typeof(Callable[]))) { var node = new CallTreeNode(st, CallTreeNodeType.Callable, field.Name); rootNode.Children.Add(node); // Add Callables from this Callable[] array var value = (Callable[])field.GetValue(st); foreach (var call in value) { node.Children.Add(GetNode(call, stack)); } } } return(rootNode); } else { return(new CallTreeNode(st, GetType(st), $"RECURSED :{st.gameObject.name}")); } }
void SwitchState(State state) { _state?.OnExit(); _state = state; _state.OnEnter(); StateName = _state.GetType().Name; }
public void Withdraw(double amount) { State.Withdraw(amount); Console.WriteLine("Withdrew {0}$ --- ", amount); Console.WriteLine(" Balance = {0}$", Balance); Console.WriteLine(" Status = {0}\n", State.GetType().Name); }
private void SetupStates() { List <State> states = new List <State>(currentTarget.GetComponents <State>()); states.RemoveAt(states.FindIndex(s => s.GetType().Name == currentTarget.GetType().Name)); foreach (State state in states) { displayNames.Add(state.GetType().Name); statePaths.Add(state.GetType().FullName); } // Setup the transition mask value from the stored transitions transitions = Reflection.GetPrivateFieldValue <List <State> >(currentTarget, "transitions"); if (transitions != null) { for (int i = 0; i < transitions.Count; i++) { try { transitionMask |= (1 << (displayNames.FindIndex(s => s == transitions[i].GetType().Name))); } catch (Exception exception) { Debug.LogError(string.Format("State {0} is allowed a transition that no longer exists with error: {1}", currentTarget.name, exception)); } } SetTransitions(transitionMask); } }
public void SetState(int stateId) { if (stateId < 0 || stateId >= states.Length) { Debug.LogError("[StateManager.SetStates] stateId: " + stateId + " out of array index"); return; } if (states[stateId] == null) { Debug.LogError("[StateManager.SetStates] the new state is null"); return; } if (curState != null) { Debug.Log(curState.GetType().ToString() + " Exit"); nextStateId = stateId; curState.StateExit(); } lastStateId = GetCurStateId(); curState = states[stateId]; Debug.Log(curState.GetType().ToString() + " Enter"); nextStateId = -1; curState.StateEnter(); }
public void Deposit(double amount) { State.Deposit(amount); Console.WriteLine("Deposited {0}$ --- ", amount); Console.WriteLine(" Balance = {0}$", Balance); Console.WriteLine(" Status = {0}", State.GetType().Name + "\n"); }
public override void Update() { if (State.GetType() == typeof(StompedGoombaState)) { if (stompTimer == stompTimerBound) { World.Instance.RemoveFromWorld(Uid); return; } else { stompTimer++; } } Sprite.Update(); // This can be reworked by adding this CONSTANT ACCEL functionality into Physics. if (State.GetType() == typeof(LeftMovingGoombaState)) { GameObjectPhysics.Move(Side.Left); } else if (State.GetType() == typeof(RightMovingGoombaState)) { GameObjectPhysics.Move(Side.Right); } GameObjectPhysics.Update(); positionOnScreen = GameObjectPhysics.GetPosition(); }
private State triggerCurrentStateEvent(Event triggerEvent) { Type eListenerType = typeof(EventListenerAttribute); Type eStateType = typeof(State); foreach (System.Reflection.MethodInfo m in currentState.GetType().GetMethods()) { if (m.GetCustomAttributes(eListenerType, false).Length > 0) { System.Reflection.ParameterInfo[] parameters = m.GetParameters(); if (parameters.Length == 1) { System.Reflection.ParameterInfo info = m.GetParameters()[0]; if (info.ParameterType == triggerEvent.GetType()) { if (m.ReturnType == eStateType) { return((State)m.Invoke(currentState, new object[] { triggerEvent })); } else { m.Invoke(currentState, new object[] { triggerEvent }); return(null); } } } } } return(null); }
public void ChangeState <R>() where R : State <T> { var newType = typeof(R); if (_currentState.GetType() == newType) { return; } if (_currentState != null) { _currentState.OnExit(); } #if UNITY_EDITOR if (!_states.ContainsKey(newType)) { var error = newType + ": state does not exist."; throw new System.Exception(error); } #endif _previousState = _currentState; _currentState = _states[newType]; _currentState.OnStart(); _elapsedTime = 0.0f; }
/// <summary> /// Agrega un estado. /// </summary> /// <param name="s">El estado a agregar.</param> public void AddState(State s) { if (SearchState(s.GetType()) < 0) { _states.Add(s); } }
private void EnterState(State aState, object[] aArgs) { #if DEBUG string stateName = aState.ToString(); bool haveArgs = aArgs != null; MethodInfo mi = aState.GetType().GetMethod("OnEnter", BindingFlags.Instance | BindingFlags.Public | BindingFlags.DeclaredOnly); if (mi != null) // OnEnter overridden on state { bool expectsArgs = mi.GetParameters().Length > 0; if (!haveArgs && expectsArgs) { Debug.Fail($"State {stateName} expects args, but none were passed in via Transition"); } else if (haveArgs && !expectsArgs) { Debug.Fail($"State {stateName} does not expect args, but some were passed in via Transition"); } } else if (haveArgs) { Debug.Fail($"Args are being passed via Transition to State {stateName}, but State doesn't implement OnEnter(params)"); } #endif if (aArgs != null) { aState.OnEnter(aArgs); } else { aState.OnEnter(); } }
/// <summary> /// Sets state /// </summary> /// <param name="newState"></param> void SetState ( State newState ) { this.state = newState; Log.Message("CL: State: {0}", newState.GetType().Name ); ClientStateChanged( this, new ClientEventArgs(){ ClientState = newState.ClientState, Message = newState.Message } ); }
public override void CollideUp(Rectangle collisionArea) { if (State.GetType() != typeof(ShroomMovingUpState)) { base.CollideUp(collisionArea); } }
public static void AddStateOnce(PedHandle ped, State state) { if (!StateMachines.HasState(ped, state.GetType())) { StateMachines.Add(ped, new State.Machine(state)); } }
public StateContainer() { // 新狀態要來這邊註冊 notLoggedinState = new NotLoggedinState(this); galaxyState = new GalaxyState(this); commanderState = new CommanderState(this); missionState = new MissionState(this); planetaryState = new PlanetaryState(this); planetMenuState = new PlanetMenuState(this); planetState = new PlanetState(this); resourceBuildingState = new ResourceBuildingState(this); stateMap = new Dictionary <string, State>(); stateMap.Add(notLoggedinState.GetType().Name, notLoggedinState); stateMap.Add(galaxyState.GetType().Name, galaxyState); stateMap.Add(commanderState.GetType().Name, commanderState); stateMap.Add(missionState.GetType().Name, missionState); stateMap.Add(planetaryState.GetType().Name, planetaryState); stateMap.Add(planetMenuState.GetType().Name, planetMenuState); stateMap.Add(planetState.GetType().Name, planetState); stateMap.Add(resourceBuildingState.GetType().Name, resourceBuildingState); mainState = notLoggedinState; tasks = new Queue <Command>(); ExtentMin = new Point(0, 0); ExtentMax = new Point(790, 660); OnInvoke = false; }
public void Update(float deltaTime) { if (CanChangeState == true) { int tranFunCount = m_AllTransitionFuns.Count; StateImpl newStateImpl = null; for (int i = 0; i < tranFunCount; i++) { State newState = ((m_AllTransitionFuns[i] as TransitionFun)(m_CurrState)); if (newState != null) { if (newState.GetType() == typeof(StateImpl)) { newStateImpl = (StateImpl)newState; break; } } } if (newStateImpl != null && m_CurrState != newStateImpl) { SetState(newStateImpl); } } if (m_CurrState != null) { m_CurrState.UpdateState(m_CurrState, deltaTime); } }
public void SwitchState(State changeTo) { //Destroy the Current State if(activeState!= null) activeState.Destroy(); //Setup new State activeState = changeTo; Debugger.Debug_Log("Initializing State-" + changeTo.GetType().Name); activeState.Init(_game, playerController); }
protected void Become(State nextState) { if (mainWindow.state != null) { mainWindow.state.Dispose(); } mainWindow.state = nextState; if (nextState != null) logger.Trace("State changed from {0} to {1}", GetType().Name, nextState.GetType().Name); else logger.Trace("State stoped from {0}", GetType().Name); }
public override IEnumerator Run(Brain controller) { if(!triggersBuilt) { foreach(TriggerManager manager in controlledTriggers) { manager.BuildTrigger(controller); } triggersBuilt = true; } yield return StartCoroutine(currentState.Run(controller)); foreach(TriggerManager manager in currentState.GetTriggers()) { if(manager.ShouldTrigger()) { nextState = manager.target; Debug.Log("Triggered Transition: " + nextState.GetType().Name); } } if(nextState != null) { yield return StartCoroutine(currentState.Exit()); currentState = nextState; nextState = null; yield return StartCoroutine(currentState.Enter(this, controller)); } }
// Schedules a state transition at the next available time public void RequestStateTransition(State goToThis) { nextState = goToThis; Debug.Log("State Transition: " + nextState.GetType().Name); }
/// <summary> /// Handles the received data /// </summary> private void Handle(int bytesReceived, Socket socket, State state) { int bytesRead = 0; int payloadLength, bytesAvailable, bytesNeeded; while (bytesRead < bytesReceived) { bytesAvailable = bytesReceived - bytesRead; if (bytesReceived > 0) { if (state.packet.Length >= 7) { payloadLength = BitConverter.ToInt32(new byte[1].Concat(state.packet.Skip(2).Take(3)).Reverse().ToArray(), 0); bytesNeeded = payloadLength - (state.packet.Length - 7); if (bytesAvailable >= bytesNeeded) { state.packet = state.packet.Concat(state.buffer.Skip(bytesRead).Take(bytesNeeded)).ToArray(); bytesRead += bytesNeeded; bytesAvailable -= bytesNeeded; if (state.GetType() == typeof(ClientState)) { Packet clientPacket = new Packet(state.packet, DataDestination.DATA_FROM_CLIENT); Logger.LogPacket(clientPacket); ServerSocket.Send(clientPacket.Raw); } else if (state.GetType() == typeof(ServerState)) { Packet serverPacket = new Packet(state.packet, DataDestination.DATA_FROM_SERVER); Logger.LogPacket(serverPacket); ClientSocket.Send(serverPacket.Raw); } state.packet = new byte[0]; } else { state.packet = state.packet.Concat(state.buffer.Skip(bytesRead).Take(bytesAvailable)).ToArray(); bytesRead = bytesReceived; bytesAvailable = 0; } } else if (bytesAvailable >= 7) { state.packet = state.packet.Concat(state.buffer.Skip(bytesRead).Take(7)).ToArray(); bytesRead += 7; bytesAvailable -= 7; } else { state.packet = state.packet.Concat(state.buffer.Skip(bytesRead).Take(bytesAvailable)).ToArray(); bytesRead = bytesReceived; bytesAvailable = 0; } } } }
private void DrawNode (State node) { bool isTrigger=false; object[] attributes=node.GetType().GetCustomAttributes(true); foreach(object attribute in attributes){ if(attribute is TriggerAttribute){ isTrigger=true; } } UnityEditor.Graphs.Styles.Color color = node.isDefaultState ? UnityEditor.Graphs.Styles.Color.Orange : node.GetType () == typeof(AnyState) ? UnityEditor.Graphs.Styles.Color.Aqua : UnityEditor.Graphs.Styles.Color.Gray; if (isTrigger) { color=UnityEditor.Graphs.Styles.Color.Green; } GUI.Box (node.position, node.name, UnityEditor.Graphs.Styles.GetNodeStyle ("node", color, node == selectedState)); DebugState (node); HandleNodeEvents (node); }
private void HandleNodeEvents (State node) { Event ev = Event.current; switch (ev.type) { case EventType.mouseDown: if (node.position.Contains (ev.mousePosition) && Event.current.button == 0) { isDraggingState = true; } if (node.position.Contains (ev.mousePosition) && Event.current.button == 1) { GenericMenu genericMenu = new GenericMenu (); genericMenu.AddItem (new GUIContent ("Make Transition"), false, new GenericMenu.MenuFunction2 (this.MakeTransitionCallback), node); if (!((State)node).isDefaultState && node.GetType() != typeof(AnyState) && !(node is BaseTrigger)) { genericMenu.AddItem (new GUIContent ("Set As Default"), false, new GenericMenu.MenuFunction2 (this.SetDefaultCallback), node); } else { genericMenu.AddDisabledItem (new GUIContent ("Set As Default")); } if(node.GetType() == typeof(AnyState)){ genericMenu.AddDisabledItem (new GUIContent ("Delete")); }else{ genericMenu.AddItem (new GUIContent ("Delete"), false, new GenericMenu.MenuFunction2 (this.DeleteStateCallback), node); } if(node.GetType() == typeof(AnyState)){ genericMenu.AddDisabledItem (new GUIContent ("Copy")); }else{ genericMenu.AddItem (new GUIContent ("Copy"), false, new GenericMenu.MenuFunction2 (this.CopyState), node); } if(copyOfState!= null && node.GetType() != typeof(AnyState) && copyOfState.id != node.id){ genericMenu.AddItem (new GUIContent ("Paste"), false, new GenericMenu.MenuFunction2 (this.PasteState), node); }else{ genericMenu.AddDisabledItem (new GUIContent ("Paste")); } genericMenu.ShowAsContext (); ev.Use (); } break; case EventType.mouseUp: isDraggingState = false; Selection.activeObject=node; break; case EventType.mouseDrag: if (isDraggingState) { selectedState.position.x += Event.current.delta.x; selectedState.position.y += Event.current.delta.y; if (selectedState.position.y < 10) { selectedState.position.y = 10; } if (selectedState.position.x < 10) { selectedState.position.x = 10; } ev.Use (); } break; } if (node.position.Contains (ev.mousePosition) && (ev.type != EventType.MouseDown || ev.button != 0 ? false : ev.clickCount == 1)) { if (selectedState != node) { OnStateSelectionChanged (node); } } }
void ShowStates() { for (int i = 0; i < statesProperty.arraySize; i++) { currentStateProperty = statesProperty.GetArrayElementAtIndex(i); currentState = currentStateProperty.GetValue<State>(); if (currentState == null) { DeleteFromArray(statesProperty, i); break; } BeginBox(); Foldout(currentStateProperty, FormatStateType(currentState.GetType(), currentLayer).ToGUIContent(), GetStateStyle()); Reorderable(statesProperty, i, true); ShowState(); EndBox(); } }
public static Type GetLayerTypeFromState(State state) { return GetLayerTypeFromState(state.GetType()); }