public override void Update(GameTime gameTime)
        {
            foreach (Entity e in EntityList)
            {
                var scriptHandlers = e.GetComponent <CScriptHandlers>();

                foreach (int callbackID in scriptHandlers.ScriptHandlerIDs)
                {
                    GameRegistry.FetchScriptCallback(callbackID)(e, gameTime);
                }
            }
        }
Exemple #2
0
        public static void Initialize()
        {
            GameRegistry.Initialize();

            entityList = new List <Entity>();
            systemList = new List <System>();

            chngEntsQueue = new List <Entity>();
            addEntsQueue  = new List <Entity>();
            rmvEntsQueue  = new List <Entity>();

            manager = new NodeListManager(GetAllEntities);

            NextInstanceID = 0x00000001;
        }
Exemple #3
0
 public static Entity SpawnPrefab(int code)
 {
     return(AddEntity(GameRegistry.CreatePrefab(code)));
 }
Exemple #4
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);
                }
            }
        }