/// <summary>
        /// Allows the game to run logic such as updating the world,
        /// checking for collisions, gathering input, and playing audio.
        /// </summary>
        /// <param name="gameTime">Provides a snapshot of timing values.</param>
        protected override void Update(GameTime gameTime)
        {
            KeyboardState keyboard = Keyboard.GetState();

            // Allows the game to exit
            if (keyboard.IsKeyDown(Keys.Escape))
            {
                this.Exit();
            }
            // Toggle fullscreen
            if (keyboard.IsKeyDown(Keys.LeftAlt) && keyboard.IsKeyDown(Keys.Enter))
            {
                graphics.ToggleFullScreen();
            }
            // Toggle debug info
            if (keyboard.IsKeyDown(Keys.F1))
            {
                foreach (UiObject u in userInterface)
                {
                    u.ToggleDebugMode();
                }
            }

            // Update every UIObject
            foreach (UiObject x in userInterface)
            {
                x.Update(gameTime);
            }

            // Find starting point for Frodo
            Position frodoStartPosition = null;

            foreach (var position in Pathfinder.BreadthFirst(engine, new Position(0, 0), -1, -1))
            {
                if (engine.map.GetTileAt(position).tileType.movementCost < 2)
                {
                    frodoStartPosition = position;
                    break;
                }
            }

            // Find starting point for Sauron
            Position sauronStartPosition = null;

            foreach (var position in Pathfinder.BreadthFirst(engine, new Position(100, 50), -1, -1))
            {
                if (engine.map.GetTileAt(position).tileType.movementCost < 2)
                {
                    sauronStartPosition = position;
                    break;
                }
            }

            Menu inGameScreen = (Menu)userInterface[1];

            if (inGameScreen.active)
            {
                // TODO: Remove
                // Create testing units on the first tick
                if (engine.currentTick == 0)
                {
                    for (int i = 0; i < 10; ++i)
                    {
                        engine.AddUnit(engine.unitTypes[2], frodoStartPosition + new Position(0, i), engine.players[0]);

                        engine.AddUnit(engine.unitTypes[2], sauronStartPosition + new Position(0, i), engine.players[1]);
                    }
                }
                engine.Tick();
            }

            base.Update(gameTime);
        }
Beispiel #2
0
        public void UnitGroupCommand()
        {
            MouseState    mouse = Mouse.GetState();
            KeyboardState keys  = Keyboard.GetState();

            Vector2 mouseTile = new Vector2(Mouse.GetState().X, Mouse.GetState().Y);

            mouseTile.X = m.X / (map.GetPxSizeMod()) + map.GetTileIndexX();
            mouseTile.Y = m.Y / (map.GetPxSizeMod()) + map.GetTileIndexY();

            Position mouseGameTilePosition = new Position((int)mouseTile.X, (int)mouseTile.Y);

            Unit clickedUnit = engine.GetUnitAt(mouseGameTilePosition);
            var  enumerator  = Pathfinder.BreadthFirst(engine, mouseGameTilePosition).GetEnumerator();

            enumerator.MoveNext();
            foreach (Unit unit in selectedUnits)
            {
                if (lastButtonPressed.Equals("None"))
                {
                    // Hold shift to append orders
                    if (keys.IsKeyUp(Keys.LeftShift) && keys.IsKeyUp(Keys.RightShift))
                    {
                        unit.orders.Clear();
                    }

                    // Click on same unit to produce units
                    if (clickedUnit == unit)
                    {
                        if (unit.CanProduce())
                        {
                            engine.OrderProduce(unit, engine.unitTypes[1]);
                        }
                        break;
                    }
                    // Click on other units to attack them
                    else if (clickedUnit != null)                // TODO: make it so you don't attack your buddies
                    {
                        if (selectedUnits.Contains(clickedUnit)) //this check makes it so that you can produce without have the other selected units attack
                        {
                            continue;
                        }
                        if (unit.CanAttack())
                        {
                            engine.OrderAttack(unit, clickedUnit);
                        }
                    }
                    else if (unit.CanMove()) // Move units or gather
                    {
                        // Click on a resource node to gather
                        var resource = engine.map.tiles[enumerator.Current.x, enumerator.Current.y].tileType.resourceType;
                        if (resource != TileType.ResourceType.None)
                        {
                            engine.OrderGather(unit, enumerator.Current);
                            enumerator.MoveNext();
                            continue;
                        }

                        // Click on an empty tile to move
                        while (engine.GetUnitAt(enumerator.Current) != null)
                        {
                            enumerator.MoveNext();
                        }
                        engine.OrderMove(unit, enumerator.Current);
                        enumerator.MoveNext();
                    }
                }
                else
                {
                    unit.orders.Clear();
                    switch (lastButtonPressed)
                    {
                    case "Build Town":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanBuild())
                            {
                                engine.OrderProduce(u, engine.unitTypes[3], mouseGameTilePosition);
                            }
                        }
                        break;

                    case "Build Mine":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanBuild())
                            {
                                engine.OrderProduce(u, engine.unitTypes[4], mouseGameTilePosition);
                            }
                        }
                        break;

                    case "Produce Knight":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[0]);
                            }
                        }
                        break;

                    case "Produce Archer":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[1]);
                            }
                        }
                        break;

                    case "Produce Peasant":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[2]);
                            }
                        }
                        break;

                    case "Attack":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[2]);
                            }
                        }
                        break;

                    case "Move":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[2]);
                            }
                        }
                        break;

                    case "Gather":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[2]);
                            }
                        }
                        break;

                    case "Stop":
                        foreach (Unit u in selectedUnits)
                        {
                            if (u.CanProduce())
                            {
                                engine.OrderProduce(u, engine.unitTypes[2]);
                            }
                        }
                        ClearOrders();
                        break;

                    default:

                        break;
                    } //End switch
                    lastButtonPressed = "None";
                }
            }
            if (keys.IsKeyUp(Keys.LeftControl) && keys.IsKeyUp(Keys.RightControl))
            {
                lastButtonPressed = "None";
            }
        }