コード例 #1
0
ファイル: Chicken.cs プロジェクト: LeviaTTV/Nova
        public override void Update(GameTime gameTime)
        {
            base.Update(gameTime);

            var anim  = _walkingAnimation.GetAnimationForOrientation(Orientation);
            var sheet = anim.AnimatedSpriteSheets.FirstOrDefault();

            if (!IsMoving)
            {
                sheet.Reset();
            }
            else
            {
                sheet.Update(gameTime);
            }

            if (ActiveActions.Any())
            {
                foreach (var act in ActiveActions)
                {
                    act.Action(gameTime, act);
                }

                return;
            }

            _currentAnimationSheet = anim.AnimatedSpriteSheets.FirstOrDefault();
        }
コード例 #2
0
        public Error Cancel(uint id)
        {
            ActiveAction activeAction;

            if (ActiveActions.TryGetValue(id, out activeAction) && !activeAction.IsDone)
            {
                var actionRequirements =
                    Ioc.Kernel.Get <ActionRequirementFactory>().GetActionRequirementRecord(activeAction.WorkerType);
                var actionRequirement = actionRequirements.List.FirstOrDefault(x => x.Index == activeAction.WorkerIndex);
                if (actionRequirement == null ||
                    (actionRequirement.Option & ActionOption.Uncancelable) == ActionOption.Uncancelable)
                {
                    return(Error.ActionUncancelable);
                }

                ThreadPool.QueueUserWorkItem(ActiveCancelCallback, activeAction);
                return(Error.Ok);
            }

            PassiveAction passiveAction;

            if (PassiveActions.TryGetValue(id, out passiveAction) && !passiveAction.IsDone)
            {
                if (!passiveAction.IsCancellable)
                {
                    return(Error.ActionUncancelable);
                }

                ThreadPool.QueueUserWorkItem(PassiveCancelCallback, passiveAction);
                return(Error.Ok);
            }

            return(Error.ActionNotFound);
        }
コード例 #3
0
ファイル: FsmState.cs プロジェクト: smdx24/CPI-Source-Code
 private bool ActivateActions(int startIndex)
 {
     for (int i = startIndex; i < Actions.Length; i++)
     {
         activeActionIndex = i;
         FsmStateAction fsmStateAction = Actions[i];
         if (!fsmStateAction.Enabled)
         {
             fsmStateAction.Finished = true;
             continue;
         }
         ActiveActions.Add(fsmStateAction);
         activeAction            = fsmStateAction;
         fsmStateAction.Active   = true;
         fsmStateAction.Finished = false;
         fsmStateAction.Init(this);
         fsmStateAction.Entered = true;
         fsmStateAction.OnEnter();
         if (Fsm.IsSwitchingState)
         {
             return(false);
         }
         if (!fsmStateAction.Finished && isSequence)
         {
             return(false);
         }
     }
     return(true);
 }
コード例 #4
0
ファイル: FsmState.cs プロジェクト: smdx24/CPI-Source-Code
 private void RemoveFinishedActions()
 {
     for (int i = 0; i < finishedActions.Count; i++)
     {
         ActiveActions.Remove(finishedActions[i]);
     }
     finishedActions.Clear();
 }
コード例 #5
0
ファイル: LivingGameObject.cs プロジェクト: LeviaTTV/Nova
        public void PerformAction(string name, bool force = false)
        {
            if (SupportedActions.TryGetValue(name, out var action))
            {
                ActiveActions.Add(action);

                action.IsRunning = true;
            }
        }
コード例 #6
0
ファイル: BaseSite.cs プロジェクト: hbernaciak/Doormat
 protected void callInvestFinished(bool Success, string Message)
 {
     if (ActiveActions.Contains(SiteAction.Invest))
     {
         ActiveActions.Remove(SiteAction.Invest);
     }
     OnWithdrawalFinished?.Invoke(this, new GenericEventArgs {
         Success = Success, Message = Message
     });
 }
コード例 #7
0
ファイル: BaseSite.cs プロジェクト: Seuntjie900/Doormat
 protected void callResetSeedFinished(bool Success, string Message)
 {
     if (ActiveActions.Contains(SiteAction.ResetSeed))
     {
         ActiveActions.Remove(SiteAction.ResetSeed);
     }
     OnResetSeedFinished?.Invoke(this, new GenericEventArgs {
         Success = Success, Message = Message
     });
 }
コード例 #8
0
ファイル: BaseSite.cs プロジェクト: Seuntjie900/Doormat
 protected void callInvestFinished(bool Success, string Message)
 {
     if (ActiveActions.Contains(SiteAction.Invest))
     {
         ActiveActions.Remove(SiteAction.Invest);
     }
     ForceUpdateStats = true;
     OnInvestFinished?.Invoke(this, new GenericEventArgs {
         Success = Success, Message = Message
     });
 }
コード例 #9
0
ファイル: BaseSite.cs プロジェクト: hbernaciak/Doormat
 public void SendTip(string Username, decimal Amount)
 {
     if (CanTip)
     {
         ActiveActions.Add(SiteAction.Tip);
         callNotify($"Tipping {Amount} {CurrentCurrency} to {Username}");
         _SendTip(Username, Amount);
     }
     else
     {
         callError("Tipping not allowed!", false, ErrorType.NotImplemented);
     }
 }
コード例 #10
0
        public bool Contains(GameAction action)
        {
            if (action is ActiveAction)
            {
                return(ActiveActions.ContainsKey(action.ActionId));
            }

            if (action is PassiveAction)
            {
                return(PassiveActions.ContainsKey(action.ActionId));
            }

            return(false);
        }
コード例 #11
0
ファイル: BaseSite.cs プロジェクト: hbernaciak/Doormat
 public void Withdraw(string Address, decimal Amount)
 {
     if (AutoWithdraw)
     {
         ActiveActions.Add(SiteAction.Withdraw);
         callNotify($"Withdrawing {Amount} {CurrentCurrency} to {Address}");
         _Withdraw(Address, Amount);
         UpdateStats();
     }
     else
     {
         callError("Withdrawing not allowed!", false, ErrorType.NotImplemented);
     }
 }
コード例 #12
0
ファイル: BaseSite.cs プロジェクト: hbernaciak/Doormat
 public void Invest(decimal Amount)
 {
     if (AutoInvest)
     {
         ActiveActions.Add(SiteAction.Invest);
         callNotify($"Investing {Amount} {CurrentCurrency}");
         _Invest(Amount);
         UpdateStats();
     }
     else
     {
         callError("Investing not allowed!", false, ErrorType.NotImplemented);
     }
 }
コード例 #13
0
ファイル: BaseSite.cs プロジェクト: hbernaciak/Doormat
 public void ResetSeed(string ClientSeed)
 {
     if (CanChangeSeed)
     {
         ActiveActions.Add(SiteAction.ResetSeed);
         callNotify("Resetting seed.");
         _ResetSeed();
         if (CanSetClientSeed)
         {
             SetClientSeed(ClientSeed);
         }
     }
     else
     {
         callError("Reset Seed not allowed!", false, ErrorType.NotImplemented);
     }
 }
コード例 #14
0
ファイル: FsmState.cs プロジェクト: smdx24/CPI-Source-Code
 public void OnEnter()
 {
     loopCount++;
     if (loopCount > maxLoopCount)
     {
         maxLoopCount = loopCount;
     }
     active   = true;
     finished = false;
     finishedActions.Clear();
     RealStartTime = FsmTime.RealtimeSinceStartup;
     StateTime     = 0f;
     ActiveActions.Clear();
     if (ActivateActions(0))
     {
         CheckAllActionsFinished();
     }
 }
コード例 #15
0
ファイル: LivingGameObject.cs プロジェクト: LeviaTTV/Nova
        public override void Update(GameTime gameTime)
        {
            ActiveActions.RemoveAll(z => !z.IsRunning);

            if (_walkingToList == null || !_walkingToList.Any())
            {
                return;
            }

            if (Vector2.Distance(Position, _targetPoint) < 5f)
            {
                _walkingToList.Remove(_targetPoint);
                _targetPoint = _walkingToList.FirstOrDefault();
                if (_targetPoint == default(Vector2))
                {
                    _walkingToList.Clear();
                    IsMoving = false;
                    return;
                }
            }

            var currentTargetPoint = _targetPoint;
            var elapsed            = (float)gameTime.ElapsedGameTime.TotalMilliseconds;

            var distance           = Vector2.Distance(Position, currentTargetPoint);
            var interpolatedVector = Vector2.Lerp(Position, currentTargetPoint, MoveSpeedModifier / distance * elapsed);

            float xDif = interpolatedVector.X - Position.X;
            float yDif = interpolatedVector.Y - Position.Y;

            if (Math.Abs(xDif) > Math.Abs(yDif))
            {
                Orientation = xDif < 0 ? Orientation.Left : Orientation.Right;
            }
            else
            {
                Orientation = yDif < 0 ? Orientation.Top : Orientation.Bottom;
            }

            IsMoving = true;

            Position = interpolatedVector;
        }
コード例 #16
0
        public override void Update(GameTime gameTime)
        {
            //Update Keyboard and Mouse States
            PreviousKeyboardState = CurrentKeyboardState;
            CurrentKeyboardState  = Keyboard.GetState();
            PreviousMouseState    = CurrentMouseState;
            CurrentMouseState     = Mouse.GetState();

            //Clear Data Structures
            ActiveActions.Clear();
            ActiveStates.Clear();
            ActiveRanges.Clear();
            MappedKeyboardKeys.Clear();
            MappedMouseButtons.Clear();
            MappedMouseRanges.Clear();
            RangeValues.Clear();

            MouseScreenLocation = new Point(CurrentMouseState.X, CurrentMouseState.Y);

            //Sort EntityList by InputMap Priority
            EntityList.Sort((Entity x, Entity y) =>
            {
                if (x.GetComponent <CInputMap>().Priority < y.GetComponent <CInputMap>().Priority)
                {
                    return(-1);
                }
                else if (x.GetComponent <CInputMap>().Priority > y.GetComponent <CInputMap>().Priority)
                {
                    return(1);
                }
                else
                {
                    return(0);
                }
            });

            //Map Raw Inputs to Actions, States and Ranges
            foreach (Entity e in EntityList)
            {
                var inputMap = e.GetComponent <CInputMap>();

                //KEYBOARD KEY TO ACTION
                foreach (KeyValuePair <Keys, int> pair in inputMap.KeyboardKeyToAction)
                {
                    if (!MappedKeyboardKeys.Contains(pair.Key))
                    {
                        if (PreviousKeyboardState.IsKeyUp(pair.Key) && CurrentKeyboardState.IsKeyDown(pair.Key))
                        {
                            ActiveActions.Add(pair.Value);
                            MappedKeyboardKeys.Add(pair.Key);
                        }
                    }
                }

                //KEYBOARD KEY TO STATE
                foreach (KeyValuePair <Keys, int> pair in inputMap.KeyboardKeyToState)
                {
                    if (!MappedKeyboardKeys.Contains(pair.Key))
                    {
                        if (CurrentKeyboardState.IsKeyDown(pair.Key))
                        {
                            ActiveStates.Add(pair.Value);
                            MappedKeyboardKeys.Add(pair.Key);
                        }
                    }
                }

                //MOUSE BUTTON TO ACTION
                foreach (KeyValuePair <MouseButtons, int> pair in inputMap.MouseButtonToAction)
                {
                    if (!MappedMouseButtons.Contains(pair.Key))
                    {
                        if (pair.Key == MouseButtons.LeftButton)
                        {
                            if (PreviousMouseState.LeftButton == ButtonState.Released && CurrentMouseState.LeftButton == ButtonState.Pressed)
                            {
                                ActiveActions.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.RightButton)
                        {
                            if (PreviousMouseState.RightButton == ButtonState.Released && CurrentMouseState.RightButton == ButtonState.Pressed)
                            {
                                ActiveActions.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.MiddleButton)
                        {
                            if (PreviousMouseState.MiddleButton == ButtonState.Released && CurrentMouseState.MiddleButton == ButtonState.Pressed)
                            {
                                ActiveActions.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.XButton1)
                        {
                            if (PreviousMouseState.XButton1 == ButtonState.Released && CurrentMouseState.XButton1 == ButtonState.Pressed)
                            {
                                ActiveActions.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.XButton2)
                        {
                            if (PreviousMouseState.XButton2 == ButtonState.Released && CurrentMouseState.XButton2 == ButtonState.Pressed)
                            {
                                ActiveActions.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                    }
                }

                //MOUSE BUTTON TO STATE
                foreach (KeyValuePair <MouseButtons, int> pair in inputMap.MouseButtonToState)
                {
                    if (!MappedMouseButtons.Contains(pair.Key))
                    {
                        if (pair.Key == MouseButtons.LeftButton)
                        {
                            if (CurrentMouseState.LeftButton == ButtonState.Pressed)
                            {
                                ActiveStates.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.RightButton)
                        {
                            if (CurrentMouseState.RightButton == ButtonState.Pressed)
                            {
                                ActiveStates.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.MiddleButton)
                        {
                            if (CurrentMouseState.MiddleButton == ButtonState.Pressed)
                            {
                                ActiveStates.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.XButton1)
                        {
                            if (CurrentMouseState.XButton1 == ButtonState.Pressed)
                            {
                                ActiveStates.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                        if (pair.Key == MouseButtons.XButton2)
                        {
                            if (CurrentMouseState.XButton2 == ButtonState.Pressed)
                            {
                                ActiveStates.Add(pair.Value);
                                MappedMouseButtons.Add(pair.Key);
                            }
                        }
                    }
                }

                //MOUSE RANGE TO RANGE
                foreach (KeyValuePair <MouseRanges, int> pair in inputMap.MouseRangeToRange)
                {
                    if (!MappedMouseRanges.Contains(pair.Key))
                    {
                        if (pair.Key == MouseRanges.ScrollDelta)
                        {
                            ActiveRanges.Add(pair.Value);
                            RangeValues.Add(pair.Value, CurrentMouseState.ScrollWheelValue - PreviousMouseState.ScrollWheelValue);
                            MappedMouseRanges.Add(pair.Key);
                        }
                        if (pair.Key == MouseRanges.MouseHorizontalDelta)
                        {
                            float hCenter = ViewPort.Width / 2;
                            ActiveRanges.Add(pair.Value);
                            RangeValues.Add(pair.Value, CurrentMouseState.X - hCenter);
                            MappedMouseRanges.Add(pair.Key);
                        }
                        if (pair.Key == MouseRanges.MouseVerticalDelta)
                        {
                            float vCenter = ViewPort.Height / 2;
                            ActiveRanges.Add(pair.Value);
                            RangeValues.Add(pair.Value, CurrentMouseState.Y - vCenter);
                            MappedMouseRanges.Add(pair.Key);
                        }
                    }
                }
            }

            //Given the Mapped Inputs, Call all Callbacks and see if they can use the Mapped Input
            foreach (Entity e in EntityList)
            {
                var inputHandlers = e.GetComponent <CInputHandlers>();

                foreach (int callbackID in inputHandlers.InputHandlerIDs)
                {
                    GameRegistry.FetchInputCallback(callbackID)(e, gameTime, ActiveActions, ActiveStates, ActiveRanges, RangeValues);
                }
            }
        }