public void SetUp()
 {
     _testBoard = new Board();
     _testPlayer = new Player();
     _village = new Settlement(_testPlayer, SettlementType.Village);
     _city = new Settlement(_testPlayer, SettlementType.City);
     _road = new Road(_testPlayer);
 }
예제 #2
0
        public void TestCityHasTwoPoints()
        {
            var city = new Settlement(_player1, SettlementType.City);
            (_board.Vertices[0]).Settlement = city;

            _controller.ScorePlayers();

            Assert.AreEqual(2, _player1.Score);
            Assert.AreEqual(0, _player2.Score);
            Assert.AreEqual(0, _player3.Score);
            Assert.AreEqual(0, _player4.Score);
        }
예제 #3
0
        public void TestVillageHasOnePoint()
        {
            var village = new Settlement(_player1, SettlementType.Village);
            (_board.Vertices[0]).Settlement = village;

            _controller.ScorePlayers();

            Assert.AreEqual(1, _player1.Score);
            Assert.AreEqual(0, _player2.Score);
            Assert.AreEqual(0, _player3.Score);
            Assert.AreEqual(0, _player4.Score);
        }
예제 #4
0
        public void TestVillageAndCityHasThreePoints()
        {
            var village = new Settlement(_player1, SettlementType.Village);
            var city = new Settlement(_player1, SettlementType.City);
            (_board.Vertices[0]).Settlement = village;
            (_board.Vertices[1]).Settlement = city;

            _controller.ScorePlayers();

            Assert.AreEqual(3, _player1.Score);
            Assert.AreEqual(0, _player2.Score);
            Assert.AreEqual(0, _player3.Score);
            Assert.AreEqual(0, _player4.Score);
        }
예제 #5
0
 public void addTradeLocation(Settlement s)
 {
     this.validTradeLocations.Add(s);
 }
예제 #6
0
        private void OnVertexClick(object sender, EventArgs e)
        {
            var currentPlayer = _gameController.CurrentPlayer;
            ButtonWithVertex curVertex;
            Pen pen;
            Road road;
            Settlement piece;
            switch(_context)
            {
                case Context.None:
                    break;
                case Context.PlaceCity:
                    var settlement = new Settlement(currentPlayer, SettlementType.City);

                    try
                    {
                        _board.PlacePiece(settlement,
                                          ((ButtonWithVertex) sender)._vertex.Index);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            Resources.settlementPlacementError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    currentPlayer.Buy(settlement);

                    ((Button) sender).BackColor = currentPlayer.GetDrawColor();
                    ((Button) sender).Text = Resources.C;

                    _context = Context.None;
                    break;
                case Context.RoadBuildingFirstVertex:
                case Context.PlaceRoadFirstVertex:
                    _roadFirstVertex = sender as ButtonWithVertex;
                    _vertexOriginalColor = _roadFirstVertex.BackColor;
                    _roadFirstVertex.BackColor = Color.Yellow;

                    if (_context == Context.PlaceRoadFirstVertex)
                    {
                        _context = Context.PlaceRoadSecondVertex;
                    } else
                    {
                        _context = Context.RoadBuildingSecondVertex;
                    }
                    break;

                case Context.RoadBuildingSecondVertex:
                case Context.PlaceRoadSecondVertex:

                    curVertex = sender as ButtonWithVertex;

                    if (!curVertex._vertex.Neighbors.Contains(_roadFirstVertex._vertex))
                    {
                        MessageBox.Show(
                            Resources.neighboringVertexError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    if (curVertex._vertex.HasRoad(_roadFirstVertex._vertex))
                    {
                        MessageBox.Show(
                            Resources.roadExistsError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    _roadFirstVertex.BackColor = _vertexOriginalColor;

                    road = new Road(currentPlayer);

                    try
                    {
                        _board.PlacePiece(road, curVertex._vertex, _roadFirstVertex._vertex);
                    } catch (Exception ex)
                    {
                        MessageBox.Show(
                            Resources.roadPlacementError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    if (_context == Context.PlaceRoadSecondVertex)
                    {
                        currentPlayer.Buy(road);
                    }

                    pen = new Pen(currentPlayer.GetDrawColor(), 10);
                    CreateGraphics().DrawLine(pen, curVertex.Location.X + 10, curVertex.Location.Y + 10, _roadFirstVertex.Location.X + 10, _roadFirstVertex.Location.Y + 10);

                    if (_context == Context.PlaceRoadSecondVertex || _roadBuildingFirst)
                    {
                        _roadBuildingFirst = false;
                        _context = Context.None;
                    } else
                    {
                        _roadBuildingFirst = true;
                        _context = Context.RoadBuildingFirstVertex;
                    }
                    break;

                case Context.PlaceVillage:
                    piece = new Settlement(currentPlayer, SettlementType.Village);

                    try
                    {
                        _board.PlacePiece(piece, ((ButtonWithVertex)sender)._vertex.Index);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            Resources.settlementPlacementError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    currentPlayer.Buy(piece);

                    ((Button) sender).BackColor = currentPlayer.GetDrawColor();
                    ((Button) sender).Text = Resources.V;

                    _context = Context.None;
                    break;

                 case Context.Trade:
                    _context = Context.None;
                    break;

                case Context.PlaceVillageSetup:
                    piece = new Settlement(currentPlayer, SettlementType.Village);

                    try
                    {
                        _board.PlacePieceSetup(piece, ((ButtonWithVertex)sender)._vertex.Index);
                    }
                    catch (Exception ex)
                    {
                        MessageBox.Show(
                            Resources.settlementPlacementError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    ((Button) sender).BackColor = currentPlayer.GetDrawColor();
                    ((Button) sender).Text = Resources.V;

                    _roadFirstVertex = sender as ButtonWithVertex;

                    _context = Context.PlaceRoadSetup;
                    GameSetup();
                    break;

                case Context.PlaceRoadSetup:
                    curVertex = sender as ButtonWithVertex;

                    if (!curVertex._vertex.Neighbors.Contains(_roadFirstVertex._vertex))
                    {
                        MessageBox.Show(
                            Resources.neighboringVertexError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    if (curVertex._vertex.HasRoad(_roadFirstVertex._vertex))
                    {
                        MessageBox.Show(
                            Resources.roadExistsError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    road = new Road(currentPlayer);

                    try
                    {
                        _board.PlacePieceSetup(road, curVertex._vertex, _roadFirstVertex._vertex);
                    } catch (Exception ex)
                    {
                        MessageBox.Show(
                            Resources.roadPlacementError,
                            Resources.invalidLocation,
                            MessageBoxButtons.OK,
                            MessageBoxIcon.Exclamation,
                            MessageBoxDefaultButton.Button1);
                        return;
                    }

                    pen = new Pen(currentPlayer.GetDrawColor(), 10);
                    CreateGraphics().DrawLine(pen, curVertex.Location.X + 10, curVertex.Location.Y + 10, _roadFirstVertex.Location.X + 10, _roadFirstVertex.Location.Y + 10);

                    _context = Context.PlaceVillageSetup;
                    NextPlayerSetup();
                    GameSetup();
                    break;

                default:
                    break;
            }
        }
예제 #7
0
 public void addSettlement(Settlement s)
 {
     this.settlements.Add(s);
 }
예제 #8
0
        /*
         *  Creates the data structures used for the board's tiles.
         */
        public void distributeTiles()
        {
            //Sets up the terrain tiles deck
            terrainTiles = new Deck(19);
            foreach (Board.ResourceType r in fourPlayerTiles)
            {
                terrainTiles.putCard(new TerrainTile(pnlBoardArea, r, this.tileImages[(int)r]));
            }

            terrainTiles.shuffleDeck();

            //Set up the number chip deck. (can be randomized, however, the default is to keep the correct order).
            numberChips = new Deck(18);
            foreach (int num in fourPlayerNumberChips)
            {
                numberChips.putCard(new NumberChip(num));
            }

            /*
             *  If random number chip order is marked, randomize the number chips deck.
             * Replace x with proper condition *
             *  if (x) {
             *      numberChips.shuffleDeck();
             *  }
             */

            int row    = 0;
            int column = 0;

            //This creates and positions each tile in the world.
            for (int i = 0; i < BOARD_TILE_COUNT; i++)
            {
                int numSettlementSpots = 2; //By default each tile creates 2 settlement spots

                //This checks for the end of a row on specific indices for correct row breaks.
                if (i == 4 || i == 9 || i == 15 || i == 22 || i == 28 || i == 33)
                {
                    row   += 1;
                    column = 0;
                    //We need to create 3 settlement spots
                }
                //Shift is used to keep track of the row offsets for the correct "meshing" of the tiles.
                int shift = 0;
                //This checks for every other row and applies a half tile shift if it is an odd numbered row.
                if (row % 2 != 0)
                {
                    shift += SPACING / 2;
                }
                //This shifts the specified row indices by whole tiles for the correct look.
                switch (row)
                {
                case 0:
                    shift += SPACING * 2;
                    break;

                case 1:
                    shift += SPACING * 1;
                    break;

                case 2:
                    shift += SPACING * 1;
                    break;

                case 4:
                    shift += SPACING * 1;
                    break;

                case 5:
                    shift += SPACING * 1;
                    //We need to create even more settlement spots (+4)
                    numSettlementSpots++;
                    //if (i==)
                    break;

                case 6:
                    shift += SPACING * 2;
                    break;
                }

                //Determine if this tile is an ocean border.
                bool ocean = false;
                for (int f = 0; f < oceanBorderIndsFourPlayer.Length; f++)
                {
                    if (i == oceanBorderIndsFourPlayer[f])
                    {
                        ocean = true;
                    }
                }

                Point position = new Point(column * SPACING + shift, row * (SPACING - TILE_TRIANGLE_HEIGHT));

                if (!ocean)
                {
                    TerrainTile tile = (TerrainTile)terrainTiles.drawTopCard();
                    tile.setPosition(position);
                    tile.index    = i;
                    boardTiles[i] = tile;
                    if (tile.getResourceType() == ResourceType.Desert)
                    {
                        //Create a number chip with a value of 0
                        tile.setNumberChip(new NumberChip(0));
                        tile.placeThief();
                    }
                    else
                    {
                        //Get the next number chip in line.
                        tile.setNumberChip((NumberChip)numberChips.drawTopCard());
                    }
                }
                else
                {
                    OceanBorderTile tile = new OceanBorderTile(pnlBoardArea);
                    tile.setPosition(position);
                    tile.index    = i;
                    boardTiles[i] = tile;
                }

                column++;

                /*
                 *  The following code block takes care of creating, linking, and positioning each settlement and road for the game.
                 *  This ensures there are no duplicate locations.
                 *
                 */
                if (!ocean)
                {
                    TerrainTile t = (TerrainTile)boardTiles[i];
                    //Default placement is the top left and top center locations of the tile.
                    //This covers almost all settlement locations.

                    Point[] settlementPoints = new Point[6];
                    //A list of positions for each possible settlement location on this tile. The order matters greatly. (In a clockwise direction)
                    settlementPoints[0] = new Point(position.X, position.Y + TILE_TRIANGLE_HEIGHT);
                    settlementPoints[1] = new Point(position.X + (SPACING / 2), position.Y);
                    settlementPoints[2] = new Point(position.X + SPACING, position.Y + TILE_TRIANGLE_HEIGHT);
                    settlementPoints[3] = new Point(position.X + SPACING, position.Y + SPACING - TILE_TRIANGLE_HEIGHT);
                    settlementPoints[4] = new Point(position.X + (SPACING / 2), position.Y + SPACING);
                    settlementPoints[5] = new Point(position.X, position.Y + SPACING - TILE_TRIANGLE_HEIGHT);

                    foreach (Point setPoint in settlementPoints)
                    {
                        //We check if this settlement location has already been created.
                        Settlement settlementLocation = findSettlementWithPosition(setPoint);
                        //If not already created we need to make a new location
                        if (settlementLocation == null)
                        {
                            settlementLocation    = new Settlement(setPoint, 0);
                            settlementLocation.id = settlementLocations.Count;
                            settlementLocations.Add(settlementLocation);
                            pnlBoardArea.Controls.Add(settlementLocation);
                            settlementLocation.BringToFront();
                        }
                        t.adjascentSettlements.Add(settlementLocation);
                    }


                    //This is almost an exact duplicate of the above process. The only difference being the positions.
                    Point[] roadPoints = new Point[6];
                    roadPoints[0] = new Point(position.X, position.Y + (SPACING / 2));                                              //V
                    roadPoints[1] = new Point(position.X + (SPACING / 4), position.Y + (TILE_TRIANGLE_HEIGHT / 2));                 //H L
                    roadPoints[2] = new Point(position.X + (SPACING / 4) * 3, position.Y + (TILE_TRIANGLE_HEIGHT / 2));             // H R
                    roadPoints[3] = new Point(position.X + SPACING, position.Y + (SPACING / 2));                                    //V
                    roadPoints[4] = new Point(position.X + (SPACING / 4) * 3, position.Y + (SPACING - (TILE_TRIANGLE_HEIGHT / 2))); //H R
                    roadPoints[5] = new Point(position.X + (SPACING / 4), position.Y + (SPACING - (TILE_TRIANGLE_HEIGHT / 2)));     //H L
                    int f = 0;
                    foreach (Point roadPoint in roadPoints)
                    {
                        //We check if this settlement location has already been created.
                        Road roadLocation = findRoadWithPosition(roadPoint);
                        if (roadLocation == null)
                        {
                            roadLocation = new Road(roadPoint, 0);
                            pnlBoardArea.Controls.Add(roadLocation);
                            roadLocation.id = roadLocations.Count;
                            roadLocations.Add(roadLocation);
                            roadLocation.BringToFront();
                            roadLocation.BackgroundImage = new Bitmap(roadImageLocations[f]);
                            roadLocation.Size            = roadLocation.BackgroundImage.Size;
                            roadLocation.Location        = new Point(roadPoint.X - (roadLocation.BackgroundImage.Width / 2), roadPoint.Y - (roadLocation.BackgroundImage.Height / 2));
                        }
                        t.adjascentRoads.Add(roadLocation);
                        f++;
                    }

                    //Next we link the roads and settlements together.
                    //We know the order in which the roads and settlements were created in, so all we need to do is link them in that order.
                    for (int index = 0; index < 6; index++)
                    {
                        t.adjascentRoads[index].linkSettlement(t.adjascentSettlements[index]);
                        //Link settlement to road
                        if (index == 0)
                        {
                            t.adjascentRoads[index].linkSettlement(t.adjascentSettlements[5]);
                        }
                        else
                        {
                            t.adjascentRoads[index].linkSettlement(t.adjascentSettlements[index - 1]);
                        }
                        //Link road to settlement
                        t.adjascentSettlements[index].linkRoad(t.adjascentRoads[index]);
                        if (index == 5)
                        {
                            t.adjascentSettlements[index].linkRoad(t.adjascentRoads[0]);
                        }
                        else
                        {
                            t.adjascentSettlements[index].linkRoad(t.adjascentRoads[index + 1]);
                        }
                    }
                }
            }

            //Position each of the harbors
            for (int i = 0; i < FourPlayerHarborLocations.Count(); i++)
            {
                //Create a new harbor using the information from the trade at harborCount location

                OceanBorderTile bt = (OceanBorderTile)this.boardTiles[FourPlayerHarborLocations[i]];
                Harbor          h  = new Harbor(FourPlayerHarborRequiredResources[i], FourPlayerHarborOutputResources[i]);
                //MessageBox.Show("Resources/" + FourPlayerHarborResourceNames[harborCount]);
                h.BackgroundImage = new Bitmap("Resources/" + FourPlayerHarborResourceNames[i]);
                h.Location        = new Point(0, TILE_TRIANGLE_HEIGHT);
                harbors.Add(h);
                bt.setHarbor(h);
                bt.Controls.Add(h);

                //Set the settlements that will be able to use this harbor
                Point position = bt.getPosition();

                Point[] settlementPoints = new Point[6];
                //A list of positions for each possible settlement location on this ocean border
                settlementPoints[0] = new Point(position.X, position.Y + TILE_TRIANGLE_HEIGHT);
                settlementPoints[1] = new Point(position.X + (SPACING / 2), position.Y);
                settlementPoints[2] = new Point(position.X + SPACING, position.Y + TILE_TRIANGLE_HEIGHT);
                settlementPoints[3] = new Point(position.X + SPACING, position.Y + SPACING - TILE_TRIANGLE_HEIGHT);
                settlementPoints[4] = new Point(position.X + (SPACING / 2), position.Y + SPACING);
                settlementPoints[5] = new Point(position.X, position.Y + SPACING - TILE_TRIANGLE_HEIGHT);
                //Look through the list of points to see if any of these positions match exisiting settlement locations
                foreach (Point p in settlementPoints)
                {
                    Settlement set = findSettlementWithPosition(p);
                    if (set != null)
                    {
                        //We have found a valid trade location
                        bt.getHarbor().addTradeLocation(set);
                    }
                }
            }

            foreach (Settlement set in settlementLocations)
            {
                var adjTiles = boardTiles
                               .OfType <TerrainTile>()
                               .Where(x => x.adjascentSettlements.Contains(set));
                set.adjacentTiles.AddRange(adjTiles);
            }

            debugSaveBoardData();
        }