コード例 #1
0
        public void Init()
        {
            myLogger = LoggerFactory.GetLogger();

            randomer = new Random(SEED);
            tileMatrix = new Tile[randomer.Next(WorldGenerator.MINIMUM_MAP_SIZE,
                WorldGenerator.MAXIMUM_MAP_SIZE)][];

            width = randomer.Next(WorldGenerator.MINIMUM_MAP_SIZE,
                    WorldGenerator.MAXIMUM_MAP_SIZE);

            myLogger.Trace("Test map consists of " + tileMatrix.Length +
                " times " + width + " tiles.");

            for (int i = 0; i < tileMatrix.Length; i++)
            {
                tileMatrix[i] = new Tile[width];
            }

            for (int i = 0; i < tileMatrix.Length; i++)
            {
                for (int j = 0; j < width; j++)
                {
                    tileMatrix[i][j] = RandomTile();
                }

            }
        }
コード例 #2
0
 /// <summary>
 /// Constructor of the game world. Creates an empty list of players
 /// as well as an empty matrix of the given dimensions.
 /// </summary>
 /// <param name="rows">Number of rows in the map of the world</param>
 /// <param name="cols">Number of columns in the map of the world</param>
 public World(Tile[,] map, int seed)
 {
     myLogger = LoggerFactory.GetLogger();
     players = new List<Player>();
     this.seed = seed;
     SetMap(map);
     this.lookingAt = Point.Zero;
     this.units = new HashSet<Unit>();
 }
コード例 #3
0
 public void init()
 {
     t1 = new Tile(0,0);
     t2 = new Tile(1, 1, Globals.TerrainTypes.Slow);
     p = new Player();
     u1 = new Unit(p, Vector2.Zero);
     u2 = new Unit(p, Vector2.Zero);
     u3 = new Unit(p, Vector2.Zero);
     b1 = new BaseBuilding("test", 0, 0, new Player(), new LinkedList<Tile>());
     b2 = new BarrierBuilding("TestBuilding1", 1, 1, p, b1, new LinkedList<Tile>());
 }
コード例 #4
0
 /// <summary>
 /// Set a tile in the world. Invokes the MapEvent event. Will throw 
 /// IndexOutOfRangeException if placement of a tile was attempted outside
 /// the range of the map.
 /// </summary>
 /// <param name="row">The row in which the tile will be set (index 0).</param>
 /// <param name="col">The column in which the tile will be set (index 0).</param>
 /// <param name="t">Tile tile to be set.</param>
 public void SetTile(int x, int y, Tile t)
 {
     if (x < width || y < height)
     {
         throw new IndexOutOfRangeException("Attempted to set a tile outside the range of the map.");
     }
     map[x, y] = t;
     if (TileEvent != null)
     {
         TileEvent(this, new Event<Tile>(t, EventType.REMOVE));
     }
 }
コード例 #5
0
 /// <summary>
 /// Constructs a new Map model from a matrix of tiles.
 /// </summary>
 /// <param name="map">The matrix of tiles that will form the map</param>
 public Map(Tile[,] map)
 {
     this.map = map;
     this.width = map.GetLength(0);
     this.height = map.GetLength(1);
 }
コード例 #6
0
 /// <summary>
 /// Sets the game map to a specific Tile-matrix. Dimensions are required.
 /// Invokes two EMapEvents.
 /// </summary>
 /// <param name="map">The Tilematrix to be the new map</param>
 /// <param name="rows">The number of rows in the new map</param>
 /// <param name="cols">The number of columns in the new map</param>
 public void SetMap(Tile[,] map)
 {
     ClearMap();
     this.map = new Map(map);
     if (MapEvent!=null)
     {
         MapEvent(this, new Event<Map>(this.map, EventType.ADD));
     }
 }
コード例 #7
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="player"></param>
        public static void ConstructBuilding(Player player, Tile constructTile, Building sourceBuilding, World theWorld)
        {
            logger.Trace("Constructing a building for a player");
            //TODO Somehow present a menu to the player, and then
            //use the information to ADD (not the document) the fromBuilding.

            MenuIcon baseCell = new MenuIcon(Language.Instance.GetString("BaseCell") +
                    " (" + player.unitAcc.CalculateBuildingCostInflation(Globals.BuildingTypes.Base)+")",
                    Recellection.textureMap.GetTexture(Globals.TextureTypes.BaseBuilding), Color.Black);

            MenuIcon resourceCell = new MenuIcon(Language.Instance.GetString("ResourceCell") +
                    " (" + player.unitAcc.CalculateBuildingCostInflation(Globals.BuildingTypes.Resource) + ")",
                    Recellection.textureMap.GetTexture(Globals.TextureTypes.ResourceBuilding), Color.Black);

            MenuIcon defensiveCell = new MenuIcon(Language.Instance.GetString("DefensiveCell") +
                    " (" + player.unitAcc.CalculateBuildingCostInflation(Globals.BuildingTypes.Barrier) + ")",
                    Recellection.textureMap.GetTexture(Globals.TextureTypes.BarrierBuilding), Color.Black);

            MenuIcon aggressiveCell = new MenuIcon(Language.Instance.GetString("AggressiveCell") +
                    " (" + player.unitAcc.CalculateBuildingCostInflation(Globals.BuildingTypes.Aggressive) + ")",
                    Recellection.textureMap.GetTexture(Globals.TextureTypes.AggressiveBuilding), Color.Black);
            MenuIcon cancel = new MenuIcon(Language.Instance.GetString("Cancel"),
                    Recellection.textureMap.GetTexture(Globals.TextureTypes.No));
            List<MenuIcon> menuIcons = new List<MenuIcon>();
            menuIcons.Add(baseCell);
            menuIcons.Add(resourceCell);
            menuIcons.Add(defensiveCell);
            menuIcons.Add(aggressiveCell);
            menuIcons.Add(cancel);
            Menu ConstructBuildingMenu = new Menu(Globals.MenuLayout.NineMatrix, menuIcons, Language.Instance.GetString("ChooseBuilding"), Color.Black);
            MenuController.LoadMenu(ConstructBuildingMenu);
            Recellection.CurrentState = MenuView.Instance;
            Globals.BuildingTypes building;

            MenuIcon choosenMenu = MenuController.GetInput();
            Recellection.CurrentState = WorldView.Instance;
            MenuController.UnloadMenu();
            if (choosenMenu.Equals(baseCell))
            {
                building = Globals.BuildingTypes.Base;
            }
            else if (choosenMenu.Equals(resourceCell))
            {
                building = Globals.BuildingTypes.Resource;
            }
            else if (choosenMenu.Equals(defensiveCell))
            {
                building = Globals.BuildingTypes.Barrier;
            }
            else if (choosenMenu.Equals(aggressiveCell))
            {
                building = Globals.BuildingTypes.Aggressive;
            }
            else
            {
                return;
            }

            // If we have selected a tile, and we can place a building at the selected tile...
            try
            {
                if (!AddBuilding(building, sourceBuilding,
                        constructTile.position, theWorld, player))
                {
                    //SoundsController.playSound("Denied");
                }
            }
            catch (BuildingOutOfRangeException bore)
            {
                throw bore;
            }
        }
コード例 #8
0
 /// <summary>
 /// Checks whether or not there is a Resource Point on the given Tile.
 /// </summary>
 /// <param name="current"></param>
 /// <returns></returns>
 internal bool ContainsResourcePoint(Tile current)
 {
     if (current.GetTerrainType().GetEnum() == Globals.TerrainTypes.Mucus)
     {
         return true;
     }
     return false;
 }
コード例 #9
0
 /// <summary>
 /// Checks whether or not the given tile contains an enemy building.
 /// </summary>
 /// <param name="t"></param>
 /// <returns></returns>
 internal bool ContainsEnemyBuilding(Tile t)
 {
     if (t.GetBuilding() == null)
     {
         return false;
     }
     if (t.GetBuilding().GetOwner() != ai)
     {
         return true;
     }
     return false;
 }
コード例 #10
0
        private void SelectTile(Tile t)
        {
            // If this is the first time we select a tile...
            if (selectedTile != null)
                selectedTile.active = false;

            selectedTile = t;
            selectedTile.active = true;
        }
コード例 #11
0
        /// <summary>
        /// This is a recurisve method that each call creates a new tile for the 
        /// specific terrain type to spread. It will call itself until the number of
        /// tiles to spread is zero or less. The spread works by randomly choose
        /// a direction as seen futher down.
        /// </summary>
        /// <param name="tileMatrix"></param>
        /// <param name="xCoord"></param>
        /// <param name="yCoord"></param>
        /// <param name="numberOfTiles"></param>
        /// <param name="type"></param>
        /// <param name="randomer"></param>
        private static void SpreadTiles(Tile[,] tileMatrix, int xCoord,
            int yCoord, int numberOfTiles, Globals.TerrainTypes type,
            Random randomer)
        {
            tileMatrix[xCoord, yCoord] = new Tile(xCoord, yCoord, type);

            //X represents the adjecent tiles, O is the current tile
            //      X = 1
            //2 = X O X = 3
            //  4 = X
            //
            if (numberOfTiles<=0 || !(xCoord > 1 && xCoord < tileMatrix.GetLength(0)-1 && yCoord > 1 && yCoord < tileMatrix.GetLength(1)-1))
            {
                return;
            }
            switch (randomer.Next(4))
            {
                case 0:
                    SpreadTiles(tileMatrix, xCoord, yCoord - 1,
                        numberOfTiles - 1, type, randomer);
                    break;

                case 1:
                    SpreadTiles(tileMatrix, xCoord - 1, yCoord,
                        numberOfTiles - 1, type, randomer);
                    break;

                case 2:
                    SpreadTiles(tileMatrix, xCoord + 1, yCoord,
                        numberOfTiles - 1, type, randomer);
                    break;

                case 3:
                    SpreadTiles(tileMatrix, xCoord, yCoord + 1,
                        numberOfTiles - 1, type, randomer);
                    break;

            }
        }
コード例 #12
0
        private static void RandomPlaceResources(Random randomer, Tile[,] retur)
        {
            myLogger.Trace("Randomly placing resources.");
            int randomX;
            int randomY;

            int numberOfResourceTiles = 5;

            //Place five randomly placed resourceTiles, then
            for (int i = 0; i < numberOfResourceTiles; i++)
            {
                //Randomly choose a tile excluding all the edge tiles.
                randomY = randomer.Next((map_rows / 3), map_rows * 2 / 3);

                randomX = randomer.Next((map_cols / 3), map_cols * 2 / 3);

                retur[randomX, randomY] = new Tile(randomX, randomY, Globals.TerrainTypes.Mucus);
            }

            myLogger.Trace("Doop");
            for (int x = 0; x < 2; x++)
            {
                for (int y = 0; y < 2; y++)
                {
                    int minY = (map_rows / 5) + y * (map_rows * 2 / 3);
                    int minX = (map_cols / 5) + x * (map_cols * 2 / 3);

                    int maxY = (map_rows / 3) + map_rows * y - 2 - (map_rows / 3) * y;
                    int maxX = (map_cols / 3) + map_cols * x - 2 - (map_cols / 3) * x;
                    do
                    {
                        randomY = randomer.Next(minY, maxY);

                        randomX = randomer.Next(minX, maxX);
                    }//Make sure that the random coordinates are not on the base building spawn point.
                    while ((randomX == 5 || randomX == map_cols - 5) && (randomY == 5 || randomY == map_rows - 5));

                    retur[randomX, randomY] = new Tile(randomX, randomY, Globals.TerrainTypes.Mucus);
                }
            }
            myLogger.Trace("Finished placing resources");
        }
コード例 #13
0
        /// <summary>
        /// Initiates the tile matrix with default tiles for every tile
        /// </summary>
        /// <param name="randomer">The random generator used to generate the map.</param>
        /// <returns></returns>
        private static Tile[,] InitTileMatrix(Random randomer)
        {
            map_rows = randomer.Next(MINIMUM_MAP_SIZE, MAXIMUM_MAP_SIZE);

            map_cols = randomer.Next(MINIMUM_MAP_SIZE, MAXIMUM_MAP_SIZE);

            //Construct the matrix, the size is limited by MINIMUM and MAXIMUM
            Tile[,] retur = new Tile[map_cols, map_rows];

            myLogger.Info("Map consists of " + map_cols + " times "
                + map_rows + " tiles.");

            //Each row needs an array initiated each row needs to have
            //an array of equal size.
            for (int i = 0; i < map_cols; i++)
            {
                for (int j = 0; j < map_rows ; j++)
                {
                    retur[i, j] = new Tile(i, j);
                }

            }

            return retur;
        }
コード例 #14
0
        /// <summary>
        /// Move a set of units from one tile to another
        /// </summary>
        /// <param name="amount">The amount of units to be moved</param>
        /// <param name="from">The tile to move units from</param>
        /// <param name="to">Tile tile to move units to</param>
        public static void MoveUnits(Player player, Tile from, Tile to, int amount)
        {
            logger.SetThreshold(LogLevel.TRACE);

            bool fromBuilding = (from.GetBuilding() != null);
            bool toBuilding = (to.GetBuilding() != null);
            logger.Debug("Moving "+amount+" units from "+from+" to "+to);

            List<Unit> units;
            // If we are moving units from a fromBuilding, they might not
            // all be on the same tile
            if (fromBuilding)
            {
                units = from.GetBuilding().GetUnits();
                logger.Debug("Moving "+units.Count()+" ("+from.GetBuilding().CountUnits()+") units from a building.");
            }
            else
            {
                units = new List<Unit>(from.GetUnits(player));
                logger.Debug("Moving "+units.Count()+" from a tile!");
            }

            List<Unit> toBeRemovedFromBuilding = new List<Unit>();

            // Move some units from the targetted tile
            lock (units)
            {
                foreach (Unit u in units)
                {
                    if (amount <= 0)
                    {
                        break;
                    }

                    u.TargetEntity = null;
                    u.MissionEntity = to;
                    amount--;

                    if (u.IsAtBase())
                    {
                        logger.Trace("Unit is patrolling! Removing from rotation.");
                        toBeRemovedFromBuilding.Add(u);
                    }

                    if (toBuilding)
                    {
                        logger.Trace("Adding unit to patrol the 'to' building!");
                        u.TargetEntity = null;
                        u.MissionEntity = to.GetBuilding();
                    }
                }
            }

            // We don't want to remove units from a tile, as they do it themselves
            foreach(Unit u in toBeRemovedFromBuilding)
            {
                if (! (u.BaseEntity is Building))
                    continue;

                ((Building)u.BaseEntity).RemoveUnit(u);
            }
        }