//sets the variables in the tile public void setVariables(TileScript input) { isOccupied = input.isOccupied; pieceIndex = input.pieceIndex; isPieceBlack = input.isPieceBlack; isKing = input.isKing; }
public void tileDragoverCallback(TileScript tileScript) { if(tileDown == null) return; //Debug.Log ("Drag over " + tileScript.x + " " + tileScript.y); tileHoveredOver = tileScript; }
// Use this for initialization void Start () { teamGOs=GameObject.FindGameObjectsWithTag(teamName); tileScript = GameObject.FindGameObjectWithTag("ground").GetComponent<TileScript>(); crosshair.SetActive(false); shotActionPopup.SetActive(false); }
public Tile(TileBehavior behavior, Texture2D image, Vector2 position, TileScript script) { this.Behavior = behavior; this.image = image; this.Position = position; this.Script = script; }
//we wish to see if the player can execute their ability on the given tile coordinate public override bool ValidateMove(ref int expectedStamina, TileScript expectedTilePosition, TileScript targetTile) { int distance = 99; CharacterScript enemy = targetTile.GetTileInhabitant(); switch(player.characterType) { case BAConstants.CharacterConstants.CharacterType.player: { if(enemy.characterType == CharacterConstants.CharacterType.enemy) { distance = player.map.GetAStar().GetRangeBetweenTwoTiles(expectedTilePosition,targetTile); if(distance <= range) { int abilityCostModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.DecreaseAbilityCost); if(player.stamina >= staminaCost - abilityCostModifier) { return true; } } } break; } case BAConstants.CharacterConstants.CharacterType.enemy: { distance = player.map.GetAStar().GetRangeBetweenTwoTiles(expectedTilePosition,targetTile); if(distance <= range) { if(enemy.characterType == CharacterConstants.CharacterType.player) { int increaseAbilityCostModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.IncreaseEnemyAbilityCost); if(player.stamina >= staminaCost + increaseAbilityCostModifier) { return true; } } } break; } } return false; }
public void OnTileClicked(TileScript tileClicked) { int newColor = tileClicked.GetNextColor(); switch (tileClicked.column) { case 1: foreach (TileScript t in tilesInLeftColumn) { t.ChangeFullColor(newColor); } foreach (Vehicle v in gs.vehicleBag.FindAll(vec => (vec.channel == 1) && (vec.color == newColor))) { gs.vehicleBag.Remove(v); Destroy (v.gameObject); } break; case 2: foreach (TileScript t in tilesInCenterColumn) { t.ChangeFullColor(newColor); } foreach (Vehicle v in gs.vehicleBag.FindAll(vec => (vec.channel == 2) && (vec.color == newColor))) { Debug.Log ("sarasasss"); gs.vehicleBag.Remove(v); Destroy (v.gameObject);} break; case 3: foreach (TileScript t in tilesInRightColumn) { t.ChangeFullColor(newColor); } foreach (Vehicle v in gs.vehicleBag.FindAll(vec => (vec.channel == 3) && (vec.color == newColor))) { Debug.Log ("sarasasss"); gs.vehicleBag.Remove(v); Destroy (v.gameObject); } break; } }
void Update() { Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition); RaycastHit hitInfo; if (Physics.Raycast(ray, out hitInfo, Mathf.Infinity)) { if (hover_state == HoverState.NONE) { // -- not used, but may be useful : // -- hitInfo.collider.SendMessage("OnMouseEnter", SendMessageOptions.DontRequireReceiver); // -- hitInfo.transform.gameObject.GetComponent<TileScript>().myName = "yo"; hoverObject = hitInfo.transform.gameObject.GetComponent<TileScript>(); hoverObject.IsSelected = true; } hover_state = HoverState.HOVER; selected(); } else { if (hover_state == HoverState.HOVER) { //if (!hoverObject) { hoverObject.IsSelected = false; hoverObject.SetVisual(); //} } ///hoverObject = null; hover_state = HoverState.NONE; } }
public static bool SameTeam(TileScript atk, TileScript def) { if(atk.unit && def.unit) { return atk.GetUnitScript().GetTeam() == def.GetUnitScript().GetTeam(); } return false; }
public override bool Execute(TileScript tile) { CharacterScript enemy = tile.GetTileInhabitant(); if(enemy) { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if(distance <= range) { //int abilityCostModifier = tile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.ReduceAbilityCost); //TODO:add these back in. //- abilityCostModifier; if(player.stamina >= staminaCost ) { int damageModifier = tile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.IncreaseDamage); enemy.health -= damage + damageModifier; //+ damageModifier; //- abilityCostModifier player.stamina -= (staminaCost); Debug.Log("Hit Enemies for " + damage + " damage to " + enemy.health + " health"); GameManagerScript gm = player.gm; AudioManagerScript am = gm.gameObject.GetComponent<AudioManagerScript>(); am.PlayAudioClip(BAConstants.AudioConstants.AudioClipType.SwordHit1); return true; } } } return false; }
public override bool ValidateMove(ref int expectedStamina, TileScript expectedTilePosition, TileScript targetTile) { CharacterScript enemy = targetTile.GetTileInhabitant(); if(enemy == null) { List<Vector2> pathToTile = player.map.GetAStar().GetPathBetweenTwoTiles(expectedTilePosition,targetTile); if(pathToTile.Count > 0) { //Reduce the count cost by since it includes the movers current position. int totalStaminaCost = staminaCost * (pathToTile.Count-1); int totalAbilityCostModifier = 0; //remove target location tile since we don't need to check //for it's ability cost modifiers pathToTile.RemoveAt(pathToTile.Count-1); foreach(Vector2 tileCoordinate in pathToTile) { TileScript currentTileInPath = (TileScript)player.map.GetTiles()[tileCoordinate]; totalAbilityCostModifier += currentTileInPath.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.DecreaseAbilityCost); } if(player.stamina >= (totalStaminaCost - totalAbilityCostModifier)) { return true; } } } return false; }
void Start() { cs = this.GetComponent<CharacterScript>(); ms = this.GetComponent<MovementScript>(); likes = new ArrayList(); ts = GameObject.FindGameObjectWithTag("Grid").GetComponent<TileScript>(); }
public void GenerateMap() { GameManager.mapArray = new TileScript[(int)mapSize.x, (int)mapSize.y]; string holderName = "Generated Map"; if (transform.Find(holderName)) { DestroyImmediate(transform.Find(holderName).gameObject); } Transform mapHolder = new GameObject(holderName).transform; mapHolder.parent = transform; for (int x = 0; x < mapSize.x; x++) { for (int y = 0; y < mapSize.y; y++) { //Vector3 tilePosition = new Vector3(-mapSize.x/2 +0.5f + x, 0, -mapSize.y/2 + 0.5f + y); //Instantiate new tiles for every x and y value and set it to 0.1 scale to fit 1 unit square Vector3 tilePosition = new Vector3(x + 0.5f, 0, y + 0.5f); //Ofset tile location by 0.5f Transform newTile = Instantiate(tilePrefab, tilePosition, Quaternion.identity) as Transform; newTile.localScale = new Vector3(0.1f, 0.1f, 0.1f) * (1 - outlinePercent); newTile.parent = mapHolder; TileScript newTileScript = newTile.GetComponent <TileScript> (); newTileScript.x = x; newTileScript.y = y; GameManager.mapArray [x, y] = newTileScript; //Add each tile instantiated to the mapArray array. } } for (int x = 0; x < mapSize.x; x++) { for (int y = 0; y < mapSize.y; y++) { //Add the neighbours if (x > 0) { GameManager.mapArray [x, y].neighbours.Add(GameManager.mapArray [x - 1, y]); //Debug.Log ("Adding neighbor at " + GameManager.mapArray [x - 1, y].x + GameManager.mapArray [x - 1, y].y + " to " + x + y); } if (x < mapSize.x - 1) { GameManager.mapArray[x, y].neighbours.Add(GameManager.mapArray[x + 1, y]); } if (y > 0) { GameManager.mapArray[x, y].neighbours.Add(GameManager.mapArray[x, y - 1]); } if (y < mapSize.y - 1) { GameManager.mapArray[x, y].neighbours.Add(GameManager.mapArray[x, y + 1]); } } } }
public void FindNeighbors(float jumpHeight, TileScript target) { Reset(); CheckTile(Vector3.forward, jumpHeight, target); CheckTile(-Vector3.forward, jumpHeight, target); CheckTile(Vector3.right, jumpHeight, target); CheckTile(-Vector3.right, jumpHeight, target); }
public int hCost; // The cost to the target node public Node(TileScript parentT, Vector3 pos, int gridX, int gridZ) { parentTile = parentT; worldPos = pos; gridXLoc = gridX; gridZLoc = gridZ; connections = new List <Node>(); }
private void PlaceTile(string tileType, int x, int y, int z, Vector3 gridStart) { //parsing string to number "1" = 1 int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate(tilePrefabs[tileIndex]).GetComponent <TileScript> (); newTile.Setup(new Point(x, y, z), new Vector3(gridStart.x + ((TileSizeX / 2) * x), gridStart.y + (TileSizeY) * y), ships[z].transform.GetChild(2), true); }
public void SetTileAt(Vector2 gridPosition, int tileVal) { if (mGridManagerRef.IsWithinBounds(gridPosition)) { GameObject tile = mTileInstances[(int)gridPosition.x, (int)gridPosition.y]; TileScript script = tile.GetComponent <TileScript>(); script.SetTileTo(tileVal); } }
public void AddTile(GameObject _tile, TileTypes _type, Vector2 _position) { TileScript tileScript = _tile.GetComponent <TileScript>(); tileScript.type = _type; tileScript.position = _position; tiles.Add(tileScript); }
private void PlaceTile(string tileType, int x, int y, Vector3 worldStart) { int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate((tilePrefabs[tileIndex]).GetComponent <TileScript>(), tileParent.transform); newTile.Setup(new Point(x, y), new Vector3(worldStart.x + (TileSize * x), worldStart.y - (TileSize * y), 0), TileParent); newTile.gameObject.name = "Tile " + x.ToString() + ", " + y.ToString(); }
private void PlaceTile(string tileType, int x, int y, Vector3 worldStart) { int tileIndex = int.Parse(tileType); // Tekee uuden tilen ja viittaa siihen newTile muuttujassa TileScript newTile = Instantiate(tilePrefabs[tileIndex]).GetComponent <TileScript>(); // Käyttää newTile muuttujaa muuttaakseen tilen sijaintia newTile.Setup(new Point(x, y), new Vector3(worldStart.x + (TileSize * x), worldStart.y - (TileSize * y), 0), map); }
public void UnhighlightTile(TileScript tile) { //tile.ColorTile(tile.originalColor); tile.myAnimator.SetBool("Highlight", false); if (HighlightedTiles.Contains(tile)) { HighlightedTiles.Remove(tile); } }
public bool IsMatch(GameObject gameObject1, GameObject gameObject2) { TileScript ts1 = gameObject1.GetComponent <TileScript>(); TileScript ts2 = gameObject2.GetComponent <TileScript>(); /* if (ts1 != null && ts2 != null && type == ts1.type && type == ts2.type) * Debug.Log(type + " " + ts1.type + " " + ts2.type); */ return(ts1 != null && ts2 != null && type == ts1.type && type == ts2.type && !ts1.isSeed && !ts2.isSeed && !isSeed); }
public void ClearAboveTile() { if (tileAbove != null) { Destroy(tileAbove.gameObject); GetComponent <BoxCollider2D>().enabled = true; tileAbove = null; } }
private void PlaceTile(string tileType, int x, int y, Vector3 worldStartPos) { int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate(tilePrefab[tileIndex]).GetComponent <TileScript>(); newTile.Setup(new Point(x, y), new Vector3(worldStartPos.x + (TileSize * x), worldStartPos.y - (TileSize * y), 0), parent); // Tiles.Add(new Point(x,y), newTile); }
void Start() { regularCursor = Resources.Load("Cursor") as Texture2D; pum = GameObject.Find("PopUpMenu").GetComponent <PopUpMenuNecro>(); gm = GameObject.Find("GameManager").GetComponent <GameManager>(); gp = GameObject.Find("GameProcess").GetComponent <GameProcess>(); tiles = new GameObject[xTiles, yTiles]; //Tile Creation for (int i = 0; i < xTiles; i++) { for (int j = 0; j < yTiles; j++) { Vector3 position = new Vector3((10 * i), 0, (10 * j)); GameObject newtile = (GameObject)Instantiate(tile, position, new Quaternion(0, 0, 0, 0)); newtile.AddComponent("TileScript"); tiles[i, j] = newtile; newtile.transform.parent = this.transform; } } //loop through the array of tiles and assign neighbors accordingly for (int i = 0; i < xTiles; i++) { for (int j = 0; j < yTiles; j++) { TileScript script = tiles[i, j].GetComponent <TileScript>(); //set tile id e.g. 5,2 script.x = i; script.y = j; if (i != 0) { script.down = tiles[i - 1, j]; } if (i != xTiles - 1) { script.up = tiles[i + 1, j]; } if (j != 0) { script.right = tiles[i, j - 1]; } if (j != yTiles - 1) { script.left = tiles[i, j + 1]; } } } addRock(0, 0, 1000); addRock(8, 0, 1001); addRock(8, 8, 1002); addRock(0, 8, 1003); }
private void RpcSyncWeaponPower(Vector3 _pos, bool _value) { Point _point = VectorToPoint(_pos); TileScript _tile = LevelManager.Instance.Tiles [_point]; WeaponScript _weapon = _tile.transform.GetChild(0).GetComponent <WeaponScript> (); _weapon.ReceiveHandleCharge(_value); }
public void Initialize(TileScript _targetTile) { targetTile = _targetTile; sr = GetComponent <SpriteRenderer>(); sr.sprite = droneCompact; done = false; once = true; speed = PlayerInfo.droneSpeed; }
public void moveTo(TileScript dest) { unitScript().parentTile = dest; aboveDest = dest.Pos() + new Vector3(0f, 1f, 0f); aboveSource = unitScript().Pos() + new Vector3(0f, 0f, 0f); startTime = Time.time; doMovement = true; destination = dest; }
public List <TileScript> GetTilesWithinMovementRange(int range, TileScript tileFrom) { // iterate through every tile, and add those within range to the temp list TileScript[] allTiles = FindObjectsOfType <TileScript>(); List <TileScript> allTilesWithinXPosRange = new List <TileScript>(); List <TileScript> allTilesWithinRange = new List <TileScript>(); List <TileScript> allTilesWithinMobilityRange = new List <TileScript>(); // first, filter in all tiles with an X grid position within movement range foreach (TileScript tile in allTiles) { int myXPos = tile.GridPosition.X; if ( (myXPos >= tileFrom.GridPosition.X && (myXPos <= tileFrom.GridPosition.X + range)) || (myXPos <= tileFrom.GridPosition.X && (myXPos >= tileFrom.GridPosition.X - range)) ) { //only add tiles to the list if they are walkable and unoccupied if (tile.CanBeMovedThrough() && tile.CanBeOccupied()) { allTilesWithinXPosRange.Add(tile); } } } // second, filter out all tiles outside of Y range, then add the remainding tiles to the final list. foreach (TileScript Xtile in allTilesWithinXPosRange) { int myYPos = Xtile.GridPosition.Y; if ( (myYPos >= tileFrom.GridPosition.Y && myYPos <= tileFrom.GridPosition.Y + range) || (myYPos <= tileFrom.GridPosition.Y && (myYPos >= tileFrom.GridPosition.Y - range)) ) { allTilesWithinRange.Add(Xtile); } } // third, remove the 'fromTile' from the list allTilesWithinRange.Remove(tileFrom); // fourth, draw a path to each tile in the list, filtering the ones within mobility range foreach (TileScript tile in allTilesWithinRange) { Stack <Node> path = AStar.GetPath(tileFrom.GridPosition, tile.GridPosition); if (path.Count <= range) { allTilesWithinMobilityRange.Add(tile); } } //Debug.Log("Tiles within range: " + allTilesWithinRange.Count); return(allTilesWithinMobilityRange); }
IEnumerator AttackAnimation(CharacterScript target, bool hitLanded = false) { yield return(null); if (t0 <= 1) { LookTowards(targetRotation); } else if (t1 < 0.8) { t1 = t1 + Time.deltaTime * attackSpeed; transform.position = Vector3.Lerp(initialPos, moveDestination, t1); t2 = t1; } else { if (!hitLanded) { int damage = Mathf.Clamp((attackStrength - target.defenseStrength), 0, 999); target.currentHealth -= damage; target.Attacked(damage); hitLanded = true; audioSource.clip = SoundLibrary.instance.attackHit; audioSource.Play(); if (target.currentHealth <= 0) { // target.transform.SetParent(null); // target.gameObject.SetActive(false); Destroy(target.gameObject); } } t2 = t2 - Time.deltaTime * attackSpeed; transform.position = Vector3.Lerp(initialPos, moveDestination, t2); if (t2 <= 0) { t0 = 0; t1 = 0; animationActive = false; if (!turnFinished() && gameObject.tag == "PlayerCharacter") { TileScript playerTile = transform.parent.GetComponent <TileScript>(); UIManager.instance.HighlightReachableTiles(playerTile, currentActionPoints); } StopCoroutine(m_characterAnimation); m_characterAnimation = null; yield break; } } m_characterAnimation = StartCoroutine(AttackAnimation(target, hitLanded)); }
private void PlaceTile(string tileType, int x, int y, Vector3 worldstart) { int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate(tilePrefabs[tileIndex]).GetComponent <TileScript>(); // 타일 오브젝트를 만듬 newTile.Setup(new Point(x, y), new Vector3(worldstart.x + (Tilesize * x), worldstart.y - (Tilesize * y), 0)); // 새로운 타일에 x,y를 곱해서 일정한 간격으로 떨어뜨려 놓음 }
public void ComputeAdjacencyLists(float jumpHeight, TileScript target) { //tiles = GameObject.FindGameObjectsWithTag("Tile"); foreach (GameObject tile in tiles) { TileScript t = tile.GetComponent <TileScript>(); t.FindNeighbors(jumpHeight, target); } }
private Vector3 PlaceTile(string tileType, int x, int y, Vector3 worldStart) { int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate(tilePrefabs[tileIndex]).GetComponent <TileScript>(); newTile.Setup(new Point(x, y), new Vector3(worldStart.x + (TileSize * x), worldStart.y - (TileSize * y), 0), map); return(newTile.transform.position); }
public IEnumerator PerformTeleportCoroutine(LivingEntity caster, TileScript destination) { Ability teleport = caster.mySpellBook.GetAbilityByName("Teleport"); MovementLogic.Instance.TeleportEntity(caster, destination); OnAbilityUsed(teleport, caster); yield return(null); }
public IEnumerator PerformDashCoroutine(LivingEntity characterMoved, TileScript destination) { Ability dash = characterMoved.mySpellBook.GetAbilityByName("Dash"); MovementLogic.Instance.MoveEntity(characterMoved, destination, 6); OnAbilityUsed(dash, characterMoved); yield return(null); }
public override bool ValidateMove(ref int expectedStamina, TileScript expectedTilePosition, TileScript targetTile) { CharacterScript enemy = targetTile.GetTileInhabitant(); if(enemy) { if(enemy.characterType != player.characterType && expectedStamina >= staminaCost) { return true; } } return false; }
public override List <GameObject> showAoEAffectedTiles(TileScript tile) { List <GameObject> ret = new List <GameObject> (); if (unitLevel == 3) { rangeAoE(ret, tile, 1); } return(ret); }
private void PlaceTile(string tileType, int x, int y, Vector3 worldStart) { int tileIndex = int.Parse(tileType); //create new tile TileScript newTile = Instantiate(tilePrefabs[tileIndex]).GetComponent <TileScript>(); //change position of tile newTile.Setup(new Point(x, y), new Vector3(worldStart.x + (TileSize * x), worldStart.y - (TileSize * y), 0), map); }
private void PlaceTile(string tileType, int x, int y, Vector3 startPosition) { int tileIndex = int.Parse(tileType); TileScript newTile = Instantiate(tiles[tileIndex]).GetComponent <TileScript>(); newTile.SetUp(new GridPoint(x, y), new Vector3(startPosition.x + (TileSize * x), startPosition.y - (TileSize * y), 0), map); }
public TileScript getTile(int row, int column) { TileScript retVal = null; if (row <= m_rows - 1 && column <= m_columns - 1) { retVal = m_Grid[row, column]; } return(retVal); }
private void Update() { currentTile = snake.map.tileArray[snake.currentX, snake.currentY]; targetTile = snake.map.appleArray[0].currentTile; if (snake.map.tick) { GetPath(); MoveTroughPath(); } }
// Places the tiles where we want private void PlaceTile(int x, int y, Vector3 worldStartPosition) { // Creates a new tile and makes a reference to that tile in the NewTile TileScript newTile = Instantiate(tile).GetComponent <TileScript>(); // Uses the new tile variable to change the position of the tile newTile.GetComponent <TileScript>().Setup(new Point(x, y), new Vector3(worldStartPosition.x + (TileSize * x), worldStartPosition.y - (TileSize * y), 0), map); Tiles.Add(new Point(x, y), newTile); }
public void PlaceDefensiveContainers(int i, Vector3 startPosition) { //GameObject newTile = Instantiate(defensiveContainer); //newTile.transform.position = new Vector3(startPosition.x + WidthDefensiveContainer * i + (float)i / 2 + (float)i / 4, startPosition.y, float.Parse("-0.01")); //select prefab and click add component to add TypeScript TileScript newTile = Instantiate(defensiveContainer).GetComponent <TileScript>(); newTile.Setup(new Point(i, 0), new Vector3(startPosition.x + WidthDefensiveContainer * i + (float)i / 2 + (float)i / 4, startPosition.y, float.Parse("-0.01"))); Tiles.Add(new Point(i, 0), newTile); }
public UI Score; // Класс с работой с UI // Функкция Поиска совпадений public void FindAllMatch(TileScript tile) { Setting.swaped.Remove(tile); // Удаляем из списка свайпнутых DeleteXY(tile, new Vector2[2] { Vector2.left, Vector2.right }); // Проверка по горизонтали DeleteXY(tile, new Vector2[2] { Vector2.up, Vector2.down }); // Проверка по горизонтали }
public void tileUpCallback(TileScript tileScript) { //Debug.Log ("Up on " + tileScript.x + ", " + tileScript.y); // If we down and up on same object // "Click" if(tileDown == tileHoveredOver) { gameObject.GetComponent<Game>().SetSelectorOnTile(tileScript); } tileDown = null; }
private void updateWorldAfterAbility(TileScript atk, TileScript def) { // Check for death; if(!def || !def.unit) return; if(def.GetUnitScript().health <= 0) { def.RemoveUnit(); def.Explosion(); Game.getInstance().UnBattle(); Game.getInstance().CheckWin(); } }
// Update is called once per frame //Make the units face the right direction. void DirectionStuff(TileScript destination) { if (destination.directionToGo == TileScript.Direction.LEFT) gameObject.transform.rotation = Quaternion.Euler(0, 180, 0); else if (destination.directionToGo == TileScript.Direction.RIGHT) gameObject.transform.rotation = Quaternion.Euler(0, 0, 0); else if (destination.directionToGo == TileScript.Direction.UP) gameObject.transform.rotation = Quaternion.Euler(0, 90, 0); else if (destination.directionToGo == TileScript.Direction.DOWN) gameObject.transform.rotation = Quaternion.Euler(0, 270, 0); }
// Creating the list of tilescripts. public void createGrid (MapCreator map) { numTilesX = map.ceilX - map.floorX + 1; numTilesY = map.ceilY - map.floorY + 1; for (int y = 0; y<numTilesY; y++) { int extraTile = 1; if (y % 2 != 0) { extraTile = 0; } for (int x = 0; x<numTilesX+extraTile; x++) { bool isUsed = false; foreach (TileScript mapTile in map.getPuzzle()) { if (mapTile.getCoordinates ().getX () == x && mapTile.getCoordinates ().getY () == y) { gameGrid.Add (mapTile); isUsed = true; } } foreach (Coordinate waterCoord in map.getWaterCoordinates()) { if (waterCoord.getX () == x && waterCoord.getY () == y) { TileScript waterTile = new TileScript (new Coordinate (x, y), "Water"); gameGrid.Add (waterTile); isUsed = true; } } if (!isUsed) { TileScript tile = new TileScript (new Coordinate (x, y), "Grass"); gameGrid.Add (tile); } } } }
void StartLevel() { //-- set the characters current tile m_CurrentTile = levelManager.GetTile(MoveDirection.MoveLeft, LaneNumber.LeftCenter, 0); m_TileSizeScaled = levelManager.spriteScaledSize; //-- pass the scaled tile size as the move distance m_PlayerController.SetMoveDistance(m_TileSizeScaled); //-- set the character position m_PlayerController.transform.position = m_CurrentTile.transform.position; m_PlayerController.SetCurrentIKTarget(m_CurrentTile.ikTarget); m_PlayerController.ApplyIKTarget(m_CurrentTile.ikTarget); }
public override bool Execute(TileScript tile) { switch(player.characterType) { case CharacterConstants.CharacterType.player: { List<Vector2> path = player.map.GetAStar().GetPathBetweenTwoTiles(player.currentTile,tile); if(path.Count > 0) { //Reduce the count cost by since it includes the movers current position. int totalStaminaCost = staminaCost * (path.Count-1); int totalAbilityCostModifier = 0; //remove target location tile since we don't need to check //for it's ability cost modifiers path.RemoveAt(path.Count-1); foreach(Vector2 tileCoordinate in path) { TileScript currentTileInPath = (TileScript)player.map.GetTiles()[tileCoordinate]; totalAbilityCostModifier += currentTileInPath.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.DecreaseAbilityCost); } if(player.stamina >= (totalStaminaCost - totalAbilityCostModifier)) { player.map.MoveCharacterToTileCoordinate(player,tile); player.stamina -= (totalStaminaCost - totalAbilityCostModifier); //JONATHAN: PLAYER MOVES HERE return true; } } break; } case CharacterConstants.CharacterType.enemy: { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if( distance - 1 <= range) { int abilityCostModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.IncreaseEnemyAbilityCost); if(player.stamina >= (staminaCost + abilityCostModifier)) { player.map.MoveCharacterToTileCoordinate(player,tile); player.stamina -= (staminaCost + abilityCostModifier); AudioManagerScript am = player.gm.gameObject.GetComponent<AudioManagerScript>(); am.PlayAudioClip(BAConstants.AudioConstants.AudioClipType.EnemyWalk); //JONATHAN: ENEMY MOVES HERE return true; } } break; } } return false; }
// Returns a start tile on a random position inside the board. public TileScript getSartTile () { int startY = (int)Mathf.Floor (Random.Range (0, mapHeight)); int extra = oneIfEven (startY); int startX = (int)Mathf.Floor (Random.Range (0, mapWidth + extra)); Coordinate startTileCoordinate = new Coordinate (startX, startY); TileScript res = new TileScript (startTileCoordinate, "Start"); return res; }
public override bool Execute(TileScript tile) { CharacterScript enemy = tile.GetTileInhabitant(); if(enemy) { switch(player.characterType) { case CharacterConstants.CharacterType.player: { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if(distance <= range) { int abilityCostModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.DecreaseAbilityCost); if(player.stamina >= staminaCost - abilityCostModifier) { int damageModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.IncreaseDamage); enemy.health -= (damage + damageModifier); player.stamina -= (staminaCost - abilityCostModifier); Debug.Log("Hitting Enemy for " + damage + " damage to " + enemy.health + " health"); GameManagerScript gm = player.gm; AudioManagerScript am = gm.gameObject.GetComponent<AudioManagerScript>(); am.PlayAudioClip(BAConstants.AudioConstants.AudioClipType.SwordHit1); return true; } } break; } case CharacterConstants.CharacterType.enemy: { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if(distance <= range) { int increaseAbilityCostModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.IncreaseEnemyAbilityCost); if(player.stamina >= staminaCost + increaseAbilityCostModifier) { int decreaseDamageModifier = player.currentTile.GetNumOfFavorEffectsInTile(ConstantsScript.TileFavorEffect.DecreaseEnemyDamage); enemy.health -= (damage - decreaseDamageModifier); player.stamina -= (staminaCost + increaseAbilityCostModifier); Debug.Log("Hitting Player for " + damage + " damage to " + enemy.health + " health"); GameManagerScript gm = player.gm; AudioManagerScript am = gm.gameObject.GetComponent<AudioManagerScript>(); am.PlayAudioClip(BAConstants.AudioConstants.AudioClipType.EnemyAttack); //JONATHAN: ENEMY HITS PLAYER HERE. return true; } } break; } } } return false; }
public override bool Execute(TileScript tile) { CharacterScript enemy = tile.GetTileInhabitant(); if(enemy) { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if( distance <= range) { if(player.stamina >= staminaCost) { enemy.health -= damage; player.stamina -= staminaCost; Debug.Log("Throwing Rock at Player for " + damage + " damage to " + enemy.health + " health"); return true; } } } return false; }
public override bool Execute(TileScript tile) { CharacterScript enemy = tile.GetTileInhabitant(); if(enemy) { int distance = player.map.GetAStar().GetRangeBetweenTwoTiles(player.currentTile,tile); if( distance <= range) { if(player.stamina >= staminaCost) { enemy.health -= damage; player.stamina -= staminaCost; //TODO: push enemy 1 hex away from player Debug.Log("Pushing player"); return true; } } } return false; }
public void selectedTile(TileScript tile) { print("selected a tile"); if (tile1 == null && tile.entity == null) return; if (tile1 == tile) { tile1.transform.localScale /= 1.1f; tile1 = null; return; } if (tile1 == null) { print("Tile 1 Set"); tile1 = tile; tile1.transform.localScale *= 1.1f; SoundPlayer.instance.playRandomBeep(); return; } if (tile2 == null) { if ((tile.tileCoord - tile1.tileCoord).magnitude > Vector2.up.magnitude) { print("Tiles too far away"); tile1.transform.localScale /= 1.1f; tile1 = null; return; } tile1.transform.localScale /= 1.1f; print("Tile 2 Set"); tile2 = tile; swapTiles(); } }
public void DeselectTile(TileScript tileScript) { foreach(TileScript t in markedTiles) { Object.Destroy(t.marker); } for(int x = 0; x < tileMap.width; x++) { for(int y = 0; y < tileMap.height; y++) { TileScript t = tileMap.At (x,y); t.marker = null; t.dist = 999999; t.visited = false; } } markedTiles.Clear(); unVisitedTiles.Clear(); visitedTiles.Clear(); if(mySelector) mySelector.transform.position = new Vector3(0f, -400f, 0f); Game.getInstance().RefreshUnitDescriptions(); }
public List<GameObject> canUseAbilityOn(TileScript attacker) { if(!attacker.unit) return new List<GameObject>(); List<GameObject> list = new List<GameObject>(); TileMap tileMap = gameObject.GetComponent<TileMap>(); int range = attacker.GetUnitScript().atkRange; int minX = Mathf.Max(attacker.x - range, 0); int maxX = Mathf.Min(attacker.x + range+1, tileMap.width-1); int minY = Mathf.Max(attacker.y - range, 0); int maxY = Mathf.Min(attacker.y + range+1, tileMap.height-1); // Calculate which tiles to call 'attackable' for(int i = minX; i <= maxX; i++) { for(int j = minY; j <= maxY; j++) { TileScript dest = tileMap.At (i, j); if(i == attacker.x && j == attacker.y) continue; if(distBetween(attacker, dest) > range) continue; if (dest.specialTerrain && dest.specialTerrain.name == "Tree") { // Can only attack someone in a tree if you are next to them. if (distBetween(attacker, dest) > 1) continue; } if(dest.unit) { // thats for attack only //if(attacker.GetUnitScript().GetTeam() == dest.GetUnitScript().GetTeam()) continue; list.Add(dest.gameObject); } } } return list; }
// for factories public int createUnitAt(TileScript atk, UnitScript factory, string type) { bool unitBefore = (atk.unit != null); // if so, return 0 to say "this ability failed so don't charge me action points if(unitBefore) { Game.getInstance().consoleString = "There's already a unit at Factory."; return 0; } if(factory.GetTeam() == 0) team1.TryGetValue(type, out type); else team2.TryGetValue(type, out type); GameObject unit = UnitFactory.getInstance().create(type); Game.getInstance().SpawnUnitAt(atk.x, atk.y, factory.GetTeam(), unit); return 1; }
public override bool Execute(TileScript tile) { //player has selected a position to move to and we return true; }
void swapTiles() { print("Swapping Tile Entities"); SoundPlayer.instance.playRandomWoosh(); if (tile1.entity != null) { tile1.entity.tile = tile2; tile1.entity.transform.parent = tile2.transform; utils.moveTo(tile1.entity.transform, tile2.transform.position, 0.3f, null); } if (tile2.entity != null) { tile2.entity.tile = tile1; tile2.entity.transform.parent = tile1.transform; utils.moveTo(tile2.entity.transform, tile1.transform.position, 0.3f, null); } Entity temp = tile1.entity; tile1.entity = tile2.entity; tile2.entity = temp; tile1 = null; tile2 = null; utils.delay(map.evaluateSystem, .35f); }
/** * Initializes the list of tiles * Generates the game grid */ public override void Start() { if (grid == null) { grid = this; } else if (grid != this) { Destroy(gameObject); } tiles = new Tile[gridX * gridY]; }