public void Should_Not_Start_When_Door_Is_Open()
        {
            // Arrange
            var microwaveData = new MicrowaveData
            {
                IsOpen         = false,
                Time           = 0,
                IsStartClicked = true
            };
            var timesCalled = 0;

            _stateEngineWrapperMock.Setup(m => m.ShowMessage(It.IsAny <object>(), It.IsAny <string>()))
            .Callback <object, string>((sender, args) =>
            {
                if (args == _messages[EventMessages.Should_Not_Start_When_Door_Is_Open])
                {
                    timesCalled++;
                }
            });

            StateEngine.ShowMessage += _stateEngineWrapperMock.Object.ShowMessage;

            // Act
            StateEngine.MicrowaveEngine(microwaveData);

            // Assert
            Assert.Equal(1, timesCalled);
        }
        public void Should_Handle_IsOpen_Correctly()
        {
            // Arrange
            var timesCalled = 0;

            _stateEngineWrapperMock.Setup(m => m.ShowMessage(It.IsAny <object>(), It.IsAny <string>()))
            .Callback <object, string>((sender, args) =>
            {
                if (args == _messages[EventMessages.Should_Handle_Door_Open])
                {
                    timesCalled++;
                }
            });
            _stateEngineWrapperMock.Setup(m => m.OpenDoor(It.IsAny <object>(), It.IsAny <object>()))
            .Callback <object, object>((sender, args) => { timesCalled++; });

            var microwaveData = new MicrowaveData
            {
                IsOpen = true
            };

            StateEngine.OpenDoor    += _stateEngineWrapperMock.Object.OpenDoor;
            StateEngine.ShowMessage += _stateEngineWrapperMock.Object.ShowMessage;

            // Act
            StateEngine.MicrowaveEngine(microwaveData);

            // Assert
            Assert.Equal(2, timesCalled);
        }
示例#3
0
        private static void Main(string[] args)
        {
            //Make exceptions be english (wtf microsoft???)
            System.Threading.Thread.CurrentThread.CurrentUICulture = CultureInfo.InvariantCulture;

            Window = new GameWindow(1280, 720, GraphicsMode.Default, "MinecraftClone3")
            {
                CursorVisible         = false,
                TargetUpdateFrequency = 120,
                VSync = VSyncMode.On
            };
            Window.Closed         += WindowOnClosed;
            Window.Resize         += WindowOnResize;
            Window.FocusedChanged += WindowOnFocusedChanged;
            Window.UpdateFrame    += WindowOnUpdateFrame;
            Window.RenderFrame    += WindowOnRenderFrame;

            StateEngine.AddState(new GuiResourceLoading(Window));

            Window.Run();

            /*
             * PlayerController.SetEntity(_playerEntity);
             *
             * _world = new WorldServer();
             * _world.PlayerEntities.Add(_playerEntity);
             *
             * _projection = Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(60), (float)Window.Width/Window.Height, 0.01f, 512);
             */
        }
        public void Should_Handle_Closed_Door_Higher_Time_Than_0()
        {
            // Arrange
            var microwaveData = new MicrowaveData
            {
                IsOpen = false,
                Time   = 1337
            };
            var timesCalled = 0;

            _stateEngineWrapperMock.Setup(m => m.SetReady(It.IsAny <object>(), It.IsAny <object>()))
            .Callback <object, object>((sender, args) => { timesCalled++; });
            _stateEngineWrapperMock.Setup(m => m.SetLightReady(It.IsAny <object>(), It.IsAny <object>()))
            .Callback <object, object>((sender, args) => { timesCalled++; });

            StateEngine.SetReady      += _stateEngineWrapperMock.Object.SetReady;
            StateEngine.SetLightReady += _stateEngineWrapperMock.Object.SetLightReady;

            // Act
            StateEngine.MicrowaveEngine(microwaveData);

            // Assert
            Assert.Equal(2, timesCalled);
            Assert.Equal(StateEngine.State.Ready, StateEngine.CurrentState);
        }
示例#5
0
    public void Init()
    {
        go        = CreateGameObject("stateTest");
        behaviour = go.AddComponent <ClassWithBasicStates>();
        engine    = go.GetComponent <StateEngine>();

        behaviour.Init();
    }
	public void Init()
	{
		go = CreateGameObject("stateTest");
		behaviour = go.AddComponent<ClassWithBasicStates>();
		engine = go.GetComponent<StateEngine>();

		behaviour.Init();
	}
示例#7
0
        //Thread thred;

        /// <summary>
        /// Standard Constructor
        /// </summary>
        /// <param name="ctx">context</param>
        /// <param name="AD_WF_Process_ID">process id</param>
        /// <param name="trxName">transaction</param>
        public MWFProcess(Ctx ctx, int AD_WF_Process_ID, Trx trxName)
            : base(ctx, AD_WF_Process_ID, trxName)
        {
            if (AD_WF_Process_ID == 0)
            {
                throw new ArgumentException("Cannot create new WF Process directly");
            }
            _state = new StateEngine(GetWFState());
        }
示例#8
0
 private void runStateEngine(object parameter)
 {
     if (Matrix != null)
     {
         StateEngine sEngine = new StateEngine(Matrix);
         sEngine.Analyze();
         Workspace.Workspace.Instance.NotifyColleagues <object>("matrix", null);
     }
 }
示例#9
0
        private static void WindowOnUpdateFrame(object sender, FrameEventArgs frameEventArgs)
        {
            StateEngine.Update();

            /*
             * PlayerController.Update(Window, _world);
             *
             * _world.Update();*/
        }
示例#10
0
        /// <summary>
        /// Initializes a new instance of the <see cref="NavTask"/> class.
        /// </summary>
        /// <param name="Character">The character.</param>
        public NavTask(Character Character)
            : base(Character)
        {
            Options     = XmlSerializationHelper.Deserialize <Options>(FileName) ?? new Options();
            TS          = new Taskstate(Character, Options);
            TS.Stopped += Stop;
            Engine      = new StateEngine();

            InitializeStateEngine();
        }
示例#11
0
 public PlayerWebsocket(IWebSocketConnection socket)
 {
     this.socket          = socket;
     this.isAuthenticated = Security.authenticateRequest(socket);
     if (isAuthenticated)
     {
         this.token    = socket.ConnectionInfo.Cookies["token"];
         this.playerID = StateEngine.GetState().GetPlayer(token).Id;
     }
 }
示例#12
0
        /// <summary>
        /// New Constructor
        /// </summary>
        /// <param name="wf">workflow</param>
        /// <param name="pi">Process Info (Record_ID)</param>
        public MWFProcess(MWorkflow wf, ProcessInfo pi)
            : base(wf.GetCtx(), 0, wf.Get_TrxName())
        {
            if (!Utility.TimeUtil.IsValid(wf.GetValidFrom(), wf.GetValidTo())) // make this class or this function
            {
                //throw new IllegalStateException("Workflow not valid");
                throw new Exception("Workflow not valid");
            }
            _wf = wf;
            _pi = pi;
            SetAD_Client_ID(wf.GetAD_Client_ID());
            SetAD_Workflow_ID(wf.GetAD_Workflow_ID());
            SetPriority(wf.GetPriority());
            base.SetWFState(WFSTATE_NotStarted);

            // vinay bhatt for window id
            SetAD_Window_ID(pi.GetAD_Window_ID());
            //

            //	Document
            SetAD_Table_ID(wf.GetAD_Table_ID());
            SetRecord_ID(pi.GetRecord_ID());
            if (GetPO() == null)
            {
                SetTextMsg("No PO with ID=" + pi.GetRecord_ID());
                base.SetWFState(WFSTATE_Terminated);
            }
            else
            {
                SetTextMsg(GetPO());
            }
            //	Responsible/User
            if (wf.GetAD_WF_Responsible_ID() == 0)
            {
                SetAD_WF_Responsible_ID();
            }
            else
            {
                SetAD_WF_Responsible_ID(wf.GetAD_WF_Responsible_ID());
            }
            SetUser_ID((int)pi.GetAD_User_ID());                //	user starting
            //
            _state = new StateEngine(GetWFState());
            _state.SetCtx(GetCtx());
            SetProcessed(false);
            //	Lock Entity
            GetPO();
            if (_po != null)
            {
                // Set transaction organization on workflow process
                SetAD_Org_ID(_po.GetAD_Org_ID());
                _po.Lock();
            }
        }
示例#13
0
 /// <summary>
 /// Set Process State and update Actions
 /// </summary>
 /// <param name="WFState">WFState</param>
 public new void   SetWFState(String WFState)
 {
     if (_state == null)
     {
         _state = new StateEngine(GetWFState());
         _state.SetCtx(GetCtx());
     }
     if (_state.IsClosed())
     {
         return;
     }
     if (GetWFState().Equals(WFState))
     {
         return;
     }
     //
     if (_state.IsValidNewState(WFState))
     {
         log.Fine(ToString() + " => " + WFState);
         base.SetWFState(WFState);
         _state = new StateEngine(GetWFState());
         _state.SetCtx(GetCtx());
         if (_state.IsClosed() || _state.IsBackground())
         {
             SetProcessed(true);
         }
         Save();
         //	Force close to all Activities
         if (_state.IsClosed() || _state.IsBackground())
         {
             MWFActivity[] activities = GetActivities(true, true);       //	requery only active
             for (int i = 0; i < activities.Length; i++)
             {
                 if (!activities[i].IsClosed())
                 {
                     activities[i].SetTextMsg("Process:" + WFState);
                     activities[i].SetWFState(WFState);
                 }
                 if (!activities[i].IsProcessed())
                 {
                     activities[i].SetProcessed(true);
                 }
                 activities[i].Save();
             }
         }       //	closed
     }
     else
     {
         log.Log(Level.SEVERE, "Ignored Invalid Transformation " + ToString() + " => " + WFState);
     }
 }
示例#14
0
    // Initializer
    public void Populate(EncounterRoster roster, Arena arenaPrefab)       // Eventually should add 'Script'
    {
        animationQueue = GetComponentInChildren <AnimationQueue>();

        combatants = GenerateFactionMap(roster);

        turnCounter = new TurnCounter <Combatant>(
            (a, b) => b.Character.Speed.Current.CompareTo(a.Character.Speed.Current)
            );
        turnCounter.Add(combatants[HERO_FACTION]);
        turnCounter.Add(combatants[ENEMY_FACTION]);
        turnCounter.Reset();

        arena = Instantiate(arenaPrefab, transform);
        arena.Populate(combatants);

        stateEngine = new StateEngine <Encounter>(this, new SetupState());
    }
示例#15
0
        private static void WindowOnRenderFrame(object sender, FrameEventArgs frameEventArgs)
        {
            StateEngine.Render();

            //WorldRenderer.RenderWorld(_world, _projection);

            Window.SwapBuffers();

            _fpsCounter++;
            _fpsTimer += frameEventArgs.Time;
            if (_fpsTimer >= 1)
            {
                //Logger.Debug("FPS: " + _fpsCounter / 1f);
                _fpsTimer  -= 1;
                _fpsCounter = 0;

                //Logger.Debug($"ChunksQueued: {_world.ChunksQueuedCount}, ChunksReady: {_world.ChunksReadyCount}, ChunksLoaded: {_world.ChunksLoadedCount}");
            }
        }
示例#16
0
        public HttpResponseMessage Post(PostData logindata)
        {
            if (logindata == null)
            {
                return(new HttpResponseMessage(System.Net.HttpStatusCode.BadRequest));
            }

            string token = Security.getToken(logindata.name, logindata.pw);
            State  state = StateEngine.GetState();

            if (state.GetPlayer(token) == null)
            {
                Event e = new NewPlayer(0, logindata.name, token);
                EventEngine.AddEvent(e);
                e.processed.WaitOne();
            }
            HttpResponseMessage response = Request.CreateResponse();

            response.Content = new StringContent(token);
            return(response);
        }
示例#17
0
        private static void WaitForInputLoop()
        {
            string input = "h";

            while (input != "")
            {
                switch (input.ToUpper())
                {
                case "H":
                    Console.WriteLine("Commands:");
                    Console.WriteLine("\th: Help");
                    Console.WriteLine("\tg: Open Game");
                    Console.WriteLine("\tr: Reset Game");
                    Console.WriteLine("\tc: Clear line Game");
                    Console.WriteLine("\tEnter: Shutdown Server");
                    break;

                case "C":
                    Console.WriteLine();
                    Console.WriteLine("-------------------------------");
                    Console.WriteLine();
                    break;

                case "G":
                    Process.Start(Settings.webserverUrl); break;

                case "R":
                    Stop();
                    Start();
                    StateEngine.ResetState();

                    Console.WriteLine("Game reset done");
                    break;

                default: break;
                }
                input = Console.ReadLine();
            }
        }
示例#18
0
        protected override Task Initialize(string apiKey)
        {
            StateEngine = StateEngineFactory.GetStateEngine(apiKey);

            return(Task.CompletedTask);
        }
示例#19
0
        //Thread worker = null;
        /// <summary>
        /// Start Workflow and Wait for completion.
        /// </summary>
        /// <param name="pi">process info with Record_ID record for the workflow</param>
        /// <returns>process</returns>
        public MWFProcess StartWait(ProcessInfo pi)
        {
            const int SLEEP    = 500; //	1/2 sec
            const int MAXLOOPS = 160; // 50;// 30;		//	15 sec
            //
            MWFProcess process = Start(pi);

            if (process == null)
            {
                return(null);
            }

            //Causes the currently executing thread object to temporarily pause
            //and allow other threads to execute.
            //Thread.yield();
            Thread.Sleep(0);

            StateEngine state = process.GetState();
            //worker = new Thread(new ThreadStart(process.Run));
            //worker.Start();
            int loops = 0;

            while (!state.IsClosed() && !state.IsSuspended() && !state.IsBackground())
            {
                if (loops > MAXLOOPS)
                {
                    // MessageBox.Show("Timeout after sec " + ((SLEEP * MAXLOOPS) / 1000));
                    pi.SetSummary(Msg.GetMsg(GetCtx(), "ProcessRunning", true));
                    pi.SetIsTimeout(true);
                    return(process);
                }
                try
                {
                    Thread.Sleep(SLEEP);
                    loops++;
                }
                catch (Exception e)
                {
                    log.Log(Level.SEVERE, "Interrupted", e);
                    pi.SetSummary("Interrupted");
                    return(process);
                }
                //Thread.yield();
                Thread.Sleep(0);
                state = process.GetState();
            }
            String summary = process.GetProcessMsg();

            // Change to get the Error Message and Display the Message
            ValueNamePair vp = VLogger.RetrieveAdvDocNoError();

            if (vp != null)
            {
                summary = vp.GetValue();
            }
            // Change to get the Error Message and Display the Message

            if (summary == null || summary.Trim().Length == 0)
            {
                // in case of Suspend (User Approval) show the workflow node on which it is suspended for approval
                if (state != null && state.GetState() == StateEngine.STATE_SUSPENDED)
                {
                    string node = Util.GetValueOfString(DB.ExecuteScalar(@"SELECT n.Name FROM AD_WF_Activity ac INNER JOIN AD_WF_Node n ON ac.AD_WF_Node_ID = n.AD_WF_Node_ID WHERE
                                  ac.AD_WF_Process_ID = " + process.Get_ID() + " AND ac.WFState = '" + StateEngine.STATE_SUSPENDED + "'"));
                    if (!String.IsNullOrEmpty(node))
                    {
                        summary = state.ToString() + " " + Msg.GetMsg(GetCtx(), "For") + " " + node;
                    }
                }
                else
                {
                    summary = state.ToString();
                }
            }

            pi.SetSummary(summary, state.IsTerminated() || state.IsAborted());
            log.Fine(summary);
            return(process);
        }
	public void Init()
	{
		go = CreateGameObject("stateTest");
		behaviour = go.AddComponent<StateBehaviour>();
		engine = go.GetComponent<StateEngine>();
	}
示例#21
0
 /// <summary>
 /// Load Constructor
 /// </summary>
 /// <param name="ctx">context</param>
 /// <param name="rs">result set</param>
 /// <param name="trxName">transaction</param>
 public MWFProcess(Ctx ctx, DataRow rs, Trx trxName)
     : base(ctx, rs, trxName)
 {
     _state = new StateEngine(GetWFState());
     _state.SetCtx(GetCtx());
 }
示例#22
0
        /// <summary>
        /// Check Status of Activities.
        /// - update Process if required
        /// - start new activity
        /// </summary>
        public void CheckActivities()
        {
            log.Info(ToString());
            if (_state.IsClosed())
            {
                return;
            }
            //
            MWFActivity[] activities  = GetActivities(true, true);      //	requery active
            String        closedState = null;
            bool          suspended   = false;
            bool          running     = false;

            for (int i = 0; i < activities.Length; i++)
            {
                MWFActivity activity = activities[i];
                activity.SetAD_Window_ID(GetAD_Window_ID());
                StateEngine activityState = activity.GetState();

                //	Completed - Start Next
                if (activityState.IsCompleted() || activityState.IsBackground())
                {
                    if (StartNext(activity, activities))
                    {
                        continue;
                    }
                }
                //
                String activityWFState = activity.GetWFState();
                if (activityState.IsClosed() || activityState.IsBackground())
                {
                    //	eliminate from active processed
                    //activity.SetProcessed(true);
                    activity.Set_ValueNoCheck("Processed", true);
                    //activities
                    activity.Save();
                    //
                    if (closedState == null)
                    {
                        closedState = activityWFState;
                    }
                    else if (!closedState.Equals(activityState))
                    {
                        //	Overwrite if terminated
                        if (WFSTATE_Terminated.Equals(activityState))
                        {
                            closedState = activityWFState;
                        }
                        //	Overwrite if activity aborted and no other terminated
                        else if (WFSTATE_Aborted.Equals(activityState) && !WFSTATE_Terminated.Equals(closedState))
                        {
                            closedState = activityWFState;
                        }
                    }
                }
                else                    //	not closed
                {
                    closedState = null; //	all need to be closed
                    if (activityState.IsSuspended())
                    {
                        suspended = true;
                    }
                    if (activityState.IsRunning())
                    {
                        running = true;
                    }
                }
            }   //	for all activities
            if (activities.Length == 0)
            {
                SetTextMsg("No Active Processed found");
                closedState = WFSTATE_Terminated;
            }
            if (closedState != null)
            {
                if (closedState == StateEngine.STATE_BACKGROUND)
                {
                    _state.SetState(StateEngine.STATE_BACKGROUND);
                }
                SetWFState(closedState);
                GetPO();
                if (_po != null)
                {
                    _po.Unlock(Get_TrxName());
                }
            }
            else if (suspended)
            {
                SetWFState(WFSTATE_Suspended);
            }
            else if (running)
            {
                SetWFState(WFSTATE_Running);
            }
        }
示例#23
0
 private static void WindowOnClosed(object sender, EventArgs eventArgs)
 {
     StateEngine.Exit();
     //_world.Unload();
 }
示例#24
0
 private Player GetPlayer()
 {
     return(StateEngine.GetState().GetPlayer(playerID));
 }
        public async Task <TState> Execute()
        {
            var previousState = StatedEntity.State;

            if (TransitionToInvoke == null)
            {
                throw new TransitionNotSpecifiedException();
            }

            try
            {
                var transition = GetRequestedTransition;
                IStateHandler <TEntity> transitionHandler = transition?.OnTransitioning?.Invoke();

                var validationResult = await IsPreconditionOk().ConfigureAwait(false);

                if (validationResult is TransitionValidationFailed failedResult && transitionHandler != null)
                {
                    StatedEntity.State.InitFailedTransitionResult(
                        previousState,
                        TransitionToInvoke,
                        failedResult);

                    if (transitionHandler is IPrevalidation <TEntity> pv)
                    {
                        await pv.OnValidationFailed(StatedEntity, failedResult).ConfigureAwait(false);
                    }
                    return(StatedEntity.State);
                }

                ITransitionExecutionResult transitionResult = null;
                Exception transitionException = null;

                if (transition.OnTransitioning != null)
                {
                    try
                    {
                        transitionHandler = transition.OnTransitioning.Invoke();
                        if (transitionHandler is IBeforeTransition <TEntity> bth)
                        {
                            await bth.OnPrepareTransition(StatedEntity).ConfigureAwait(false);
                        }
                        transitionResult = await transitionHandler.ExecuteTransition(StatedEntity).ConfigureAwait(false);
                    }
                    catch (Exception e)
                    {
                        transitionException    = e;
                        IsTransitionSuccessful = false;
                        transitionResult       = CreateFailedResult(previousState, TransitionToInvoke, "TransitionFailed", e);
                    }
                }

                if (transitionResult is TransitionSuccessful successfulResult)
                {
                    StatedEntity.State = transition.StateTransitionOnSuccess.Compile()(StatedEntity.State);
                    if (transitionHandler is IAfterSuccessfulTransition <TEntity> ast)
                    {
                        await ast.OnSuccessfulTransition(StatedEntity, successfulResult).ConfigureAwait(false);
                    }

                    StatedEntity.State.InitSuccessfulTransitionResult(successfulResult);
                    ActionOnSuccess?.Invoke(StatedEntity, StatedEntity.State);
                    await StateEngine.NotifyStateChange(StatedEntity).ConfigureAwait(false);

                    return(StatedEntity.State);
                }

                if (transitionHandler is IAfterFailedTransition <TEntity> aft)
                {
                    await aft.OnFailedTransition(StatedEntity, transitionResult as TransitionFailed).ConfigureAwait(false);
                }

                if (transition.OnTransitionFailed == null)
                {
                    throw new TransitionFailedException(transition.StateTransitionOnSuccess.TransitionName <TState, TStateEnum>(),
                                                        $"{previousState}", transitionException);
                }

                throw new TransitionRollbackFailedException(
                          transition.StateTransitionOnFailed?.TransitionName <TState, TStateEnum>()
                          ?? "[rollback undefined]", $"{previousState}", transitionException);
            }
            catch (Exception ex)
            {
                StatedEntity.State.InitFailedTransitionResult(previousState, TransitionToInvoke, "TransitionExecutionFailed", ex);
                StatedEntity.State.TransitionResult.AddMessageArg("", "");
                ActionOnError?.Invoke(StatedEntity, StatedEntity.State);
                return(StatedEntity.State);
            }
        }
 public void Init()
 {
     go        = CreateGameObject("stateTest");
     behaviour = go.AddComponent <StateBehaviour>();
     engine    = go.GetComponent <StateEngine>();
 }
示例#27
0
    // Use this for initialization
    private void Start()
    {
        _init = false;
        _stateEngine = new StateEngine<MonsterAction>();
        _stateEngine.debug = true;
        //_stateEngine.Init(this, new MonsterStateNormalStage(normalParam));

        //init status
        hitCount = 0;
        targetActive = true;
        _health = maxHealth;

        DeactivatePunch(PunchType.Left);
        DeactivatePunch(PunchType.Right);
        DeactivateDash();

        healthBar.targetHealth = 1.0f;
    }
示例#28
0
        //Thread worker = null;
        /// <summary>
        /// Start Workflow and Wait for completion.
        /// </summary>
        /// <param name="pi">process info with Record_ID record for the workflow</param>
        /// <returns>process</returns>
        public MWFProcess StartWait(ProcessInfo pi)
        {
            const int SLEEP    = 500; //	1/2 sec
            const int MAXLOOPS = 160; // 50;// 30;		//	15 sec
            //
            MWFProcess process = Start(pi);

            if (process == null)
            {
                return(null);
            }

            //Causes the currently executing thread object to temporarily pause
            //and allow other threads to execute.
            //Thread.yield();
            Thread.Sleep(0);

            StateEngine state = process.GetState();
            //worker = new Thread(new ThreadStart(process.Run));
            //worker.Start();
            int loops = 0;

            while (!state.IsClosed() && !state.IsSuspended())
            {
                if (loops > MAXLOOPS)
                {
                    // MessageBox.Show("Timeout after sec " + ((SLEEP * MAXLOOPS) / 1000));
                    pi.SetSummary(Msg.GetMsg(GetCtx(), "ProcessRunning", true));
                    pi.SetIsTimeout(true);
                    return(process);
                }
                try
                {
                    Thread.Sleep(SLEEP);
                    loops++;
                }
                catch (Exception e)
                {
                    log.Log(Level.SEVERE, "Interrupted", e);
                    pi.SetSummary("Interrupted");
                    return(process);
                }
                //Thread.yield();
                Thread.Sleep(0);
                state = process.GetState();
            }
            String summary = process.GetProcessMsg();

            // Change to get the Error Message and Display the Message
            ValueNamePair vp = VLogger.RetrieveAdvDocNoError();

            if (vp != null)
            {
                summary = vp.GetValue();
            }
            // Change to get the Error Message and Display the Message


            if (summary == null || summary.Trim().Length == 0)
            {
                summary = state.ToString();
            }



            pi.SetSummary(summary, state.IsTerminated() || state.IsAborted());
            log.Fine(summary);
            return(process);
        }
 void Awake()
 {
     m_playerInput = gameObject.GetComponent<PlayerInputController>();
     m_stateMachine = gameObject.GetComponent<StateEngine>();
     m_playerMoveState = gameObject.GetComponent<GameObjectMoveState>();
 }