Esempio n. 1
0
 //Returns a list of tiles containing a valid target in range of the given ability
 //That list is stored on the ability object and is cleared with each new (non-recursive) call to this method
 public List<Tile> checkRange(Tile origin, Ability ability, int range, Piece user)
 {
     //Clears the list if this is the initial call because the parameter "range" will only equal ability.range if this is the first call
     if (ability.getRange() == range)
     {
         validTargets = new List<Tile>();
     }
     List<Tile> frontier = getNeighbors(origin, new List<Tile>());
     if (!origin.isEmpty())
     {
         //If ability targets enemies & the tile contains a unit from the other faction & if the tile is not already in the list THEN the tile is added
         if (ability.getTargetType().Equals("Enemy") && !(origin.getResident().getFaction().Equals(user.getFaction())) && !validTargets.Contains(origin))
         {
             validTargets.Add(origin);
         }
         //If ability targets friendlies & the tile contains a unit from the same faction & if the tile is not already in the list THEN the tile is added
         else if (ability.getTargetType().Equals("Friendly") && (origin.getResident().getFaction().Equals(user.getFaction())) && !validTargets.Contains(origin))
         {
             validTargets.Add(origin);
         }
     }
     //decrement range for the next round of checks
     int nRange = range - 1;
     if (nRange >= 0)
     {
         for (int i = 0; i < frontier.Count(); i++)
         {
             checkRange(frontier[i], ability, nRange, user);
         }
     }
     return validTargets;
 }
Esempio n. 2
0
        public List<Tile> getNeighbors(Tile tile, List<Tile> neighbors)
        {
            //returns the neighbors of the given tile and adds them to existing list
            //at most, will return 4 tiles
            int xCoord = tile.getXCoord();
            int yCoord = tile.getYCoord();

            //MAYBE TODO, getNeighbors and find moves back to working order

            //prevent array index out of bounds and check for existence of tile in list
            if (xCoord > 0 && !neighbors.Contains(map[xCoord - 1][yCoord]))
            {
                neighbors.Add(map[xCoord - 1][yCoord]);
            }
            if (xCoord < width && !neighbors.Contains(map[xCoord + 1][yCoord]))
            {
                neighbors.Add(map[xCoord + 1][yCoord]);
            }
            if (yCoord > 0 && !neighbors.Contains(map[xCoord][yCoord - 1]))
            {
                neighbors.Add(map[xCoord][yCoord - 1]);
            }
            if (yCoord < width && !neighbors.Contains(map[xCoord][yCoord + 1]))
            {
                neighbors.Add(map[xCoord][yCoord + 1]);
            }
            return neighbors;
        }
Esempio n. 3
0
 public TacMap(Tile[,] map, ContentManager content)
 {
     this.map = map;
     validMoves = new List<Tile>();
     woods = content.Load<Texture2D>("TerrainSprites/tree 2");
     woods2 = content.Load<Texture2D>("TerrainSprites/tree 1");
     mountains = content.Load<Texture2D>("TerrainSprites/terrain_mountains");
     river = content.Load<Texture2D>("TerrainSprites/river");
     //TODO load all unit sprites and terrain sprites and effects sprites for drawing
 }
Esempio n. 4
0
 //checks neighbors of tiles for targets
 public List<Tile> checkMeleeRange(Tile origin)
 {
     List<Tile> targets = new List<Tile>();
     targets = getNeighbors(origin, targets);
     foreach(Tile t in targets)
         if(t.isEmpty())
             targets.Remove(t);
     if(targets.Count == 0)
         return null;
     else
         return targets;
 }
Esempio n. 5
0
 public void updateInfo(Tile t)
 {
     if (t.getResident() != null)
     {
         Piece display = t.getResident();
         unitInfo = "    UNIT \n Name : " + display.getName();
         unitInfo += "\nLevel: " + display.getLevel();
         unitInfo += "\nAttack: " + display.getAttack();
         unitInfo += "\nDefense: " + display.getDefense();
         unitInfo += "\nRange: " + display.getRange();
         unitInfo += "\nHealth: " + display.getHealth() + "/" + (5 * display.getStamina());
         unitInfo += "\nAction points: " + display.getAP();
         unitInfo += "\nExp: " + display.getXP() + "/" + display.maxXP();
         unitInfo += "\n";
         unitInfo += "\n";
         if (display.hasPieceAttacked())
             unitInfo += "\nUnit is spent for \nthis turn";
         else if (display.hasPieceMoved())
             unitInfo += "\nUnit has moved \nbut can still attack";
         else
             unitInfo += "\nUnit can still move \nthis turn";
     }
 }
Esempio n. 6
0
        public void update()                    //gathers input, updates positions, and handles combat
        {
            //update inputs
            oldMouse = mouseState;
            mouseState = Mouse.GetState();
            oldKeyboardState = keyboardState;
            keyboardState = Keyboard.GetState();

            Rectangle endTurn = new Rectangle(918, 818, 268, 69);
            Rectangle toggleGrid = new Rectangle(1076, 70, 115, 20);
            Rectangle mouse = new Rectangle(mouseState.X, mouseState.Y, 1, 1);
            //TODO find unspent unit

            //click toggle grid button
            if (mouse.Intersects(toggleGrid) && mouseState.LeftButton == ButtonState.Pressed && oldMouse.LeftButton != ButtonState.Pressed)
                gridOn = !gridOn;

            if (controlState == ControlState.selectUnit)
            {
                //change scroll-over display based on mouse coordinates
                scrolledOver = mouseOverTile();
                //if click and scrolled over friendly unit set unit to selected and change state to choose option
                if (mouseState.LeftButton == ButtonState.Pressed)
                {
                    if (mouse.Intersects(endTurn) && oldMouse.LeftButton != ButtonState.Pressed)
                    {
                        //if end turn is clicked then refresh armies and switch players
                        controlState = ControlState.endTurn;
                    }
                    else
                    {
                        if (mouseState.X < 900 && mouseState.Y < 900 && scrolledOver != null && !scrolledOver.isEmpty())
                        {
                            if((scrolledOver.getResident().getFaction().Equals("RED") && isPlayer1Turn) || (scrolledOver.getResident().getFaction().Equals("BLUE") && !isPlayer1Turn))
                            {
                                if (!scrolledOver.getResident().hasPieceAttacked())
                                {
                                    selectedTile = scrolledOver;
                                    selectedUnit = scrolledOver.getResident();

                                    selectionTiles = map.getValidMoves();
                                    controlState = ControlState.chooseOption;
                                    //hide mouse
                                    mouseVisible = false;
                                }
                                else
                                    status = "Unit is spent for this turn";
                            }
                        }
                    }
                }
                if (keyboardState.IsKeyDown(Keys.K))            //test win screen
                {
                    status = "Nobody wins! YAY!";
                    controlState = ControlState.endGame;
                }

            }
            else if (controlState == ControlState.chooseOption)
            {
                //if keyboardState has a button pressed coressponding to the options then change state and show mouse TODO
                if (keyboardState.IsKeyDown(Keys.W) && !selectedUnit.hasPieceMoved())            //move
                {
                    mouseVisible = true;
                    selectionTiles = map.findValidMoves(selectedUnit);
                    controlState = ControlState.move;
                }
                else if (keyboardState.IsKeyDown(Keys.A) && !selectedUnit.hasPieceAttacked())       //attack
                {
                    mouseVisible = true;
                    currentAbility = new Attack(selectedUnit);
                    selectionTiles = map.checkRange(selectedTile, currentAbility, currentAbility.getRange(), selectedUnit);
                    //if no targets in range status "says so" and don't change state
                    controlState = ControlState.selectTarget;
                }
                else if (keyboardState.IsKeyDown(Keys.T))       //end turn
                {
                    //selectedUnit.move();
                    selectedUnit.attack();                      //TODO
                    mouseVisible = true;
                    controlState = ControlState.selectUnit;
                }
                else if (keyboardState.IsKeyDown(Keys.Space) && !oldKeyboardState.IsKeyDown(Keys.Space))
                {
                    mouseVisible = true;
                    controlState = ControlState.selectUnit;
                }
                //space = cancel, go back to selectUnit
            }
            else if (controlState == ControlState.move)
            {
                //change scroll-over display based on mouse coordinates
                scrolledOver = mouseOverTile();
                //if click and mouse XY corresponds to valid tile then move unit and return to chooseoption TODO
                if (selectionTiles.Contains(mouseOverTile()) && mouseState.LeftButton == ButtonState.Pressed)
                {
                    map.movePiece(selectedTile, scrolledOver, selectedUnit);
                    selectedTile = scrolledOver;
                    selectedUnit.move();
                    status = selectedUnit.getName() + " has moved.";
                    mouseVisible = false;
                    controlState = ControlState.chooseOption;
                }
                else if (keyboardState.IsKeyDown(Keys.Space) && !oldKeyboardState.IsKeyDown(Keys.Space))
                {
                    mouseVisible = false;
                    controlState = ControlState.chooseOption;
                }
                //space = cancel, go back to chooseOption
            }
            else if (controlState == ControlState.selectTarget)
            {
                //change scroll-over display based on mouse coordinates
                scrolledOver = mouseOverTile();
                
                //if click and tile is in target list than initiate combat between selected unit and target, show mouse, return to select unit TODO
                if (mouseState.LeftButton == ButtonState.Pressed)
                {
                    //if scrolled over tile is within targetTiles then initiate combat
                    if(selectionTiles.Contains(scrolledOver))
                    {
                        //change status to combat result string
                        status = currentAbility.execute(selectedUnit, scrolledOver.getResident());
                        selectedUnit.attack();
                        //remove dead units
                        if (selectedUnit.getHealth() < 1)
                            selectedTile.removePiece();
                        if (scrolledOver.getResident().getHealth() < 1)
                            scrolledOver.removePiece();
                        controlState = ControlState.selectUnit;
                        //status = "attack";
                    }
                }
                else if (keyboardState.IsKeyDown(Keys.Space) && !oldKeyboardState.IsKeyDown(Keys.Space))
                {
                    currentAbility = null;
                    mouseVisible = false;
                    controlState = ControlState.chooseOption;
                }
                //space = cancel, go back to chooseOption
            }
            else if (controlState == ControlState.endTurn)
            {
                if (keyboardState.IsKeyDown(Keys.Y))
                {
                    refreshArmy();
                    isPlayer1Turn = !isPlayer1Turn;
                    //refreshArmy();
                    status = "Turn ended, next player's turn begins";
                    controlState = ControlState.selectUnit;
                }
                else if (keyboardState.IsKeyDown(Keys.Space))
                {
                    controlState = ControlState.selectUnit;
                }
            }
            else if(controlState == ControlState.endGame)
            {

                //continue
                if (keyboardState.IsKeyDown(Keys.Space))
                {
                   endBattle();
                }
            }

            if (isArmyDead(player1Army))
            {
                status = "Blue Player 2 Wins!";
            }
            else if (isArmyDead(player2Army))
            {
                status = "Red Player 1 Wins!";
            }
        }
Esempio n. 7
0
        /// <summary>
        /// LoadContent will be called once per game and is the place to load
        /// all of your content.
        /// </summary>
        protected override void LoadContent()
        {
            // Create a new SpriteBatch, which can be used to draw textures.
            spriteBatch = new SpriteBatch(GraphicsDevice);
            army1 = new List<Piece>();
            army2 = new List<Piece>();

            //Load the screen backgrounds
            mTitleScreenBackground = Content.Load<Texture2D>("Menu/TitleScreen");

            //Music
            musicTitle = Content.Load<Song>("Music/Title");

            //Play the Intro Song
            MediaPlayer.Play(musicTitle);
            /*
                army1.Add( new Pikeman("RED", Content));
                army2.Add(new Pikeman("BLUE", Content));

                army1.Add(new Knight("RED", Content));
                army2.Add( new Knight("BLUE", Content));

                army1.Add(new Swordsman("RED", Content));
                army2.Add(new Swordsman("BLUE", Content));

                army1.Add(new Archer("RED", Content));
                army2.Add(new Archer("BLUE", Content));

                army1.Add(new Nomad("RED", Content));
                army2.Add(new Nomad("BLUE", Content));

                army1.Add(new Mage("RED", Content));
                army2.Add(new Mage("BLUE", Content));

                army1.Add(new Zealot("RED", Content));
                army2.Add(new Zealot("BLUE", Content));
            */

            Tile[,] mm = new Tile[30,30];
            for (int i = 0; i < 30; i++)
                for (int j = 0; j < 30; j++)
                    mm[i,j] = new Tile("Plain", i, j);

            map = new TacMap(mm, Content);
            map.randomMap();

            battle = new TacticalBattle(army1, army2, map, Content);
            manager = new ArmyManagment(Content, army1, army2);

            // TODO: use this.Content to load your game content here
        }
Esempio n. 8
0
 public void addTile(Tile tile, int xCoor, int yCoor)
 {
     // places tile in the given coordinates
     map[xCoor][yCoor] = tile;
 }
Esempio n. 9
0
 public TacMap(Tile[][] map, ContentManager content)
 {
     this.map = map;
     //validMoves = new List<Tile>();
     //TODO load all unit sprites and terrain sprites and effects sprites for drawing
 }
Esempio n. 10
0
        private void findMoves(Tile location, int ap, Piece piece)
        {
            int remainingPoints = ap;
            List<Tile> neighbors = getNeighbors(location, new List<Tile>());

            for (int i = 0; i < neighbors.Count; i++)
            {
                Tile tile = neighbors[i];
                int cost;
                if (tile.getTerrain().Equals("Plain"))
                {
                    cost = 1;
                }
                else if (tile.getTerrain().Equals("Woods"))
                {
                    cost = 2;
                }
                else if (tile.getTerrain().Equals("Mountain"))
                {
                    cost = 4;
                }
                else
                {
                    cost = 999;
                }
                if (remainingPoints >= cost && !piece.validMoves.Contains(neighbors[i]))
                {
                    if (neighbors[i].isEmpty())
                    {
                        piece.validMoves.Add(neighbors[i]);
                        findMoves(neighbors[i], remainingPoints - cost, piece);
                        return;
                    }
                    else
                    {
                        if (neighbors[i].getResident().getFaction().Equals(piece.getFaction()))
                        {
                            findMoves(neighbors[i], remainingPoints - cost, piece);
                            return;
                        }
                        else
                        {
                            return;
                        }
                    }
                }
                else
                {
                    return;
                }
            }
        }
Esempio n. 11
0
        public void randomMap()
        {
            //constructs a randomly generated map
            //start by setting every tile to be plains
            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    map[i][j] = new Tile("Plain", i, j);
                }
            }
            //determine how many types of terrain will be on the map
            Random r = new Random();
            int typesOfTerrain = r.Next(2) + 1;

            bool water = false;
            bool mountain = false;
            bool woods = false;
            //now figure out which of these should be true

            if (typesOfTerrain == 1 || typesOfTerrain == 2)
            {
                int n = r.Next(2);
                //0 = water
                //1 = mountain
                //2 = woods
                if (typesOfTerrain == 1)
                {
                    if (n == 0)
                        water = true;
                    else if (n == 1)
                        mountain = true;
                    else if (n == 2)
                        woods = true;
                }
                if (typesOfTerrain == 2)
                {
                    if (n == 0)
                    {
                        mountain = true;
                        woods = true;
                    }
                    else if (n == 1)
                    {
                        water = true;
                        woods = true;
                    }
                    else if (n == 2)
                    {
                        water = true;
                        mountain = true;
                    }
                }
            }

            if (water)
            {
                //up to 25 tiles can be water
                int numberOfWater = r.Next(25) + 1;
                int n = 0;
                while (n < numberOfWater)
                {
                    //pick a random tile, and if the tile is plains, change into water
                    int x = r.Next(width);
                    int y = r.Next(width);
                    if (map[x][y].getTerrain().Equals("Plain"))
                    {
                        map[x][y] = new Tile("Water", x, y);
                        n++;
                    }
                }
            }

            if (mountain)
            {
                //up to 20 tiles can be mountains
                //mountains shouldn't block off an entire section of the map
                int numberOfMountains = _r.Next(25) + 1;
                int n = 0;
                while (n < numberOfMountains)
                {
                    //pick a random tile, and if the tile is plains, change into mountains
                    int x = r.Next(width);
                    int y = r.Next(width);
                    if (map[x][y].getTerrain().Equals("Plain"))
                    {
                        map[x][y] = new Tile("Mountain", x, y);
                        n++;
                    }
                }
            }

            if (woods)
            {
                //up to 40 tiles can be woods
                //woods can go anywhere
                int numberOfWoods = r.Next(40) + 1;
                int n = 0;
                while (n < numberOfWoods)
                {
                    //pick a random tile, and if the tile is plains, change into woods
                    int x = r.Next(width);
                    int y = r.Next(width);
                    if (map[x][y].getTerrain().Equals("Plain"))
                    {
                        map[x][y] = new Tile("Woods", x, y);
                        n++;
                    }
                }
            }
        }
Esempio n. 12
0
        public String movePiece(Tile origin, Tile destination, Piece piece)
        {
            if (piece.validMoves.Contains(destination))
            {
                origin.removePiece();
                origin.enterPiece(piece);
                // promptAbility();
                piece.move();
                piece.validMoves = null;
                return piece.getName() + " has moved";

            }
            else
                return "invalid location";
        }
Esempio n. 13
0
 public bool isNeighbor(Tile tile1, Tile tile2)
 {
     //returns true if the given tiles are neighbors
     //two tiles are neighbors if either their xCoords or yCoords are one apart (but not both)
     int xCoord1 = tile1.getXCoord();
     int yCoord1 = tile1.getYCoord();
     int xCoord2 = tile2.getXCoord();
     int yCoord2 = tile2.getYCoord();
     if (Math.Abs(xCoord1 - xCoord2) == 1 && (yCoord1 - yCoord2 == 0))
     {
         return true;
     }
     else if (Math.Abs(yCoord1 - yCoord2) == 1 && (xCoord1 - xCoord2 == 0))
     {
         return true;
     }
     else
     {
         return false;
     }
 }
Esempio n. 14
0
        private void findMoves(Tile location, int ap, Piece piece)
        {
            int remainingPoints = ap;
            List<Tile> neighbors = getNeighbors(location, new List<Tile>());

            for (int i = 0; i < neighbors.Count; i++)
            {
                Tile tile = neighbors[i];
                int cost;
                if (tile.getTerrain().Equals("Plain"))
                {
                    cost = 1;
                }
                else if (tile.getTerrain().Equals("Woods"))
                {
                    cost = 2;
                }
                else if (tile.getTerrain().Equals("Mountain"))
                {
                    cost = 4;
                }
                else
                {
                    cost = 999;
                }
                //If there is sufficient ap
                if (remainingPoints >= cost)
                {
                    //If the tile is empty it is added to the list and another call made
                    if (neighbors[i].isEmpty())
                    {
                        //if validMoves does not already hold the tile
                        if (!validMoves.Contains(neighbors[i]))
                        {
                            validMoves.Add(neighbors[i]);
                        }
                        findMoves(neighbors[i], remainingPoints - cost, piece);
                    }
                    else
                    {
                        //if the tile is occupied BUT is occupied by a friendly another call is made but the tile is not added, the tile is not a valid move
                        //but the search still "paths" through it
                        if (neighbors[i].getResident().getFaction().Equals(piece.getFaction()))
                        {
                            findMoves(neighbors[i], remainingPoints - cost, piece);
                        }
                    }
                }
            }
        }
Esempio n. 15
0
        public void randomMap()
        {
            //constructs a randomly generated map
            //start by setting every tile to be plains
            for (int i = 0; i < width; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    map[i, j] = new Tile("Plain", i, j);
                }
            }
            //determine how many types of terrain will be on the map
            Random _r = new Random();

            //woods
            int ir = 5 + _r.Next(16);
            for (int i = 0; i < ir; i++)
            {
                int x = _r.Next(30);
                int y = _r.Next(30);

                int jr = _r.Next(12);
                int kr = _r.Next(12);
                for (int j = 0; j < jr; j++)
                {
                    //int kr = _r.Next(12);
                    for (int k = 0; k < kr; k++)
                    {
                        if (_r.Next(8) != 0 && x+j < 30 && y+k <30)
                        {
                            map[x + j, y + k] = new Tile("Woods", x + j, y + k);
                        }
                    }
                }
            }

            //Mountains
            ir = 3 + _r.Next(5);
            for (int i = 0; i < ir; i++)
            {
                int x = _r.Next(30);
                int y = _r.Next(30);

                int jr = _r.Next(7);
                int kr = _r.Next(7);
                for (int j = 0; j < jr; j++)
                {
                    //int kr = _r.Next(7);
                    for (int k = 0; k < kr; k++)
                    {
                        if (_r.Next(10) != 0 && x + j < 30 && y + k < 30)
                        {
                            map[x + j, y + k] = new Tile("Mountain", x + j, y + k);
                        }
                    }
                }
            }

            //water
            ir = 1 + _r.Next(2);
            for (int i = 0; i < ir; i++)
            {
                int x = _r.Next(11) + 7;
                int y = _r.Next(11) + 7;

                int jr = _r.Next(9);
                int kr = _r.Next(9);
                for (int j = 0; j < jr; j++)
                {
                    //int kr = _r.Next(9);
                    for (int k = 0; k < kr; k++)
                    {
                        if (_r.Next(20) != 0 && x + j < 30 && y + k < 30)
                        {
                            map[x + j, y + k] = new Tile("Water", x + j, y + k);
                        }
                    }
                }
            }

            for (int i = 0; i < 5; i++)
            {
                for (int j = 0; j < 5; j++)
                {
                    map[i, j] = new Tile("Plain", i, j);
                }
            }

            for (int i = 24; i < 30; i++)
            {
                for (int j = 24; j < 30; j++)
                {
                    map[i, j] = new Tile("Plain", i, j);
                }
            }
        }
Esempio n. 16
0
        public void findTargets(Tile location, int range, Piece piece)
        {
            int remainingRange = range;
            List<Tile> neighbors = getNeighbors(location, new List<Tile>());

            for (int i = 0; i < neighbors.Count; i++)
            {
                //If there is sufficient ap and validMoves does not already hold that tile
                if (remainingRange >= 1 && !validTargets.Contains(neighbors[i]))
                {
                    //If the tile is empty it is not added to the list and another call made
                    if (neighbors[i].isEmpty())
                    {
                        //validTargets.Add(neighbors[i]);
                        findTargets(neighbors[i], remainingRange - 1, piece);
                    }
                    else
                    {
                        //if the tile is occupied BUT is occupied by a friendly another call is made but the tile is not added, the tile is not a valid target
                        //but the search still "paths" through it
                        if (neighbors[i].getResident().getFaction().Equals(piece.getFaction()))
                        {
                            findTargets(neighbors[i], remainingRange - 1, piece);
                        }
                        //if the tile is occupied by an enemy faction, add it to validTargets
                        else
                        {
                            validTargets.Add(neighbors[i]);
                            findTargets(neighbors[i], remainingRange - 1, piece);
                        }
                    }
                }
            }
        }