예제 #1
0
파일: WorldState.cs 프로젝트: teamstor/aod
        public override void Update(double deltaTime, double totalTime, long count)
        {
            if (Input.Key(Keys.LeftShift) && Input.KeyPressed(Keys.F5))
            {
                _debug = !_debug;
            }

            if (_useTransiton && _transition.IsComplete && Paused)
            {
                _useTransiton = Paused = false;
                Coroutine.Start(ShowMapName);
            }

            if (!Paused)
            {
                Player.Update(deltaTime, totalTime, count);

                foreach (NPC npc in NPCs)
                {
                    npc.Update(deltaTime, totalTime, count);
                }

                foreach (Tile.MapLayer layer in Tile.CachedAllMapLayers)
                {
                    TileEventBase oldEvents = Map[layer, _lastPlayerPos.X, _lastPlayerPos.Y].Events;
                    TileEventBase newEvents = Map[layer, Player.Position.X, Player.Position.Y].Events;

                    if (Player.Position != _lastPlayerPos)
                    {
                        if (Map.Info.CombatArea)
                        {
                            RandomEncounter.TryRandomEncounter(this);
                        }

                        oldEvents?.OnWalkLeave(Map.GetMetadata(layer, _lastPlayerPos.X, _lastPlayerPos.Y), this, _lastPlayerPos);
                        newEvents?.OnWalkEnter(Map.GetMetadata(layer, Player.Position.X, Player.Position.Y), this, Player.Position);
                    }
                }

                _lastPlayerPos = Player.Position;
            }

            Camera.Update(deltaTime);

            while (_npcDespawnQueue.Count > 0)
            {
                NPC npc = _npcDespawnQueue.Dequeue();
                _npcs.Remove(npc);
            }

            if (UpdateHook != null)
            {
                UpdateHook(this, new Game.UpdateEventArgs(deltaTime, totalTime, count));
            }
        }
예제 #2
0
파일: WorldState.cs 프로젝트: teamstor/aod
 public override void FixedUpdate(long count)
 {
     if (!Paused)
     {
         foreach (Tile.MapLayer layer in Tile.CachedAllMapLayers)
         {
             TileEventBase events = Map[layer, Player.Position.X, Player.Position.Y].Events;
             events?.OnStandingOn(Map.GetMetadata(layer, Player.Position.X, Player.Position.Y), this, Player.Position, count);
         }
     }
 }
예제 #3
0
        public void Update(double deltaTime, double totalTime, long count)
        {
            foreach (Quest quest in Quests)
            {
                quest.OnQuestTick(this);
            }

            if (!IsWalking)
            {
                if (InputMap.FindMapping(InputAction.Inventory).Pressed(World.Input))
                {
                    InventoryUI.Show(World, this);
                    return;
                }

                if (InputMap.FindMapping(InputAction.Spells).Pressed(World.Input))
                {
                    SpellsUI.Show(World);
                    return;
                }

                if (InputMap.FindMapping(InputAction.Player).Pressed(World.Input))
                {
                    PlayerUI.Show(World);
                    return;
                }

                if (InputMap.FindMapping(InputAction.Menu).Pressed(World.Input))
                {
                    PauseMenuUI.Show(World);
                    return;
                }


                Direction _lastHeading = Heading;

                if (InputMap.FindMapping(InputAction.Up).Held(World.Input))
                {
                    if (Heading != Direction.Up)
                    {
                        Heading = Direction.Up;
                    }
                    else if (_keyHeld == 0)
                    {
                        _keyHeld = 0.1;
                    }

                    _keyHeld += deltaTime;
                }
                else if (InputMap.FindMapping(InputAction.Down).Held(World.Input))
                {
                    if (Heading != Direction.Down)
                    {
                        Heading = Direction.Down;
                    }
                    else if (_keyHeld == 0)
                    {
                        _keyHeld = 0.1;
                    }

                    _keyHeld += deltaTime;
                }
                else if (InputMap.FindMapping(InputAction.Left).Held(World.Input))
                {
                    if (Heading != Direction.Left)
                    {
                        Heading = Direction.Left;
                    }
                    else if (_keyHeld == 0)
                    {
                        _keyHeld = 0.1;
                    }

                    _keyHeld += deltaTime;
                }
                else if (InputMap.FindMapping(InputAction.Right).Held(World.Input))
                {
                    if (Heading != Direction.Right)
                    {
                        Heading = Direction.Right;
                    }
                    else if (_keyHeld == 0)
                    {
                        _keyHeld = 0.1;
                    }

                    _keyHeld += deltaTime;
                }
                else
                {
                    _keyHeld -= deltaTime * 2;
                }

                _keyHeld = MathHelper.Clamp((float)_keyHeld, 0.0f, 0.1f);

                if (_keyQueued != Keys.None)
                {
                    if (_keyQueued == Keys.Up)
                    {
                        Heading = Direction.Up;
                    }
                    if (_keyQueued == Keys.Down)
                    {
                        Heading = Direction.Down;
                    }
                    if (_keyQueued == Keys.Left)
                    {
                        Heading = Direction.Left;
                    }
                    if (_keyQueued == Keys.Right)
                    {
                        Heading = Direction.Right;
                    }

                    _keyHeld   = 0.1f;
                    _keyQueued = Keys.None;
                }

                if (_lastHeading != Heading && _keyHeld < 0.1)
                {
                    _landWhen = World.Game.Time + 0.1;
                }

                if (_keyHeld >= 0.1)
                {
                    if (!World.IsPointBlocked(Position + Heading.ToPoint()))
                    {
                        MoveTo(Position + Heading.ToPoint());
                    }
                }

                if (InputMap.FindMapping(InputAction.Action).Pressed(World.Input))
                {
                    Point interactionPoint = Position + Heading.ToPoint();
                    interactionPoint.X = (int)MathHelper.Clamp(interactionPoint.X, 0, World.Map.Width - 1);
                    interactionPoint.Y = (int)MathHelper.Clamp(interactionPoint.Y, 0, World.Map.Height - 1);

                    foreach (Tile.MapLayer layer in Tile.CachedAllMapLayers)
                    {
                        TileEventBase events = World.Map[layer, interactionPoint.X, interactionPoint.Y].Events;
                        events?.OnInteract(World.Map.GetMetadata(layer, interactionPoint.X, interactionPoint.Y), World, interactionPoint);
                    }

                    foreach (NPC npc in World.NPCs)
                    {
                        if (npc.Position == interactionPoint)
                        {
                            bool isFacingPlayer =
                                Heading == Direction.Left && npc.Heading == Direction.Right ||
                                Heading == Direction.Right && npc.Heading == Direction.Left ||
                                Heading == Direction.Up && npc.Heading == Direction.Down ||
                                Heading == Direction.Down && npc.Heading == Direction.Up;

                            npc.Template.Behavior.OnInteract(npc, this, isFacingPlayer);
                        }
                    }
                }
            }
        }