internal static void Up( GridTile tile ) { GodOfInteraction.OnPick_Tile( tile ); #if UNITY_EDITOR if( EDITOR_SHIT && tile.currentUnit != null ) { Selection.objects = new Object[] { tile.currentUnit.gameObject }; } #endif }
internal WorldObject AddDecor( Transform model, GridTile tile ) { Transform o = (Transform)Instantiate( model, tile.transform.position, model.transform.rotation ); objects.Add( o.GetComponent<WorldObject>() ); tile.objects.Add( o.GetComponent<WorldObject>() ); o.transform.parent = worldContainer.decorationHolder; return o.GetComponent<WorldObject>(); }
private void SpawnSingleUnit(GridTile pTile) { switch (_spawnUnitType) { case 1: GameManager.Instance.SpawnUnit(GameManager.Instance.UnitOgrePrefab, _currentbot, pTile); break; default: GameManager.Instance.SpawnUnit(GameManager.Instance.UnitSpiderPrefab, _currentbot, pTile); break; } _spawnUnitType++; if (_spawnUnitType > 1) _spawnUnitType = 0; }
protected List<GridTile> _GetPathTo( GridTile tile ) { List<GridTile> list = new List<GridTile>(); while( nodes[tile].prevTile != null ) { list.Add( tile ); tile = nodes[tile].prevTile; } list.Reverse(); return list; }
internal Obstruction AddObstruction( Obstruction prefab, GridTile tile, float coverValue, Transform model = null ) { Obstruction o = Instantiate( prefab, tile.transform.position, prefab.transform.rotation ) as Obstruction; if( o != null ) { o.transform.parent = worldContainer.obstructionsHolder; o.height = coverValue; o.currentTile = tile; tile.SetObstruction( o ); if( model ) { o.decor = AddDecor( model, tile ); } return o; } return null; }
protected List<GridTile> _GetLine( GridTile from, GridTile to ) { List<GridTile> list = new List<GridTile>(); IEnumerable<Int2D> r; GridTile t; r = GetPointsOnLine( from.x, from.y, to.x, to.y ); foreach( Int2D value in r ) { t = grid.GetTile( value.x, value.y ); if( t != from && t != to ) { list.Add( t ); } } r = GetPointsOnLine( to.x, to.y, from.x, from.y ); foreach( Int2D value in r ) { t = grid.GetTile( value.x, value.y ); if( !list.Contains( t ) && t != from && t != to ) { list.Add( t ); } } return list; }
private void GetWorldTiles() //check for all the active tiles in the Tilemap { tiles = new Dictionary <Vector3, GridTile>(); int count = 0; //TESTING THE DATA FILE textRW gridFile = new textRW(); string [] lines = gridFile.SeparateLines("grid"); //Debug.Log("Number of lines in data file " + lines.Length); List <string> locationData = new List <string>(); foreach (string str in lines) { string[] cell = gridFile.ParseLine(str); //returns an array locationData.Add(cell[0]); } //END TESTING THE DATA FILE //clear the index file gridFile.ClearFile("index"); foreach (Vector3Int pos in Tilemap.cellBounds.allPositionsWithin) { var localPlace = new Vector3Int(pos.x, pos.y, pos.z); if (!Tilemap.HasTile(localPlace)) { continue; } var tile = new GridTile { LocalPlace = localPlace, WorldLocation = Tilemap.CellToWorld(localPlace), TileBase = Tilemap.GetTile(localPlace), TilemapMember = Tilemap, Name = localPlace.x + "," + localPlace.y, Cost = count, myTerrain = terrainType.road, myEncounter = encounterType.empty }; //testing here to see if the grid.txt has the location (parsing the location too) for (int i = 0; i < locationData.Count; i++) { if (gridFile.CellToVector(locationData[i]) == tile.WorldLocation) { string[] cell = gridFile.ParseLine(lines[i]);//the cell [] holds the comma separated cells Debug.Log("matched world location " + cell[0]); //check if the 3rd cell in the row matches a possible type for encounterType if (System.Enum.TryParse <encounterType>(cell[1], out encounterType testEnum)) { Debug.Log("encounter check worked " + testEnum); tile.myEncounter = testEnum; } else { Debug.Log("encounter match not found"); } } } //testing out writing stuff for the index document string coords = "" + tile.WorldLocation.x + " " + tile.WorldLocation.y; coords = coords + "," + tile.myTerrain + "," + tile.myEncounter; gridFile.WriteLine("index", coords); //End of all the writing shenanigans count++; tiles.Add(tile.WorldLocation, tile); } }
internal ICover[] GetCoversAgainst( GridTile attackerTile ) { List<ICover> covers = ( from coverTile in neighbours where coverTile != attackerTile where GetSingleCoverValueAgainst( coverTile , attackerTile ) > 0 select coverTile.cover ).ToList( ); covers.Sort( ( t1 , t2 ) => t2.coverValue.CompareTo( t1.coverValue ) ); return covers.ToArray(); }
public void RaiseChunk() { confirmedTile.TryRaiseChunk(); confirmedTile = null; }
private Vector2 GetWorldPositionOfGridTile(GridTile tile) { return(tile.WorldLocation); }
// 17x13 public override GridTile[,] GenerateMap(int sizeX, int sizeY, Transform holder) { grid = new GridTile[sizeX, sizeY]; mapLasers = new Laser[1]; for (int y = 0; y < sizeY; y++) { for (int x = 0; x < sizeX; x++) { grid[x, y].position = new Vector2(x, y); grid[x, y].background = Instantiate(mapGenerationTowers[0].GetGameObject(), holder); grid[x, y].background.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, 0) + offset; grid[x, y].background.isStatic = true; if ((x + y) % 2 == 0) { grid[x, y].background.GetComponent <MeshRenderer>().material.color = Color.black; } if (x == 0 || y == 0 || x == sizeX - 1 || y == sizeY - 1) { grid[x, y].currentTower = mapGenerationTowers[1]; grid[x, y].currentTowerMesh = Instantiate(mapGenerationTowers[1].GetGameObject(), grid[x, y].background.transform); grid[x, y].currentTowerMesh.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, -1) + offset; grid[x, y].currentTowerMesh.GetComponent <MeshRenderer>().material.color = Color.red; grid[x, y].owner = TileOwner.GAMEMANAGER; } if (x == 4 && y >= 4 && y <= sizeY - (4 + 1) || x == sizeX - (4 + 1) && y >= 4 && y <= sizeY - (4 + 1)) { grid[x, y].currentTower = mapGenerationTowers[1]; grid[x, y].currentTowerMesh = Instantiate(mapGenerationTowers[1].GetGameObject(), grid[x, y].background.transform); grid[x, y].currentTowerMesh.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, -1) + offset; grid[x, y].currentTowerMesh.GetComponent <MeshRenderer>().material.color = Color.red; grid[x, y].owner = TileOwner.GAMEMANAGER; } //Laser if (x == sizeX / 2 && y == sizeY / 2) { grid[x, y].currentTower = mapGenerationTowers[4]; grid[x, y].currentTowerMesh = Instantiate(mapGenerationTowers[4].GetGameObject(), grid[x, y].background.transform); grid[x, y].currentTowerMesh.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, -1) + offset; grid[x, y].owner = TileOwner.GAMEMANAGER; mapLasers[0] = grid[x, y].currentTowerMesh.GetComponent <Laser>(); mapLasers[0].SetStartPosition(grid[x, y].currentTowerMesh.transform.position); mapLasers[0].SetStartDDAPoint(grid[x, y].position); mapLasers[0].SetCheckFirstCell(false); } if (x == playerStartPositions[0].x && y == playerStartPositions[0].y) { //Spawn Player 1 grid[x, y].currentTower = mapGenerationTowers[1]; grid[x, y].currentTowerMesh = Instantiate(mapGenerationTowers[1].GetGameObject(), grid[x, y].background.transform); grid[x, y].currentTowerMesh.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, -1) + offset; } if (x == playerStartPositions[1].x && y == playerStartPositions[1].y) { //Spawn Player 2 grid[x, y].currentTower = mapGenerationTowers[1]; grid[x, y].currentTowerMesh = Instantiate(mapGenerationTowers[1].GetGameObject(), grid[x, y].background.transform); grid[x, y].currentTowerMesh.transform.position = new Vector3(grid[x, y].position.x, grid[x, y].position.y, -1) + offset; } } } return(grid); }
public GridTile Move(GridSide side, int x, int y) { GridTile to = GetTile(side, x, y); return(to); }
private static bool IsOutOfGrid(GridTile pos, Boundaries boundaries) { return((pos.x < boundaries.Min.x || pos.x > boundaries.Max.x) || (pos.y < boundaries.Min.y || pos.y > boundaries.Max.y)); }
public GridTileTileRelation GetRelation( GridTile tile ) { return relations[tile]; }
public static List<GridTile> GetPathTo( GridTile tile ) { return me ? me._GetPathTo( tile ) : null; }
public static List<GridTile> GetLine( GridTile from, GridTile to ) { return me ? me._GetLine( from, to ) : null; }
internal float GetTotalCoverValueAgainst( GridTile attackerTile ) { float result = 0; foreach( GridTile coverTile in neighbours ) { if( coverTile != attackerTile ) { result += GetSingleCoverValueAgainst( coverTile, attackerTile ); } } return result; }
internal float GetSingleCoverValueAgainst( GridTile coverTile, GridTile attackerTile ) { return ( COVER_MAX_ANGLE - Mathf.Abs( Mathf.DeltaAngle( relations[coverTile].angle, relations[attackerTile].angle ) ).ClipMaxMin( COVER_MAX_ANGLE ) ) / COVER_MAX_ANGLE * coverTile.coverValue; }
private void AddTileToSegment(GridTile tile) { _allSegmentTiles.Add(tile); }
public PathNode( GridTile prevTile, float pathLen ) { this.prevTile = prevTile; this.pathLen = pathLen; }
private void Awake() { Instance = this; }
protected const float POINT_BLANK_RADIUS = 3f; // 1.5f #endregion Fields #region Constructors public RangedAttackResult( Unit attacker, Unit attackee, GridTile atTile = null ) { //TODO replace target with IDamegable GridTile attackeeTile = atTile ?? attackee.currentTile; float mul_DistanceAndAccuracy = 1f; float mul_CoversAndTargetSize = 1f; float mul_TargetEvasion = 1f; //start with "perfect conditions" chance which is based solely on skill mul_DistanceAndAccuracy *= ChanceFromAccuracy( attacker ); //apply distance penalty mul_DistanceAndAccuracy *= ChanceFromDistance( attacker.GetDistance( attackeeTile.transform ), attacker.propAttackRange ); //apply protection from cover //apply unit size multilpier so larger units are easier to hit even from distance or behind small cover. mul_CoversAndTargetSize *= ChanceFromCoverAndSize( attacker.currentTile, attackeeTile, attackee.propHeight ); //apply evasion chance mul_TargetEvasion *= ChanceFromUnitEvasion( attackee ); //calculate total chance, which will be shown before attack for user consideration hitChance = 100f * mul_DistanceAndAccuracy * mul_CoversAndTargetSize * mul_TargetEvasion; longDescription = "mul_DistanceAndAccuracy =" + "\n ChanceFromAccuracy~" + ChanceFromAccuracy( attacker ) + "\n ChanceFromDistance!~" + ChanceFromDistance( attacker.GetDistance( attackeeTile.transform ), attacker.propAttackRange ) + "\nmul_CoversAndTargetSize =" + "\n ChanceFromUnitSize~" + ChanceFromUnitSize( attackee.propHeight ) + "\n ChanceFromCoverAndSize~" + ChanceFromCoverAndSize( attacker.currentTile, attackeeTile, attackee.props.size ) + "\nmul_TargetEvasion =" + "\n ChanceFromUnitEvasion~" + ChanceFromUnitEvasion( attackee ); if( !this.Chance1( mul_DistanceAndAccuracy ) ) { msg = Message.MISSED; } else { if( !this.Chance1( mul_CoversAndTargetSize ) ) { msg = Message.HIT_COVER; ICover[] covers = attackeeTile.relations.GetCoversAgainst( attacker.currentTile ); if( covers.Length > 0 ) { hittee = covers[0] as IDamageable; } } else { if( !this.Chance1( mul_TargetEvasion ) ) { msg = Message.EVADED; } else { msg = Message.SUCCESS; hittee = attackee; } } } }
void CalculateChunk(object args) { object[] argsArr = (object[])args; int i = (int)argsArr[0]; float time = (float)argsArr[1]; int operationsPerThread = Mathf.CeilToInt(windSpeedChunks.Count / chunkThreads.Length); int windCount = windSpeedChunks.Count; int startK = (int)i * operationsPerThread; int endK = ((int)i + 1) * operationsPerThread; for (int k = startK; k < endK; k++) { if (k >= windCount) { break; } if (!windSpeedChunks[k].isEnabled) { continue; } List <Vector3> vert = threadVerts[k]; for (int j = 0; j < vert.Count; j++) { GridTile tile = GridTile.FindClosestGridTile(vert[j]); if (tile != null && tile.canSeeWind && !tile.isOutsideBorder) { float curWind = WindController.GetWindAtTile(tile, height, time); Vector2 curUv = new Vector2(1 - curWind / WindController.WindMagnitudeAtTime(time), 1 - curWind / WindController.WindMagnitudeAtTime(time)); for (int intp = 0; intp < intpSteps; intp++) { if (curUvs) { Vector2 interpolated = Vector2.Lerp(buffereduvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1)); uvs[k][intp][j].Set(interpolated.x, interpolated.y); } else { Vector2 interpolated = Vector2.Lerp(uvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1)); buffereduvs[k][intp][j].Set(interpolated.x, interpolated.y); } if (stopThreads) { return; } } } else if (tile != null && !tile.canSeeWind && !tile.isOutsideBorder) { Vector2 curUv = new Vector2(0.125f, 0.875f); for (int intp = 0; intp < intpSteps; intp++) { if (curUvs) { Vector2 interpolated = Vector2.Lerp(buffereduvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1)); uvs[k][intp][j].Set(interpolated.x, interpolated.y); } else { Vector2 interpolated = Vector2.Lerp(uvs[k][(intpSteps - 1)][j], curUv, (float)intp / (intpSteps - 1)); buffereduvs[k][intp][j].Set(interpolated.x, interpolated.y); } if (stopThreads) { return; } } } } } }
protected static float ChanceFromCoverAndSize( GridTile attackerTile, GridTile attackeeTile, float attackeeSize ) { if( Config.OVERRIDE_HIT_CHANCE_COVER ) { return 1.0f; } float r = ( ChanceFromUnitSize( attackeeSize ) - attackeeTile.relations.GetTotalCoverValueAgainst( attackerTile ) ); return r.ClipMaxMin(); }
/// <summary> /// Sets a new destination the character will pathfind to /// </summary> /// <param name="destinationGridTile"></param> public virtual void SetNewDestination(GridTile destinationGridTile) { m_DestinationTile = destinationGridTile; DeterminePath(_gridObject.m_CurrentGridTile, destinationGridTile); }
void Start() { me = GetComponent<GridTile>(); // model = me.renderer; }
private bool IsInLineOfSight( GridTile tile ) { return GodOfPathfinding.GetLine( currentTile, tile ).FindAll( t => t.coverValue >= 1f ).Count == 0; }
internal static void UnhighlightGridTile( GridTile gridTile ) { me.gridTileHighlighter.renderer.enabled = false; me.hideAllHolos(); me.gridTileHighlighter.HideDanger(); if( crossHolo != null ) { crossHolo.active = false; } gridTile.Blink(); }
public void SubmitButtonPressed() { _characterMap.Clear(); // Get all character tiles boxes GameObject[] colliders = GameObject.FindGameObjectsWithTag(CheckBoardMaker.CHECKBOARDBOXESTAG); //if no dislike +1 points foreach (var item in colliders) { GridTile tile = item.GetComponent <GridTile>(); tile.character.totalScore = 0; _characterMap.Add(tile.Index, tile.character); Character referenceChar = tile.character; string objectName = item.gameObject.name; bool dislikeSomeTerrain = false; if (objectName.Contains(referenceChar.LikedMapSide.ToString())) { referenceChar.totalScore += likedMapSideBonus; } if (objectName.Contains(referenceChar.DislikedMapSide.ToString())) { referenceChar.totalScore -= dislikedMapSideMalus; dislikeSomeTerrain = true; } if (!dislikeSomeTerrain) { referenceChar.totalScore += notDislikeBonus; } } foreach (var evaluatedCharacter in _characterMap) { bool dislikedSomeone = false; foreach (var index in maskForCheckIndex) { Character otherCharacter; int valueToTest = index + evaluatedCharacter.Key; int originalYposition = evaluatedCharacter.Key / 3; int newYPosition = (evaluatedCharacter.Key + index) / 3; //when adding or removing 1 from the index we don't want to check //different rows. So we skip. if (Mathf.Abs(index) == 1 && originalYposition != newYPosition) { continue; } if (_characterMap.TryGetValue(evaluatedCharacter.Key + index, out otherCharacter)) { if (evaluatedCharacter.Value.LikedCharacter == otherCharacter.Name) { evaluatedCharacter.Value.totalScore += likedCharacterBonus; } else if (evaluatedCharacter.Value.DislikedCharacter == otherCharacter.Name) { evaluatedCharacter.Value.totalScore -= dislikedCharacterMalus; dislikedSomeone = true; } } } if (!dislikedSomeone) { evaluatedCharacter.Value.totalScore += notDislikeBonus; } } ScoresComputed(); }
internal static void HighlightGridTile( GridTile tile ) { me.gridTileHighlighter.renderer.enabled = true; me.gridTileHighlighter.transform.position = tile.transform.position + Vector3.up * .066f; me.hideAllHolos(); if( mode == HoloMode.Cross ) { if( crossHolo != null ) { crossHolo.active = true; crossHolo.transform.position = tile.transform.position; if( tile.obstructed ) { crossHolo.transform.position += Vector3.up * tile.obstruction.height * 2; } } } else if( mode == HoloMode.HoloUnit ) { if( tile.walkable ) { GridTile smallestCover = null; foreach( GridTile cover in tile.relations.neighbours ) { if( cover.obstructed && !tile.relations.relations[cover].diagonal ) { if( smallestCover == null || smallestCover.coverValue > cover.coverValue ) { smallestCover = cover; } } } unitHolo = me.unitHoloRunning; if( smallestCover == null ) { unitHolo = me.unitHoloRunning; unitHolo.model.renderer.enabled = true; unitHolo.transform.position = tile.transform.position; unitHolo.transform.LookAt( God.selectedUnit.transform ); unitHolo.transform.Rotate( Vector3.up * 180 ); } else { if( smallestCover.coverValue < God.selectedUnit.propHeight ) { unitHolo = me.unitHoloInCoverDucked; } else { unitHolo = me.unitHoloInCover; } unitHolo.model.renderer.enabled = true; unitHolo.transform.position = tile.transform.position; unitHolo.transform.LookAt( smallestCover.transform ); } unitHolo.animation.Rewind(); unitHolo.animation.Play( "FadeIn" ); unitHolo.transform.localScale = new Vector3( 1, God.selectedUnit.props.size, 1 ); //tile.DebugOut( Mathf.Floor( Angles.FixAngleDegSigned( God.selectedUnit.currentTile.relations.GetRelation( tile ).angle + God.selectedUnit.transform.eulerAngles.y - 90 ) ).ToString() ); //List<GridTile> list = GodOfPathfinding.GetLine( selectedUnit.currentTile, tile ); //foreach( GridTile t in grid.GetAllTiles() ) { // bool flag = list.Contains( t ); // t.transform.Find( "flag" ).renderer.enabled = flag; //} } } //float danger = 0; //RangedAttackResult r; //foreach( Unit subjectUnit in allUnits ) { // if( selectedUnit.team.IsEnemy( subjectUnit ) ) { // if( subjectUnit.inPlay && subjectUnit.CanSee( tile ) ) { // subjectUnit.__SetFlag( true ); // r = new RangedAttackResult( subjectUnit, selectedUnit, tile ); // danger += r.hitChance * (1-danger/100) ; // } // } //} //me.gridTileHighlighter.ShowDanger( danger ); }
public float GetAngle( GridTile tile ) { return relations[tile].angle; }
public void Update(GameTime gameTime) { futureTile = Platform.GetTileByCoordinate(futurePosition); if (futureTile.walkable) { position = futurePosition; velocity = futureVelocity; } else { velocity.X = 0; velocity.Y = 0; } renderPosition.X = position.X; renderPosition.Y = position.Y; }
public static void ONGeneratedPoint(GridTile tile) { OnGeneratedPoint?.Invoke(tile); }
private bool TileIsClear(GridTile tile) { return(tile.Pathable()); }
//Returns whether the tile is a valid free tile in the map or not public bool IsFreeTile(GridTile tile) { return(tile.x >= 0 && tile.x < Width && tile.y >= 0 && tile.y < Height && !Obstacles[tile.y][tile.x]); }
public bool GetTile(TileKey key, out GridTile tile) { return(GridTiles.TryGetValue(key, out tile)); }
public void AssignActiveTile(GridTile newActiveTile) { activeTile = newActiveTile; activeTile.tileLifeOver += OnTileLifeOver; }
public void RemoveTileFromGrid(GridTile _tile) { _tile.ClearSurroundingTiles(this); GridTiles.Remove(_tile.Key); Destroy(_tile.gameObject); }
private static float EuclidianDistance(GridTile tile1, GridTile tile2) { return(Mathf.Sqrt(Mathf.Pow(tile2.x - tile1.x, 2) + Mathf.Pow(tile2.y - tile1.y, 2))); }
public void ProjectileCreated(GridTile newTile) { levelTiles.Remove(newTile.GetInstanceID()); }
public float GetDistance( GridTile tile ) { return relations[tile].distance; }
public void ProjectileDestroyed(GridTile tile) { levelTiles.Add(tile.GetInstanceID(), tile); }
public void SetGridTile(GridTile tile) { gridTile = tile; }
public void SetTile(int x, int y, GridTile tile) { tiles[x, y] = tile; }
// Load stage private void Load(StageData stageData) { // Unload Unload(); // Set instance instance = this; // Get stage data data = stageData; // Set size width = tileSize * data.columns; height = tileSize * data.rows; Debug.Log("GRID MANAGER - LOAD STAGE: " + data.stageID); // Generate tiles tiles = new Dictionary <int, GridTile>(); foreach (TileData tileDatum in data.tiles) { // Ensure unique index if (tiles.ContainsKey(tileDatum.tileIndex)) { Debug.LogError("GRID MANAGER - CANNOT HAVE MULTIPLE TILES FOR INDEX: " + tileDatum.tileIndex); continue; } // Get tile prefab GridTile prefab = tileDatum.tilePrefab >= 0 && tileDatum.tilePrefab < tilePrefabs.Length ? tilePrefabs[tileDatum.tilePrefab] : null; if (prefab == null) { Debug.LogError("GRID MANAGER - NO TILE FOR PREFAB INDEX: " + tileDatum.tilePrefab); continue; } // Load tile instance GridTile inst = Pool.instance.Load(prefab.gameObject).GetComponent <GridTile>(); inst.movable = null; if (inst == null) { Debug.LogError("GRID MANAGER - CANNOT INSTANTIATE TILE PREFAB: " + prefab.gameObject.name); continue; } // Set position Transform tileTransform = inst.transform; tileTransform.SetParent(transform); tileTransform.localPosition = GetTilePosition(tileDatum.tileIndex); // Load data inst.LoadData(tileDatum); tiles[tileDatum.tileIndex] = inst; } // Generate props List <GameObject> winList = new List <GameObject>(); props = new GridProp[data.props.Length]; for (int p = 0; p < data.props.Length; p++) { // Prop datum PropData propDatum = data.props[p]; // Ensure tile exists if (!tiles.ContainsKey(propDatum.tileIndex)) { Debug.LogError("GRID MANAGER - NO TILE FOUND FOR INDEX: " + propDatum.tileIndex); continue; } // Get tile GridTile tile = tiles[propDatum.tileIndex]; if (tile.movable != null) { Debug.LogError("GRID MANAGER - CANNOT HAVE MULTIPLE PROPS ON THE SAME TILE FOR INDEX: " + propDatum.tileIndex); continue; } // Get prop prefab GridProp prefab = propDatum.propPrefab >= 0 && propDatum.propPrefab < propPrefabs.Length ? propPrefabs[propDatum.propPrefab] : null; if (prefab == null) { Debug.LogWarning("GRID MANAGER - NO PROP FOR PREFAB INDEX: " + propDatum.propPrefab); prefab = propPrefabs[0]; } // Load prop instance GridProp inst = Pool.instance.Load(prefab.gameObject).GetComponent <GridProp>(); if (inst == null) { Debug.LogError("GRID MANAGER - CANNOT INSTANTIATE PROP PREFAB: " + prefab.gameObject.name); continue; } // Set position Transform trans = inst.transform; trans.SetParent(transform); trans.localPosition = GetTilePosition(propDatum.tileIndex); Direction direction = propDatum.direction; if (direction == Direction.None) { int random = UnityEngine.Random.Range(0, 5) + 1; direction = (Direction)random; } trans.localRotation = GetRotation(direction); // Load data inst.LoadData(propDatum); props[p] = inst; // Add win effect if (propDatum.isWinProp) { GameObject winEffect = Pool.instance.Load(winPropEffect); winEffect.transform.SetParent(inst.transform); winEffect.transform.localPosition = new Vector3(0f, 1f, 0f); winEffect.transform.localRotation = Quaternion.identity; winEffect.transform.localScale = Vector3.one; winList.Add(winEffect); } } winEffects = winList.ToArray(); // Generate characters if (GameManager.instance.players != null && GameManager.instance.players.Count > 0) { if (GameManager.instance.players.Count > data.players.Length) { Debug.Log("STAGE: " + data.stageID + "\nPLAYERS: " + data.players.Length); } characters = new GridCharacter[GameManager.instance.players.Count]; for (int p = 0; p < GameManager.instance.players.Count; p++) { // Player GamePlayer player = GameManager.instance.players[p]; PlayerData playerData = data.players[p]; // Get character data int index = player.characterIndex; if (index < 0 || index >= GameManager.instance.gameData.characters.Length) { index = UnityEngine.Random.Range(0, GameManager.instance.gameData.characters.Length); } GameCharacter character = GameManager.instance.gameData.characters[index]; // Get prefab GridCharacter prefab = GetCharacterPrefab(character.characterID); // Get instance GridCharacter mover = Pool.instance.Load(prefab.gameObject).GetComponent <GridCharacter>(); mover.playerIndex = p; mover.Place(character.characterVariant, playerData.tileIndex, playerData.direction); // Set character characters[p] = mover; } } // Delegate if (onGridLoaded != null) { onGridLoaded(this); } // Set game intro if (GameManager.instance != null) { GameManager.instance.SetState(GameState.GameIntro); } }
void Awake() { selectedTiles = new List <GridTile> (); selectedTile = null; }
public void StartSearch(GridTile startPos, GridTile endPos) { todo = new List <GridTile>(); done = new List <GridTile>(); todo.Add(startPos); smallestDis = startPos; smallestDis.CalcuteDistance(endPos, startPos); while (todo.Count > 0) { smallestDis = todo[0]; for (int i = 0; i < todo.Count; i++) { if (smallestDis != null && todo[i].totalDistance <= smallestDis.totalDistance) { if (temp != todo[i]) { temp = todo[i]; smallestDis = temp; } } } done.Add(smallestDis); done.Add(temp); todo.Remove(temp); if (smallestDis == endPos) { endPos.CalcuteDistance(endPos, smallestDis.previousTile); done.Reverse(); foreach (GridTile tile in done) { if (tile == smallestDis.previousTile && !path.Contains(tile)) { path.Add(tile); smallestDis = smallestDis.previousTile; } } if (smallestDis == startPos) { path.Reverse(); break; } } GridTile[,] grid = GameObject.FindGameObjectWithTag("PathManager").GetComponent <PathManager>().grid; List <GridTile> neighbour = new List <GridTile>(); int k, j; j = smallestDis.x_pos; k = smallestDis.z_pos; //Left if (j - 1 >= 0 && j != 0) { if (!grid[j - 1, k].blockade) { neighbour.Add(grid[j - 1, k]); } } //Right if (j + 1 < grid.GetLength(0) && j != grid.GetLength(0) - 1) { if (!grid[j + 1, k].blockade) { neighbour.Add(grid[j + 1, k]); } } //Below if (k - 1 >= 0 && k != 0) { if (!grid[j, k - 1].blockade) { neighbour.Add(grid[j, k - 1]); } } //Above if (k + 1 < grid.GetLength(1) && k != grid.GetLength(1) - 1) { if (!grid[j, k + 1].blockade) { neighbour.Add(grid[j, k + 1]); } } foreach (GridTile neigbouringGrid in neighbour) { if (!done.Contains(neigbouringGrid) && !todo.Contains(neigbouringGrid)) { neigbouringGrid.CalcuteDistance(endPos, smallestDis); todo.Add(neigbouringGrid); } } } if (todo.Count <= 0) { Debug.LogError("No Target"); } }
public List <GridTile> FindPath(Vector3 startPos, Vector3 endPos, bool ignoreCollisions = false) { GridTile startTile = grid.Get((int)startPos.x, (int)startPos.y); GridTile endTile = grid.Get((int)endPos.x, (int)endPos.y); // print(endTile.gridX + " " + endTile.gridY); // print(startTile.gridX + " " + startTile.gridY); List <GridTile> openList = new List <GridTile>(); HashSet <GridTile> closedList = new HashSet <GridTile>(); openList.Add(startTile); while (openList.Count > 0) { GridTile currentTile = openList[0]; for (int i = 1; i < openList.Count; i++) { if (openList[i].FCost < currentTile.FCost || openList[i].FCost == currentTile.FCost && openList[i].hCost < currentTile.hCost) { currentTile = openList[i]; } } openList.Remove(currentTile); closedList.Add(currentTile); if (currentTile == endTile) { return(GetFinalPath(startTile, endTile)); } foreach (var neighbour in grid.GetNeighbours(currentTile)) { if (closedList.Contains(neighbour)) { continue; } if (ignoreCollisions) { } else if ((neighbour.type == TileType.SNAKE || closedList.Contains(neighbour) || neighbour.type == TileType.PICKUP || neighbour.type == TileType.SPAWNER)) { continue; } int movecost = currentTile.gCost + GetManHTDist(currentTile, neighbour); if (movecost < neighbour.gCost || !openList.Contains(neighbour)) { neighbour.gCost = movecost; neighbour.hCost = GetManHTDist(neighbour, endTile); neighbour.Parent = currentTile; if (!openList.Contains(neighbour)) { openList.Add(neighbour); } } } } return(null); }
internal bool CanSee( GridTile tile ) { return IsInLineOfSight( tile ) && IsInVisualRange( tile.gameObject ); }
public UnitMoveAlongPath( Unit subject, GridTile targetTile ) : base("Repositioning", subject) { path = GodOfPathfinding.GetPathTo( targetTile ); }
public void ClearFog( GridTile centerTile ) { if( team.isUserControlled && Config.USE_FOG ) { foreach( GridTile tile in grid.GetAllTiles() ) { if( CanSee( tile ) ) { tile.UnFog(); } } } }
public UnitMoveToTile( Unit subject, GridTile targetTile, float speed = -1f ) : base("MoveToTile", subject) { this.targetTile = targetTile; this.speed = speed > 0f ? speed : subject.movementSpeed; }
// Use this for initialization public void Init() { //find all columns, tell them to initialize. //establish the connections between each pir of grid tiles columns = new List <Column>(); foreach (Column col in GetComponentsInChildren <Column>()) { col.Init(); columns.Add(col); } columns.Sort((colA, colB) => colA.x - colB.x); for (int x = 0; x < columns.Count; x++) { List <GridTile> tilesInColumn = columns[x].GetColumnTiles(); for (int y = 0; y < tilesInColumn.Count; y++) { GridTile tile = tilesInColumn[y]; Connection northConnection = y > 0 ? tilesInColumn[y - 1].GetConnection(Direction.NORTH.Opposite()) : null; Connection southConnection = y < tilesInColumn.Count - 1 ? (Instantiate(Resources.Load("Prefabs/Connection", typeof(GameObject))) as GameObject).GetComponent <Connection>() : null; if (southConnection != null) { southConnection.SetGridTile(tile); GridTile other = tilesInColumn[y + 1]; southConnection.SetGridTile(other); southConnection.transform.position = (tile.transform.position + other.transform.position) * .5f; } Connection westConnection = x > 0 ? columns[x - 1].GetColumnTiles()[y].GetConnection(Direction.WEST.Opposite()) : null; Connection eastConnection = x < columns.Count - 1 ? (Instantiate(Resources.Load("Prefabs/Connection", typeof(GameObject))) as GameObject).GetComponent <Connection>() : null; if (eastConnection != null) { eastConnection.SetGridTile(tile); GridTile other = columns[x + 1].GetColumnTiles()[y]; eastConnection.SetGridTile(other); eastConnection.transform.position = (tile.transform.position + other.transform.position) * .5f; } tile.SetConnection(Direction.SOUTH, southConnection); tile.SetConnection(Direction.WEST, westConnection); tile.SetConnection(Direction.NORTH, northConnection); tile.SetConnection(Direction.EAST, eastConnection); } } }
public GridTileTileRelations( GridTile @this, GridTile[,] allTiles ) { relations = new Dictionary<GridTile, GridTileTileRelation>(); List<GridTile> covers = new List<GridTile>(); GridTileTileRelation relation; foreach( GridTile @that in allTiles ) { relation = new GridTileTileRelation( @this, @that ); relations.Add( @that, relation ); if( @that != @this && relation.distanceSqr == 1 ) { covers.Add( @that ); } } neighbours = covers.ToArray(); }
internal void OnTilePicked( GridTile tile ) { if( !active || selectedAction.subjectType != ActionSubjectType.GridTile ) return; if( ( selectedAction ).IsSubjectViable( tile ) ) { ConfirmSelectedActionOn( tile ); } }
// Wether or not this unit is able to move to a target tile (based on wether or not it is inside the range) public bool CanMoveToTile(GridTile targetTile) { return(CanMove() && m_currentMovementRange.Contains(targetTile) && targetTile != _gridObject.m_CurrentGridTile); }
internal Unit SpawnUnit( Unit prefab, Team team, GridTile spawnTile, GridTile firstTile = null ) { Unit unit = Instantiate( prefab, spawnTile.transform.position, prefab.transform.rotation ) as Unit; if( unit != null ) { unit.currentTile = firstTile ?? spawnTile; unit.team = team; allUnits.Add( unit ); team.units.Add( unit ); objects.Add( unit.model ); unit.transform.parent = worldContainer.unitsHolder; return unit; } return null; }
public bool CanAttackTile(GridTile targetTile) { return(CanAttack() && m_CharacterAttack.CanAttackTile(targetTile)); }
public void moveUnitToGridTile(GridTile tile) { transform.parent = tile.transform; StartCoroutine(smoothMovementCoRoutine(transform.position, tile.transform.position, 0.05f)); deselectUnit(); }
internal GridTile GetClosestNeighbourTo( GridTile subject ) { GridTile result = null; float dist = float.MaxValue; foreach( GridTile neighbour in neighbours ) { if( result != null && neighbour.transform.position.DistanceTo( subject.transform.position ) >= dist ) continue; result = neighbour; dist = neighbour.transform.position.DistanceTo( subject.transform.position ); } return result; }