public CellGridStateUnitSelected(CellGrid cellGrid, Unit unit) : base(cellGrid) { _unit = unit; _pathsInRange = new List<Cell>(); _unitsInRange = new List<Unit>(); }
public override void Play(CellGrid cellGrid) { cellGrid.CellGridState = new CellGridStateAiTurn(cellGrid); _cellGrid = cellGrid; StartCoroutine(Play()); //Coroutine is necessary to allow Unity to run updates on other objects (like UI). //Implementing this with threads would require a lot of modifications in other classes, as Unity API is not thread safe. }
void SelectCharacter(CellGrid cellGrid) { var unit = cellGrid.Units.FindAll(u => u.PlayerNumber.Equals(PlayerNumber)).FirstOrDefault(); if (unit != null) { manager.actualPlayer = unit.GetComponent<Actor>(); cameraController.target = unit.transform; } }
public Vector3 findPosition(CellGrid cellgrid, int gridSize) { int cellPosition = cellgrid.Cells.IndexOf(Cell); int i = cellPosition / gridSize; int j = (cellPosition % gridSize) / 2; if ((cellPosition % gridSize) % 2 != 0) { j += 1; } int k = (cellPosition % gridSize / 2); Vector3 vector = (new Vector3(i, j, k)); SimplifyHexVector3(ref vector); return(vector); }
public void BeforeEachTest() { Cell[,] cells = new Cell[GridSize, GridSize]; for (int column = 0; column < GridSize; column++) { for (int row = 0; row < GridSize; row++) { cells[column, row] = new Cell(CellState.Dead); } } gameCellGrid = new CellGrid(cells); game = new Game(gameCellGrid); }
// **TODO** Implémenter les dégâts supplémentaires au centre. public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellgrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); foreach (var receiver in receivers) { int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); caster.DealDamage2(receiver, damage); } caster.ActionPoints--; SetCooldown(); }
public void Initialize(CellGrid cellGrid, Canvas canvas) { if (!IsInitialized) { IsInitialized = true; Regions = new List <Region>(); this.cellGrid = cellGrid; SegmentGridByElevation(canvas); CalculateAllRegionPortals(); GenerateColliders(); } else { Debug.LogWarning("RegionManager.Initialize() has already been called!"); } }
// TODO: fix this entire region (temporary interface hack) // erase wall labels in all cells private void eraseLabels() { CellGrid grid = board.getGridRef(); for (uint r = 0; r < grid.rowcnt; r++) { for (uint c = 0; c < grid.colcnt; c++) { for (int l = 0; l < Cell.wcnt; l++) { board[r, c].lbl[l] = ""; board[r, c].lbltemp[l] = ""; } } } }
// iterate through available moves on given grid private bool iterateMove(ref CellGrid grid, ref Move m, uint attr, uint minPathlen) { // search for the next sensible move starting from the last move do { // get the next wall of the cell, in the following order: top -> lef -> bot -> rig // initially m.wall will result in Cell.none (because it has initial value Cell.none) do { m.wall = ((m.wall << 1) & Cell.all); }while ( // (attr & skipunsensible) == 0 && // if unsensible should be skipped, check all walls of a cell ((m.wall == Cell.bot && m.row != grid.rowcnt - 1) || // skip bot wall except if the cell is in the bottom row (m.wall == Cell.rig && m.col != grid.colcnt - 1))); // skip rig wall except if the cell is in the right column // if all walls of the cell were exausted, move to the next cell if (m.wall == Cell.none) { do { // move to the next cell if (++m.col >= grid.colcnt) // m.col will initially be 0 (because it has initial value uint.MaxValue) { m.col = 0; if (++m.row >= grid.rowcnt) { // m.row = 1000; //TEST m = null; // there are no moves left to play return(false); } } }while (grid[m.row, m.col].getWallCnt() == 4 || // skip cells having all walls ((attr & skip2) == skip2 && grid[m.row, m.col].getWallCnt() == 2)); // if required, skip cells having two walls // the first wall of the cell to check is at the top m.wall = Cell.top; } }while (grid[m.row, m.col].hasWall(m.wall) || // repeat the search until the chosen wall does not exist in the chosen cell, then try that move ((attr & skip2) == skip2 && // if cells already having two walls should be skipped, do so ((m.wall == Cell.lef && m.col > 0 && grid[m.row, m.col - 1].getWallCnt() == 2) || (m.wall == Cell.rig && m.col < grid.colcnt - 1 && grid[m.row, m.col + 1].getWallCnt() == 2) || (m.wall == Cell.top && m.row > 0 && grid[m.row - 1, m.col].getWallCnt() == 2) || (m.wall == Cell.bot && m.row < grid.rowcnt - 1 && grid[m.row + 1, m.col].getWallCnt() == 2))) || ((attr & skipunsafe) == skipunsafe && !grid.isMoveSafe(m.row, m.col, m.wall)) || ((attr & skipunsensible) == skipunsensible && !grid.isMoveSensible(m.row, m.col, m.wall, minPathlen))); return(true); }
public override void HandleCapture() { Unit[] units = GameObject.Find("Units Parent").GetComponentsInChildren <Unit>(); CellGrid grid = GameObject.Find("CellGrid").GetComponent <CellGrid>(); if (!Cell.IsTaken) { HitPoints = 20; return; } foreach (Unit u in units) { if (!(u is Building) && u.transform.position.x == this.transform.position.x && u.transform.position.y == this.transform.position.y) { if (u.canCapture && u.isAbleToCapture && u.PlayerNumber != this.PlayerNumber && grid.CurrentPlayerNumber == u.PlayerNumber) { int capValue = (u.HitPoints / 10) + 1; if (capValue > 10) { capValue = 10; } HitPoints -= capValue; StartCoroutine("DamageFlash"); if (HitPoints <= 0) { PlayerNumber = u.PlayerNumber; UpdateColor(); HitPoints = 20; faction = u.faction; } } else if (grid.CurrentPlayerNumber == u.PlayerNumber) { HitPoints = 20; if (u.PlayerNumber == this.PlayerNumber) { u.HitPoints += 20; u.UpdateHpBar(); } } return; } } HitPoints = 20; }
public void ReformatCellGrid(UInt16 newWidth, UInt16 newHeight, bool forceRedraw) { ONIPlannerSubControl[,] newGrid = new ONIPlannerSubControl[newWidth, newHeight]; if (newWidth == CellGrid.GetLength(0) && newHeight == CellGrid.GetLength(1)) { return; } if (CellGrid == null) { newGrid.Initialize(); } else { for (int x = 0; x < newWidth; x++) { for (int y = 0; y < newHeight; y++) { if (CellGrid.GetLength(0) > newWidth || CellGrid.GetLength(1) > newHeight) { newGrid[x, y] = new ONIPlannerSubControl(); } else { newGrid[x, y] = CellGrid[x, y]; } } } } CellGrid = newGrid; if (forceRedraw) { for (int x = 0; x < newWidth; x++) { for (int y = 0; y < newHeight; y++) { CellGrid[x, y].NeedsRedraw = true; CellGrid[x, y].Refresh(); } } } }
// Check if grid has element and it's upper-left corner is positioned at (x, y) private bool CheckIfHasElementOnPosition(int x, int y, CellGrid element, bool marked) { for (var i = 0; i < element.height; i++) { for (var j = 0; j < element.width; j++) { if (element[i, j] != 'b' && ((marked && this[x + i, y + j] != 'm') || (!marked && this[x + i, y + j] == 'b'))) { return(false); } } } return(true); }
public static BitGrid ToBitGrid(CellGrid cellGrid) { BitGrid grid = new BitGrid(cellGrid.Width, cellGrid.Height); for (var row = 0; row < grid.Height; row++) { for (var cell = 0; cell < grid.Width; cell++) { var gridCell = cellGrid[row][cell]; grid[row][cell] |= (!gridCell.North)? (int)Directions.N:0; grid[row][cell] |= (!gridCell.East)? (int)Directions.E:0; grid[row][cell] |= (!gridCell.South)? (int)Directions.S:0; grid[row][cell] |= (!gridCell.West)? (int)Directions.W:0; } } return(grid); }
public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellGrid) { int selfHeal = (int)Mathf.Floor((caster.TotalHitPoints - caster.HitPoints) / 2); caster.HitPoints += selfHeal; if (caster.HitPoints > caster.TotalHitPoints) { caster.HitPoints = caster.TotalHitPoints; } SecondWindBuff Buff = new SecondWindBuff(); caster.Buffs.Add(Buff); Buff.Apply(caster); caster.ActionPoints--; SetCooldown(); }
// Return cells coordinates related to grid of element, // upper-left corner of wich is positioned at (x, y) private List <Tuple <int, int> > GetCellsCoordinatesOfElement(int x, int y, CellGrid element) { var coordinates = new List <Tuple <int, int> >(); for (var i = 0; i < element.height; i++) { for (var j = 0; j < element.width; j++) { if (element[i, j] != 'b' && this[x + i, y + j] == 'm') { coordinates.Add(Tuple.Create(x + i, y + j)); } } } return(coordinates); }
private static string GetMaximumPopulationText(int terrainId, CellGrid cellGrid, HexOffsetCoordinates hexPoint) { var gameConfigCache = CallContext <GameConfigCache> .GetData("GameConfigCache"); var terrain = gameConfigCache.GetTerrainConfigById(terrainId); if (!terrain.CanSettleOn) { return(string.Empty); } var catchment = cellGrid.GetCatchment(hexPoint.Col, hexPoint.Row, 2); var maxPop = BaseFoodLevel.DetermineBaseFoodLevel(catchment); var text = $"Maximum Pop - {maxPop}"; return(text); }
// **TODO** Implémenter les dégâts supplémentaires au centre. public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellgrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); for (int i = 0; i < 3; ++i) { int randomReceiver = UnityEngine.Random.Range(0, receivers.Count); int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); caster.DealDamage2(receivers[randomReceiver], damage); } caster.ActionPoints--; SetCooldown(); }
public TapeGrid(string tape, int width, int height, CellGrid element) : base(tape, width, height) { var reflections = element.GetCellsReflections(); for (var i = 0; i <= 3; i++) { elements[i * 2] = new CellGrid(reflections[i * 2], i % 2 == 0 ? element.width : element.height, i % 2 == 0 ? element.height : element.width); elements[i * 2 + 1] = new CellGrid(reflections[i * 2 + 1], i % 2 == 0 ? element.width : element.height, i % 2 == 0 ? element.height : element.width); } }
// **TODO** Implémenter les dégâts supplémentaires au centre. public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellgrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); foreach (var receiver in receivers) { DefenceBuff ArmorVoidBuff = new DefenceBuff(2, 1.5f); receiver.Buffs.Add(ArmorVoidBuff); ArmorVoidBuff.Apply(receiver); } caster.ActionPoints--; SetCooldown(); }
public void UpdateAgent_Movement() { if (isDead) { return; } if (movementMode == MovementMode.Pathing) { movementController.FixedUpdate_MovementController(); } else if (movementMode == MovementMode.Steering) { simpleVehicleModel.UpdateSteering(); } Cell = CellGrid.GetCell(transform.position); }
protected void PathFind(int x, int y) { // Pathfind to player CellGrid cellGrid = LevelGen.CellGrid; GridCell targetCell = cellGrid.Grid[x, y]; GridCell currentCell = cellGrid.GetCellAtPos(transform.position); List <Vector3> path = cellGrid.FindPathWorld(targetCell, currentCell); if (path.Count > 1) { // Move towards next cell Vector3 dir = (path[1] - transform.position).normalized; TurnTowards(dir); Move(dir); } }
// return id of winning player (invalid id if there is no such player) private int getWinnerId() { CellGrid grid = board.getGridRef(); // if the board still has uncircled cells, do nothing if (grid.getCircledCnt() != grid.getCellCnt()) { return(Player.invalid_id); } int id_best = 0; // id of winning player(s) uint ccc_best = 0; // circled cell count of winning player(s) uint winner_cnt = 0; // number of winning players, should be one if there is a clear winner // for all players for (uint id = 0, ccc; id < player_cnt; id++) { // save current player circle cell count ccc = player[id].getCircledCellCnt(); // if current player beats previous players if (ccc_best < ccc) { // update best player variable, and reset the winning players counter id_best = (int)id; ccc_best = ccc; winner_cnt = 1; } else if (ccc_best == ccc) { // if the current player has the same circled cell count as the best player, increase the winning players counter winner_cnt++; } } // if there are more winning players, then the game is a tie if (winner_cnt > 1) { id_best = Player.invalid_id; } // return winning player id return(id_best); }
public override void Apply(Unit caster, List <Cell> cells, CellGrid cellGrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); foreach (var currentCell in cells) { if (currentCell.Occupent != null) { int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); caster.DealDamage2(currentCell.Occupent, damage); } } caster.ActionPoints--; SetCooldown(); }
public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellGrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Attack", true); anim.SetBool("Idle", false); foreach (var receiver in receivers) { int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); caster.DealDamage2(receiver, damage); RootedDebuff debuff = new RootedDebuff(); receiver.Buffs.Add(debuff); debuff.Apply(receiver); } caster.ActionPoints--; SetCooldown(); }
public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellGrid) { foreach (var receiver in receivers) { int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); Unit victim = MoveCasterToTarget(caster, receiver, cellGrid); Debug.Log(victim); Debug.Log(damage); caster.DealDamage2(victim, damage); } Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Attack", true); anim.SetBool("Idle", false); caster.ActionPoints--; SetCooldown(); }
private void EliminateByRout(Unit defeater) { CellGrid grid = GameObject.Find("CellGrid").GetComponent <CellGrid>(); foreach (Unit u in grid.Units) { if (u is Building && u.PlayerNumber == this.PlayerNumber) { u.PlayerNumber = defeater.PlayerNumber; (u as Building).UpdateColor(); u.GetComponent <Renderer>().material.color = (u as Unit).LeadingColor; } else if (u.PlayerNumber == this.PlayerNumber) { u.DestroyUnit(defeater, 100); } } grid.CheckForEndGame(); }
public T Invoke(int width, int height, CellGrid cellGrid) { return(Execute(() => { var cells = new List <Cell>(); for (int x = 0; x < width; x++) { for (int y = 0; y < height; y++) { var cell = new Cell(x, y, cellGrid); cell.CellEvaluationState = new CellStateEvaluated(cell); cells.Add(cell); } } return OnComplete(cells); })); }
// **TODO** Implémenter les dégâts supplémentaires au centre. public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellgrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); foreach (var receiver in receivers) { receiver.HitPoints += 40; Buff DoT = receiver.Buffs.Find(b => b.isDot); if (DoT != null) { receiver.Buffs.Remove(DoT); } } caster.ActionPoints--; SetCooldown(); }
public void KillCellIfItIsUnderPopulated() { Cell[,] cells = new Cell[GridSize, GridSize]; for (int column = 0; column < GridSize; column++) { for (int row = 0; row < GridSize; row++) { cells[column, row] = new Cell(CellState.Dead); } } cells[5, 5] = new Cell(CellState.Alive); CellGrid cellGrid = new CellGrid(cells); cellGrid.Iterate(); Assert.IsTrue(cellGrid.Cells[5, 5].State == CellState.Dead); }
/// <summary> /// Attacking unit calls Defend method on defending unit. /// </summary> protected virtual void Defend(Unit other, int damage) { MarkAsDefending(other); HitPoints -= DamageCalculator(other, damage, 0, Cell.defenseValue); GameObject.Find("DamageSound").GetComponent <AudioSource>().Play(); StartCoroutine("DamageFlash"); //(55 * ((100 / (100 + 0 * 10))) / (10 - Math.Ceiling(10))) //HitPoints -= Mathf.Clamp(damage - DefenceFactor, 1, damage); //Damage is calculated by subtracting attack factor of attacker and defence factor of defender. If result is below 1, it is set to 1. //This behaviour can be overridden in derived classes. if (UnitAttacked != null) { UnitAttacked.Invoke(this, new AttackEventArgs(other, this, damage)); } if (HitPoints <= 0) { CellGrid grid = GameObject.Find("CellGrid").GetComponent <CellGrid>(); Player myPlayer = grid.Players.Find(p => p.PlayerNumber.Equals(this.PlayerNumber)); if (grid.Units.FindAll(u => u.PlayerNumber.Equals(this.PlayerNumber) && !(u is Building)).Count <= 1) { myPlayer.EliminatePlayer(false, other); grid.CheckForEndGame(); } DestroyUnit(other, damage); return; } if (CanCounterAttack(other)) { AttackFactor = (int)(DamageChart.damageValues[this.GetDamageType().ToString().ToUpper()][other.GetArmorType().ToString().ToUpper()] * damageMultiplier * other.armorMultiplier); //AttackFactor = DamageChart.damageValues[this.GetType().ToString()][other.GetType().ToString()]; other.HitPoints -= other.DamageCalculator(this, AttackFactor, 0, 0); other.StartCoroutine("DamageFlash"); } UpdateHpBar(); }
public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellGrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Attack", true); foreach (Unit u in receivers) { if (caster.Cell.GetDistance(u.Cell) == 1) { int damage = UnityEngine.Random.Range(17, 21); caster.DealDamage2(u, damage); } else { int damage = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); caster.DealDamage2(u, damage); } } caster.ActionPoints--; SetCooldown(); }
public void DoNotReviveCellIfItHas1Neighbour() { Cell[,] cells = new Cell[GridSize, GridSize]; for (int column = 0; column < GridSize; column++) { for (int row = 0; row < GridSize; row++) { cells[column, row] = new Cell(CellState.Dead); } } cells[5, 5] = new Cell(CellState.Dead); cells[4, 4] = new Cell(CellState.Alive); CellGrid cellGrid = new CellGrid(cells); cellGrid.Iterate(); Assert.IsTrue(cellGrid.Cells[5, 5].State == CellState.Dead); }
// **TODO** Implémenter les dégâts supplémentaires au centre. public override void Apply(Unit caster, List <Unit> receivers, CellGrid cellgrid) { Animator anim = caster.GetComponentInChildren <Animator>(); anim.SetBool("Skill", true); anim.SetBool("Idle", false); foreach (var receiver in receivers) { int heal = UnityEngine.Random.Range(MinDamage, MaxDamage + 1); receiver.HitPoints += heal; if (receiver.HitPoints > receiver.TotalHitPoints) { receiver.HitPoints = receiver.TotalHitPoints; } } caster.ActionPoints--; SetCooldown(); }
public CellGridStateAiTurn(CellGrid cellGrid) : base(cellGrid) { }
public CellGridStateTurnChanging(CellGrid cellGrid) : base(cellGrid) { }
public override void Play(CellGrid cellGrid) { base.Play(cellGrid); SelectCharacter(cellGrid); }
public CellGridStateTurnChanging(CellGrid cellGrid) : base(cellGrid) { //cellGrid.EndTurn (); Debug.LogWarning("turn changing"); }
public CellGridStateWaitingForInput(CellGrid cellGrid) : base(cellGrid) { }
public void Regenerate() { // Clean up Ungenerate(); // Regenerate maze maze.Regenerate(); // Make the mesh seriously like 5x the resolution of the original maze for destructivity hiResGrid = new Cell[maze.Grid.GetLength(0) * MAZE_RESOLUTION, maze.Grid.GetLength(1) * MAZE_RESOLUTION]; for (int x = 0; x < maze.Grid.GetLength(0); ++x) { for (int y = 0; y < maze.Grid.GetLength(1); ++y) { for (int ix = 0; ix < MAZE_RESOLUTION; ++ix) { for (int iy = 0; iy < MAZE_RESOLUTION; ++iy) { Cell oldCell = maze.Grid[x, y]; int newX = x * MAZE_RESOLUTION + ix; int newY = y * MAZE_RESOLUTION + iy; Cell newCell = new Cell(oldCell); newCell.position = new Point(newX, newY); hiResGrid[newX, newY] = newCell; } } } } // Store a list of empty spaces emptySpaces = new List<GridCell>(); // Copy maze to pathfinding grid int width = hiResGrid.GetLength(0); int height = hiResGrid.GetLength(1); Grid = new GridCell[width, height]; for (int x = 0; x < width; ++x) { for (int y = 0; y < height; ++y) { Grid[x, y] = new GridCell(x, y, hiResGrid[x, y].visited); if (Grid[x, y].Accessible) emptySpaces.Add(Grid[x, y]); } } // Create cell grid for pathfinding cellGrid = CellGrid; // Reset enemy pathfinding data NonplayerCharacter.ResetPathfinding(); // Get list of empty cells List<GridCell> emptyCellsCopy = new List<GridCell>(emptySpaces); // Pick random deadend for player GridCell playerSpawnCell = emptyCellsCopy[Random.Range(0, emptyCellsCopy.Count)]; // Remove this dead end from the list so that no enemies can spawn there emptyCellsCopy.Remove(playerSpawnCell); // Spawn the player there Vector3 playerPos = cellGrid.GetCellPos(playerSpawnCell); playerPos.z = 0; GameObject playerObj = ((Component)GameObject.FindObjectOfType(typeof(PlayerCharacter))).gameObject; playerObj.transform.position = playerPos; // Create enemies and do the same enemies = new GameObject("Enemies"); for (int i = 0; i < enemyCount; ++i) { // Pick random place for enemy to spawn GridCell enemySpawnCell = emptyCellsCopy[Random.Range(0, emptyCellsCopy.Count)]; Vector3 enemyPos = cellGrid.GetCellPos(enemySpawnCell); enemyPos.z = 0; GameObject enemy = (GameObject)GameObject.Instantiate(enemyPrefab, enemyPos, Quaternion.identity); enemy.GetComponent<NonplayerCharacter>().target = playerObj; enemy.transform.parent = enemies.transform; // Add a slight force to enemy so they get unstuck if they're overlapping another character enemy.rigidbody.AddForce(new Vector3(0.1f, 0.1f)); } // Spawn powerups in maze PowerupManager powerupManager = (PowerupManager)GameObject.FindObjectOfType(typeof(PowerupManager)); powerupManager.SetOpenSpaces(cellGrid, emptySpaces); powerupManager.SpawnPowerups(); // Create mesh for level mesh = MeshGenerator.GenerateMesh(hiResGrid); // Asign mesh to mesh filter GetComponent<MeshFilter>().mesh = mesh; GetComponent<MeshCollider>().sharedMesh = mesh; // Create lights on walls if (wallLightPrefab != null) { CreateLights(); } }
public override void Play(CellGrid cellGrid) { cellGrid.CellGridState = new CellGridStateWaitingForInput(cellGrid); }
// Used to reset the pathfinding when the level is regenerated public static void ResetPathfinding() { gridWidth = LevelGen.CellGrid.Width; gridHeight = LevelGen.CellGrid.Height; // Allocate grids cellStates = new CellState[gridWidth, gridHeight]; pathFindingGrid = new GridCell[gridWidth, gridHeight]; // Initialise state grid for (int x = 0; x < gridWidth; ++x) for (int y = 0; y < gridHeight; ++y) { cellStates[x, y] = CellState.UNKNOWN; } // Initialise pathfinding grid for (int x = 0; x < gridWidth; ++x) for (int y = 0; y < gridHeight; ++y) { pathFindingGrid[x, y] = new GridCell(x, y, false); } cellGrid = new CellGrid(pathFindingGrid, LevelGen.Instance.transform, LevelGen.MAZE_RESOLUTION); currentTargets.Clear(); }
public void SetOpenSpaces(CellGrid cellGrid, List<GridCell> openSpaces) { this.cellGrid = cellGrid; this.openSpaces = new List<GridCell>(openSpaces); this.powerups = new List<Powerup>(); }
public PathNodeFromGrid(CellGrid grid, GridCell cell) { this.grid = grid; this.cell = cell; }
protected CellGridState(CellGrid cellGrid) { _cellGrid = cellGrid; }
void SelectFirstEnemy(CellGrid cellGrid) { this.cellGrid = cellGrid; units = cellGrid.Units.FindAll(u => u.PlayerNumber.Equals(PlayerNumber)).ToList(); NextMonster(); }
public override void Play(CellGrid cellGrid) { base.Play(cellGrid); SelectFirstEnemy(cellGrid); }
/// <summary> /// Method is called every turn. Allows player to interact with his units. /// </summary> public abstract void Play(CellGrid cellGrid);
public CellGridStateGameOver(CellGrid cellGrid) : base(cellGrid) { }