//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];
}
