/// <summary> /// Simulates infection of a neighboring LivingUnit. Only LivingUnits to the left, right, /// top, and bottom of the Virus. Only infects a single neighbor. /// </summary> /// <param name="grid">The grid of Units.</param> private void Infect(Unit[,] grid) { // Iterate through each of the directions (left, right, top, bottom) foreach (var dir in GridHelper.directions) { // Calculate the row and column of the neighbor int newRow = Location.r + dir.Item1; int newCol = Location.c + dir.Item2; // Check if the neighbor is within the grid if (!grid.InGridBounds(newRow, newCol)) { // Try a different direction continue; } // Otherwise, get the neighbor Unit neighbor = grid[newRow, newCol]; // Check if there is a non-null LivingUnit in the block // Infects a unit even if it is already infected if (neighbor != null && neighbor is LivingUnit) { // Infect the neighbor (neighbor as LivingUnit).BeInfected(); // Do not infect any other neighbors break; } } }
public GamePlay(ContentManager contentManager) { //cManager.RootDirectory = "Content"; //Console.WriteLine("Content Manager root directory: "+cManager.RootDirectory.ToString()); //paddle = cManager.Load<Texture2D>(cManager.RootDirectory+"/GameAssets/breakout_paddle"); //entityList = new List<Entities.BaseEntity>(); currentKeyboardState = Keyboard.GetState(); previousKeyboardState = currentKeyboardState; currentMouseState = Mouse.GetState(); previousMouseState = Mouse.GetState(); RoughnessPosition = new Vector2(); RoughnessPosition.X = 100; RoughnessPosition.Y = 20; WaterTexture = contentManager.Load<Texture2D>("res/art/terrain/water_block"); GrassTexture = contentManager.Load<Texture2D>("res/art/terrain/grass_block"); MountainTexture = contentManager.Load<Texture2D>("res/art/terrain/mountain_block"); kootenayFont = contentManager.Load<SpriteFont>("res/fonts/kootenay"); _terrain = new Terrain("res/art/terrain/grass_block", _boxWidth, _boxHeight, Game1._DEFAULT_SCREEN_WIDTH, Game1._DEFAULT_SCREEN_HEIGHT, GrassTexture, WaterTexture, MountainTexture); _terrain.GenerateNewMap(); _unitMap = new Unit[_terrain.ArrayWidth, _terrain.ArrayHeight]; GenerateNewUnitMap(); LoadContent(contentManager); }
public void Create(FightCtllerView ctl, FightGrid grid) { m_ctller = ctl; m_fight_grid = grid; Vector2 min = new Vector2(float.MaxValue, float.MaxValue); Vector2 max = new Vector2(float.MinValue, float.MinValue); m_units = new Unit[FightGrid.UnitCount.Y, FightGrid.UnitCount.X]; for (int y = 0; y < FightGrid.UnitCount.Y; ++y) { for (int x = 0; x < FightGrid.UnitCount.X; ++x) { GameObject obj_unit = ResMgr.Instance.CreateGameObject("Fight/GridUnit", gameObject); obj_unit.transform.localPosition = grid.Units[y, x].Position * Launcher.SpriteScale; FightGridUnitView uv = obj_unit.GetComponent<FightGridUnitView>(); uv.Create(this, grid.Units[y, x]); m_units[y, x] = new Unit(new Int2D(x, y), uv); min.x = Mathf.Min(min.x, grid.Units[y, x].Position.x - FightGrid.UnitSize / 2); min.y = Mathf.Min(min.y, grid.Units[y, x].Position.y - FightGrid.UnitSize / 2); max.x = Mathf.Max(max.x, grid.Units[y, x].Position.x + FightGrid.UnitSize / 2); max.y = Mathf.Max(max.y, grid.Units[y, x].Position.y + FightGrid.UnitSize / 2); } } min *= Launcher.SpriteScale; max *= Launcher.SpriteScale; BoxCollider cld = gameObject.AddComponent<BoxCollider>(); cld.center = min + (max - min) / 2; cld.size = (max - min); m_fight_grid.OnAddCreature += OnAddCreature; }
public GamePlay(ContentManager contentManager) { //cManager.RootDirectory = "Content"; //Console.WriteLine("Content Manager root directory: "+cManager.RootDirectory.ToString()); //paddle = cManager.Load<Texture2D>(cManager.RootDirectory+"/GameAssets/breakout_paddle"); //entityList = new List<Entities.BaseEntity>(); currentKeyboardState = Keyboard.GetState(); previousKeyboardState = currentKeyboardState; currentMouseState = Mouse.GetState(); previousMouseState = Mouse.GetState(); RoughnessPosition = new Vector2(); RoughnessPosition.X = 100; RoughnessPosition.Y = 20; WaterTexture = contentManager.Load <Texture2D>("res/art/terrain/water_block"); GrassTexture = contentManager.Load <Texture2D>("res/art/terrain/grass_block"); MountainTexture = contentManager.Load <Texture2D>("res/art/terrain/mountain_block"); kootenayFont = contentManager.Load <SpriteFont>("res/fonts/kootenay"); _terrain = new Terrain("res/art/terrain/grass_block", _boxWidth, _boxHeight, Game1._DEFAULT_SCREEN_WIDTH, Game1._DEFAULT_SCREEN_HEIGHT, GrassTexture, WaterTexture, MountainTexture); _terrain.GenerateNewMap(); _unitMap = new Unit[_terrain.ArrayWidth, _terrain.ArrayHeight]; GenerateNewUnitMap(); LoadContent(contentManager); }
public PlayerControlManager(int xSize, int ySize, Unit[,] units, Explosive[,] explosions) { this.xSize = xSize; this.ySize = ySize; this.units = units; this.explosions = explosions; }
TileObject[,] tiles; //change to basetile? void Awake() { int gridSize = GameObject.Find("Managers").GetComponent <GridManager>().gridSize; tiles = new TileObject[gridSize, gridSize]; units = new Unit[gridSize, gridSize]; }
public static void update_OneUnitCoord_onTable(Unit u, Unit[,] table) { int coordX = u.CurrentColumn; int coordY = u.CurrentRow; table [coordX, coordY] = u; }
private void ChangeInVariation(Variation variation, Unit[,] newFillArray, bool state) { foreach (var item in variation.VariationPoints) { newFillArray[(int)item.X, (int)item.Y].IsInVariation = state; } }
public Navigator(World world) { _world = world; _map = new Unit[world.Size.X, world.Size.Y]; _foodMap = new FoodItem[world.Size.X, world.Size.Y]; _individualsMap = new Individual[world.Size.X, world.Size.Y]; }
public void InitializeGridFromLocalData(int sideLength) { SideLength = sideLength; Rows = Columns = SideLength; Units = GetNewEmptyGrid(); UnitCounter = 0; Data.MaxValue = SideLength - 1; Data.CurrentLayout = Data.layouts[SideLength]; Data.Score = GameManager.CurrentLocalData.LastScores[SideLength - 3]; State = GridState.Game; CanUndo = false; CreateUnitsFromState(GameManager.CurrentLocalData.GridState[SideLength - 3]); LastUnitsState = new int[Rows, Columns]; LastLastUnitsState = new int[Rows, Columns]; drawer.SetGridImageBySize(SideLength); Wait.ForFrames(Drawer.TimingsConfig.framesBeforeDrawingUnits, () => { StartCoroutine(DrawUnitsWithDelay()); }); GameManager.UpdateScoreText(); }
//Атака компьютера по человеку public static Point AutoAttack(ref Unit[,] matrix_state) { Random rnd = new Random(); Point tmp = new Point(0, 0); // создаем темповую точку, для того, чтобы менять ее, если вдруг точка не пустая int x = 0, y = 0; // Координаты x,y для матрицы bool flag = true; // Для вызода из цикла while (flag) //Не выходим изцикла пока что не найдем точку с морем { x = rnd.Next(0, 10); Thread.Sleep(10);//Задержка, чтобы рандом был рандомным y = rnd.Next(0, 10); if (matrix_state[x, y].Get_Unit_Type() == unit_type.sea) //Сравниваем тип ячейки входной матрицы с типом моря //И если всё хорошо, то выходим из цикла и в темповую переменную кидаем эту точку { flag = false; tmp = new Point(x, y); matrix_state[x, y].Set_Unit_Type(unit_type.hit_sea); } } Point result = tmp; return(result); }
/// <summary> /// Computes the state of a given "block" in the grid in the new generation /// given the grid and the block. /// </summary> /// <remarks> /// Uses row and column instead of Unit since the focus is on /// the location of the Unit, not its parameters. /// </remarks> /// <param name="grid">The grid in which the block to compute is.</param> /// <param name="row">The row (within the grid) of the block to update.</param> /// <param name="col">The column (within the grid) of the block to update.</param> /// <returns>The new Unit that should occupy the block in this new generation. Null if no unit /// should occupy the block.</returns> public static Unit NewBlockState(Unit[,] grid, int row, int col) { // The current Unit in the block to update Unit thisUnit = grid[row, col]; int allNeighbors = CountAllNeighbors(grid, row, col); // Check if the current block is empty if (thisUnit == null) { // Check if a new unit should be born (which happens only // if the block has exactly 3 neighbours) if (allNeighbors == OVER_POP) { // Birth the new unit return(NewbornUnit(grid, row, col)); } } // Check if the Unit is a Virus if (!(thisUnit is LivingUnit)) { // Update the Virus with separate Virus-oriented computations return(NewVirusState(grid, row, col)); } // Otherwise, the Unit is a living unit else { // Update the LivingUnit with separate LivingUnit-oriented computations return(NewLivingState(grid, row, col)); } }
/// <summary> /// Returns the number of non-null Unit neighbors, either all Virus or all LivingUnit, /// of the block at (row, col). /// </summary> /// <remarks> /// Reusable method for both Virus counting and LivingUnit counting. /// </remarks> /// <param name="grid">Grid to use for counting neighbors.</param> /// <param name="row">Row (within the grid) of the block whose neighbors are counted.</param> /// <param name="col">Column (within the grid) of the block whose neighbors are counted.</param> /// <param name="countViral">Whether to count Viruses as neighbors (in which case LivingUnit /// neighbors are not counted), or not count them as neighbors (in which case only LivingUnit /// neighbors are counted).</param> /// <returns>The number of non-null Virus neighbors if "countViral" is true, or the number /// of non-null LivingUnit neighbors if "countViral" is false. Neighbors are in the Moore neighborhood.</returns> private static int NumberOfNeighbors(Unit[,] grid, int row, int col, bool countViral) { // Will store the number of neighbors int neighbors = 0; // Iterate through the Moore neighborhood // Iterate row by row, starting from the row above the block and ending at the row // below the block. for (int i = row - 1; i <= row + 1; i++) { // Iterate column by column, starting from the column to the left of the block // and ending at the column to the right of the block. for (int j = col - 1; j <= col + 1; j++) { // Check if the current block is not the original block at (row, col), // that it is inside the grid bounds, and that the Unit stored in the block is not null if ((i != row || j != col) && grid.InGridBounds(i, j) && grid[i, j] != null) { // Count the current neighbor only if Viruses should be counted and the neighbor is // not a LivingUnit, or if Viruses should not be counted and the neighbour is a LivingUnit neighbors += (!countViral == grid[i, j] is LivingUnit ? 1 : 0); } } } // Return the number of neighbors corresponding to the criterion of Virus counting or not counting return(neighbors); }
/// <summary> /// Gets a list of all the non-null Unit neighbors of a block in the grid. /// </summary> /// <param name="grid">Grid to use for finding neighbors.</param> /// <param name="row">Row (within the grid) of the block whose neighbors are found.</param> /// <param name="col">Column (within the grid) of the block whose neighbors are found.</param> /// <returns>A List of non-null Units which are neighbors of the block at (row, col).</returns> private static List <Unit> GetAllNeighbors(Unit[,] grid, int row, int col) { // List that will store all the neighbors List <Unit> neighbors = new List <Unit>(); // Iterate through the Moore neighborhood // Iterate row by row, starting from the row above the block and ending at the row // below the block. for (int i = row - 1; i <= row + 1; i++) { // Iterate column by column, starting from the column to the left of the block // and ending at the column to the right of the block. for (int j = col - 1; j <= col + 1; j++) { // Check if the current block is not the original block at (row, col), // that it is inside the grid bounds, and that the Unit stored in the block is not null if ((i != row || j != col) && grid.InGridBounds(i, j) && grid[i, j] != null) { // Store this neighbor neighbors.Add(grid[i, j]); } } } // Return all the neighbors return(neighbors); }
public Terrain() { MapWidth = Config.GetInstance().iMapDefaultWidth - 1; MapHeight = Config.GetInstance().iMapDefaultHeight - 1; MinHeight = Config.GetInstance().minheight; MaxHeight = Config.GetInstance().maxheight; Map = new double[HeightMapWidth, HeightMapHeight]; FeatureMap = new Unit[MapWidth, MapHeight]; InitMap(MinHeight); LogFile.GetInstance().WriteLine("HeightMap() " + HeightMapWidth + " " + HeightMapHeight); texturestages = new List <MapTextureStage>(); texturestages.Add(new MapTextureStage()); //texturestages = Sm3Persistence.GetInstance().LoadTextureStages(TdfParser.FromFile("maps/Whakamatunga_Riri.sm3").RootSection.SubSection("map/terrain")); //Sm3Persistence.GetInstance().LoadHeightMap(TdfParser.FromFile("maps/Whakamatunga_Riri.sm3").RootSection.SubSection("map/terrain")); renderableheightmap = new RenderableHeightMap(this, Map, SquareSize, SquareSize, texturestages); renderableallfeatures = new RenderableAllFeatures(this); // water must be last, otherwise you cant see through it ;-) renderablewater = new RenderableWater(new Vector3(), new Vector2(HeightMapWidth * SquareSize, HeightMapHeight * SquareSize)); // minimap last, covers everything else renderableminimap = new RenderableMinimap(this, renderableheightmap); //OnTerrainModified(); }
/// <summary> /// Gets the number of neighbors of the same type as this Multicellular /// in a 5x5 square centered on the organism. /// </summary> /// <param name="grid"></param> /// <returns> an integer representing the number of neighbours of the same species that this unit has </returns> protected int NumberOfSameSpeciesNeighbors(Unit[,] grid) { // Create a counter to store the number of same species neighbours int numNeighbors = 0; // Compute the boundaries of the area to check for same species neighbours int rowLowerBound = Math.Max(0, Location.r - EXTENDED_NEIGHBORHOOD_SIZE / 2), colLowerBound = Math.Max(0, Location.c - EXTENDED_NEIGHBORHOOD_SIZE / 2); int rowUpperBound = Math.Min(grid.GetLength(GridHelper.ROW), Location.r + EXTENDED_NEIGHBORHOOD_SIZE / 2 + 1), colUpperBound = Math.Min(grid.GetLength(GridHelper.COLUMN), Location.c + EXTENDED_NEIGHBORHOOD_SIZE / 2 + 1); // Loop through all rows in the area to be checked to check each grid cell for (int i = rowLowerBound; i < rowUpperBound; i++) { // Loop through all columns in the area to be checked to check each grid cell for (int j = colLowerBound; j < colUpperBound; j++) { // Check if the current grid cell is in the grid and holds a unit if (grid.InGridBounds(i, j) && grid[i, j] != null) { // Increase the number of same species neighbour in the community // only if the type of the unit in the current grid cell matches the type of the current unit numNeighbors += grid[i, j].GetType() == this.GetType() ? 1 : 0; } } } // Return the number of same species neighbours in the area surrounding this unit return(numNeighbors); }
public Grid(int cellsNum, int cellSize) { CellsNum = cellsNum; CellSize = cellSize; _cells = new Unit[CellsNum, CellsNum]; Clear(); }
public Grid(int dimension) { int result = dimension * dimension; wholeGrid = new Unit[result, result]; this.dimension = dimension; }
/// <summary> /// Calculate the score of the current grid, adding it to the state's cumulative score /// and checking if the game is over /// </summary> /// <returns> The score of the current grid in the simulation </returns> public int CalculateScore() { // get the current grid of units in the simulation Unit[,] grid = currentState.UnitGrid; //keeps track of the board's current score int gridScore = 0; //loop through the entire grid for (int j = 0; j < grid.GetLength(GridHelper.ROW); j++) { for (int k = 0; k < grid.GetLength(GridHelper.COLUMN); k++) { //check if block is a virus or not a cell - if so, add the block's species complexity to the total if (!(grid[j, k] is Virus) && grid[j, k] != null) { //add the product of the unit's species complexity and age, or just the species complexity if they are new, to the grid score gridScore += Math.Max((grid[j, k] as LivingUnit).SpeciesComplexity * (grid[j, k] as LivingUnit).Age, (grid[j, k] as LivingUnit).SpeciesComplexity); } } } // if the current score of the board is higher than the highest recorded concurrent score, it becomes the new highest concurrent score if (gridScore > HighestConcurrentScore) { HighestConcurrentScore = gridScore; } // add the score of the board to the tracker of the current board's score CurrentScore += gridScore; return(gridScore); }
/// <summary> /// Start a new game, refresh all the data /// </summary> public void NewGame() { ClearGame(); boardUnit = new Unit[BoardInfo.Row, BoardInfo.Col]; boardBread = new Unit[BoardInfo.Row, BoardInfo.Col]; boardState = new GridState[BoardInfo.Row, BoardInfo.Col]; playerInfo = new Dictionary <Unit.TypeEnum, int>[2] { new Dictionary <Unit.TypeEnum, int>(), new Dictionary <Unit.TypeEnum, int>() }; for (int r = 0; r < BoardInfo.Row; r++) { for (int c = 0; c < BoardInfo.Col; c++) { boardState[r, c] = GridState.Void; } } boardState[BoardInfo.Base[0].R, BoardInfo.Base[0].C] = GridState.Base0; boardState[BoardInfo.Base[1].R, BoardInfo.Base[1].C] = GridState.Base1; foreach (Position pos in BoardInfo.BreadList) { CreateUnit(new UnitInfo(pos, Unit.TypeEnum.Bread)); } restBreadNum = BoardInfo.BreadList.Length; foreach (UnitInfo info in BoardInfo.InitUnitList) { CreateUnit(info); } }
/// <summary> /// Splits up the Colony into 4 cells in a 2x2 square. Called when there is insufficient /// food for the Colony. /// </summary> /// <remarks> /// This is meant to be a rare event. /// Author: Rudy Ariaz /// </remarks> /// <param name="grid">The grid in which the Colony is.</param> /// <param name="gameEnv">The Environment of the Colony.</param> public void SplitUp(Unit[,] grid, Environment gameEnv) { // Get the row and column of the Colony int row = Location.r, col = Location.c; /* * Try splitting in each direction, in this order: * Cell is in the top left corner * Cell is in the bottom left corner * Cell is in the top right corner * Cell is in the bottom right corner */ // Iterate through the different directions of vertical splitting for (int rowDir = 1; rowDir >= -1; rowDir -= 2) { // Iterate through the different directions of horizontal splitting for (int colDir = 1; colDir >= -1; colDir -= 2) { // Check if the split is possible in this direction if (IsSplitPossible(grid, rowDir, colDir)) { // Kill the exisitng Colony this.Die(grid, gameEnv); // Spread the new Cells out in the current direction grid[row, col] = new Cell(row, col); grid[row, col + colDir] = new Cell(row, col + colDir); grid[row + rowDir, col] = new Cell(row + rowDir, col); grid[row + rowDir, col + colDir] = new Cell(row + rowDir, col + colDir); // Stop searching for valid splitting directions break; } } } }
/// <summary> /// Rollback the board to cached state. /// </summary> public void RollbackGame(GameCache cache) { ClearGame(); boardUnit = new Unit[BoardInfo.Row, BoardInfo.Col]; boardBread = new Unit[BoardInfo.Row, BoardInfo.Col]; boardState = new GridState[BoardInfo.Row, BoardInfo.Col]; playerInfo = new Dictionary <Unit.TypeEnum, int>[2] { new Dictionary <Unit.TypeEnum, int>(), new Dictionary <Unit.TypeEnum, int>() }; restBreadNum = 0; for (int i = 0; i < BoardInfo.Row; i++) { for (int j = 0; j < BoardInfo.Col; j++) { boardState[i, j] = cache.descriptor.GetGridState(i, j); if (boardState[i, j] == GridState.Bread) { CreateUnit(new UnitInfo(new Position(i, j), Unit.TypeEnum.Bread)); } var unitInfo = cache.descriptor.GetUnitInfo(i, j); if (unitInfo.type >= Unit.TypeEnum.Scout && unitInfo.type <= Unit.TypeEnum.Bomb) { CreateUnit(unitInfo); } } } for (Unit.TypeEnum type = Unit.TypeEnum.Bread; type < Unit.TypeEnum.Void; type++) { playerInfo[(int)Unit.OwnerEnum.Black][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.Black); playerInfo[(int)Unit.OwnerEnum.White][type] = cache.descriptor.GetPlayerInfo(type, Unit.OwnerEnum.White); } restBreadNum = cache.descriptor.RestResource; SwitchTurn(cache.descriptor.Turn); }
/// <summary> /// Merges the current Cell with the 3 other Cells in a 2x2 block with this Cell as the top left /// </summary> /// <param name="grid"> The grid of Units currently in the simulation </param> /// <param name="row"> The row of the grid that this Cell resides in </param> /// <param name="col"> The column of the grid that this Cell resides in </param> protected override void Merge(Unit[,] grid, Environment gameEnv) { KillMergedUnits(grid, gameEnv); // Replace the current Cell with a newly created Colony grid[Location.r, Location.c] = UnitFactory.CreateUnit(Enums.UnitType.Colony, Location.r, Location.c); }
/// <summary> /// Checks if the MergeableUnit is in a position to merge (into a Colony if it /// is a cell, or into a Plant or Animal if it is a Colony). /// </summary> /// <param name="grid"> The grid of Units currently in the simulation </param> /// <param name="row"> The row of the grid that this MergeableUnit resides in. </param> /// <param name="col"> The column of the grid that this MergeableUnit resides in. </param> /// <returns> True if the MergeableUnit is the top left of a 2x2 square with other /// MergeableUnits of the same species and should merge, false otherwise. </returns> protected bool ShouldMerge(Unit[,] grid) { // Get the type of this unit -- must merge with units of the same species var curType = this.GetType(); // Get the location of the current unit int row = Location.r, col = Location.c; // if the cell is not in a space capable of forming a 2x2 square, it cannot merge if (!grid.InDimension(GridHelper.ROW, row + 1) || !grid.InDimension(GridHelper.COLUMN, col + 1)) { return(false); } // otherwise, if the surrounding 3 grids cells are of the same type, this unit should merge else if (grid[row, col + 1]?.GetType() == curType && grid[row + 1, col]?.GetType() == curType && grid[row + 1, col + 1]?.GetType() == curType) { return(true); } // otherwise, this unit does not meet the locational requirements to evolve else { return(false); } }
public Grid(int width, int height) { width = Math.Max(1, width); height = Math.Max(1, height); data = new Unit[width, height]; }
enum tags { city, grass, mount, road, water };// enum-ed tags to allow random determination of terrain tile // Constructors public Gameboard(Game1 game1) { game = game1;//store game reference //grid shits, need to do unit grid- fill with "empty" units upperIndex = new Vector2(cols, rows); offsetIndex = new Vector2(); terrainGrid = new Terrain[cols, rows]; unitGrid = new Unit[cols, rows]; Terrain current = new Terrain(); current.Size = unitSize; defaultTex = game1.Content.Load <Texture2D>("outline"); current.Texture = defaultTex; System.Random rand = new System.Random(); for (int i = 0; i < cols; i++) { for (int j = 0; j < rows; j++) { current.Y = j * unitSize; current.X = i * unitSize; terrainGrid[i, j] = new Terrain(); terrainGrid[i, j].Position = current.Position; terrainGrid[i, j].Tag = "outline"; // in case something fails and a tag cannot be generated tags myTag = (tags)rand.Next(0, 5); // this is temporary code terrainGrid[i, j].Tag = myTag.ToString(); // the tag of the tile needs to be known by this point!! figure out some sort of level loading terrainGrid[i, j].Texture = game1.Content.Load <Texture2D>(terrainGrid[i, j].Tag); } } }
/// <summary> /// Updates an Animal with all operations that must be applied to the Animal every generation. /// </summary> /// <remarks> /// Called every generation. /// </remarks> /// <remarks> /// Author: Rudy Ariaz /// </remarks> /// <param name="grid">The grid of Units in which the Animal is.</param> /// <param name="gameEnv">The Environment with which the Animal interacts.</param> public override void Update(Unit[,] grid, Environment gameEnv) { // Apply the benefits that a Multicellular organism receives based on being in the vicinity of other // multicellular organisms ApplyCommunityBenefits(grid); // Perform basic operations needed for all LivingUnits UpdateLivingUnit(grid, gameEnv); // Check if the animal is hibernating if (IsHibernating) { // Reduce the number of generations left for hibernation HibernationGenerationsLeft--; // Try to wake up from hibernation (if there are no hibernation generations left) TryWake(); } // Otherwise, apply the usual Animal operations else { // Check if the animal is starving, try to eat a plant if (IsStarving(gameEnv)) { // Try to eat a Plant CheckPlantsToEat(grid, gameEnv); } // Check if the Unit should and can thermoregulate if (ShouldThermoregulate(gameEnv) && CanThermoregulate(gameEnv)) { // Thermoregulate if needed Thermoregulate(gameEnv); } } }
/// <summary> /// Checks for Plants to eat (which are in direct contact with the Animal, so /// diagonal Plants are not included). Eats a Plant if a valid one is found (only one Plant can be eaten). /// </summary> /// <remarks> /// Author: Rudy Ariaz /// </remarks> /// <param name="grid">The Grid to use for finding Plants.</param> /// <param name="gameEnv">The Environment with which the Unit interacts.</param> private void CheckPlantsToEat(Unit[,] grid, Environment gameEnv) { // Get the row and column of the Animal int row = Location.r, col = Location.c; // Iterate through each of the directions (up, down, left, right) foreach (var dir in GridHelper.directions) { // Compute the new row and column of the grid block being checked int newRow = row + dir.Item1; int newCol = col + dir.Item2; // If the block is not within the grid, try a different direction if (!grid.InGridBounds(newRow, newCol)) { continue; } // Otherwise, get the neighbor in the block Unit neighbor = grid[newRow, newCol]; // Check if the neighbor is a non-null Plant if (neighbor != null && neighbor is Plant) { // Eat the Plant EatPlant(grid, gameEnv, (Plant)neighbor); // Stop looking for Plants break; } } }
/// <summary> /// Initialize the board controller /// </summary> public void Start() { this.Cells = new CellController[(this.GridSize * 2) + 1, (this.GridSize * 2) + 1]; this.Units = new Unit[(this.GridSize * 2) + 1, (this.GridSize * 2) + 1]; for (int i = -1 * this.GridSize; i <= this.GridSize; i++) { for (int j = -1 * this.GridSize; j <= this.GridSize; j++) { if (HexDistance.Distance(0, 0, i, j) <= this.GridSize) { float x = i; if (Math.Abs(j) % 2 == 1) { x = i + 0.5f; } var hex = (CellController)Instantiate(this.HexCellPrefab); hex.transform.position = new Vector3(x * this.XScale, this.YPosition, j * this.ZScale); CellCoordinate cellCoord = WorldToGameConverter.ConvertWorldToCell(hex.transform.position, this.ZScale); hex.gameObject.name = "(" + cellCoord.X + ", " + cellCoord.Y + ")"; this.SetCell(cellCoord.X, cellCoord.Y, hex); CellController cellController = hex.GetComponent <CellController>(); cellController.BoardController = this; cellController.Coordinate = cellCoord; } } } }
void GetNeighbours(Unit[,] table, int i, int j) { if (table[i, j] != Unit.Mine) { var neighbourmines = 0; for (int k = i - 1; k <= i + 1; k++) { for (int l = j - 1; l <= j + 1; l++) { try { if (table[k, l] == Unit.Mine) { neighbourmines++; } } catch (Exception e) { } } } table[i, j] = GetNumber(neighbourmines); } //table[i,j] = Unit.Mine; }
public void InitializeTable(int column, int row) { if (!firstStepDone) { firstStepDone = true; table = new Unit[rows, columns]; for (int i = 0; i < rows; i++) { for (int j = 0; j < columns; j++) { table[i, j] = Unit.Free; } } var rnd = new Random(); var minesLeft = mines; while (minesLeft > 0) { int mineX; int mineY; do { mineX = rnd.Next(0, columns); mineY = rnd.Next(0, rows); }while ((mineX == column && mineY == row) || table[mineX, mineY] == Unit.Mine); table[mineX, mineY] = Unit.Mine; minesLeft--; } SetNumbers(table); } }
/// <summary> /// Assumes playerUnits and enemyUnits are already initialized (non-null). /// </summary> /// <param name="board"></param> /// <param name="tiles"></param> /// <param name="playerUnits"></param> /// <param name="enemyUnits"></param> public Game( Unit[,] board, Tile[,] tiles, List <Unit> playerUnits, List <Unit> enemyUnits) { allUnits = new List <Unit>(); this.board = board; this.tiles = tiles; this.playerUnits = playerUnits; this.enemyUnits = enemyUnits; foreach (Unit unit in playerUnits) { allUnits.Add(unit); unit.team = Teams.Player; } foreach (Unit unit in enemyUnits) { allUnits.Add(unit); unit.team = Teams.Enemy; } foreach (Unit unit in allUnits) { unit.board = board; unit.tiles = tiles; } }
public Engine(int mapWidth, int mapHeight) { currentTick = 0; futureUpdates = new Dictionary<int, List<Unit>>(); map = new EngineMap(this, mapWidth, mapHeight); unitTypes = new List<UnitType>(); tileTypes = new List<TileType>(); players = new List<Player>(); units = new List<Unit>(); unitGrid = new Unit[map.width, map.height]; unitQuadtrees = new Dictionary<Player, Quadtree>(); idCounter = 0; map.Initialize(); List<Position> goldTiles = new List<Position>(); List<Position> ironTiles = new List<Position>(); List<Position> manaTiles = new List<Position>(); ai1 = new AI(this, null, goldTiles, ironTiles, manaTiles); ai2 = new AI(this, null, goldTiles, ironTiles, manaTiles); }
/// <summary> /// Start a new game, refresh all the data /// </summary> public void NewGame() { ClearGame(); boardUnit = new Unit[BoardInfo.Row, BoardInfo.Col]; boardBread = new Unit[BoardInfo.Row, BoardInfo.Col]; boardState = new GridState[BoardInfo.Row, BoardInfo.Col]; playerInfo = new Dictionary<Unit.TypeEnum, int>[2]{new Dictionary<Unit.TypeEnum, int>(), new Dictionary<Unit.TypeEnum, int>()}; for (int r = 0; r < BoardInfo.Row; r++) for (int c = 0; c < BoardInfo.Col; c++) boardState[r, c] = GridState.Void; boardState[BoardInfo.Base[0].R, BoardInfo.Base[0].C] = GridState.Base0; boardState[BoardInfo.Base[1].R, BoardInfo.Base[1].C] = GridState.Base1; foreach(Position pos in BoardInfo.BreadList) CreateUnit(new UnitInfo(pos, Unit.TypeEnum.Bread)); restBreadNum = BoardInfo.BreadList.Length; foreach (UnitInfo info in BoardInfo.InitUnitList) CreateUnit(info); }
public void Create(FightCtller ctl, DirType dir) { m_dir = dir; m_ctller = ctl; m_units = new Unit[UnitCount.Y, UnitCount.X]; for (int y = 0; y < Units.GetLength(0); ++y) { for (int x = 0; x < Units.GetLength(1); ++x) { m_units[y, x] = new Unit(new Int2D(x, y), null); m_units[y, x].Position = CalcUnitPosition(m_units[y, x].Index, dir); } } }
void Awake() { Cells = new Unit[Width, Height]; _gridCollider = GetComponent<BoxCollider>(); _gc = GameController.Get(); CreateGrid(); }