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