public float Reload(TowerController towerController)
{
float reloadPrice = towerService.Reload(towerController.Model);
towerController.UpdateView();
return(reloadPrice);
}
public void setCurrentTowerInfo(TowerController towerController)
{
controller = towerController;
Name.text = towerController.attribute.Name;
ATK.text = towerController.attribute.MinATK + "-" + towerController.attribute.MaxATK;
spawnShoot.text = towerController.attribute.SpawnShoot.ToString();
timeBuild.text = towerController.attribute.TimeBuild.ToString();
//Check bonus
if (ItemManager.Instance.listItemState.Contains(EItemState.ATK))
{
ATK.text += " [8aff5c]+ " + towerController.Bonus.ATK + "[-]";
}
if (ItemManager.Instance.listItemState.Contains(EItemState.SPAWN_SHOOT))
{
spawnShoot.text += " [8aff5c]- " + towerController.Bonus.SpawnShoot + "[-]";
}
if (ItemManager.Instance.listItemState.Contains(EItemState.RANGE))
{
PlayManager playManager = PlayManager.Instance;
playManager.rangeTowerBonus.transform.position = playManager.rangeTower.transform.position;
float scale = (float)(controller.attribute.Range + controller.Bonus.Range) / 100f;
playManager.rangeTowerBonus.transform.localScale = new Vector3(scale, scale, 0);
playManager.rangeTowerBonus.SetActive(true);
((SphereCollider)controller.collider).radius = controller.attribute.Range + controller.Bonus.Range;
}
}
public static ProjectileController CreateProjectile(TowerController towerController, Projectile model, ProjectileType type)
{
GameObject prefab = null;
switch (type)
{
case ProjectileType.ROCK:
prefab = instance.rockProjectilePrefab;
break;
case ProjectileType.FIREBALL:
prefab = instance.fireballProjectilePrefab;
break;
}
GameObject projectile = Instantiate(
prefab,
towerController.View.transform.position,
towerController.View.transform.rotation);
ProjectileView view = projectile.GetComponent <ProjectileView>();
ProjectileController controller = new ProjectileController(model, view);
view.Controller = controller;
return(controller);
}
private void Awake()
{
gc = FindObjectOfType <GameController>();
//rend = GetComponent<SpriteRenderer>();
startPos = transform.localPosition;
parent = transform.parent.GetComponent <TowerController>();
}
public void UpdateState(TowerSpawnerViewModel data)
{
if (towerProjection != null)
{
Destroy(towerProjection);
}
Tower model = ElementalTowerDefenseModel.TowerFactory.CreateTower(data.TowerType);
TowerController controller
= TowerFactory.CreateTower(
data.TowerType,
model,
null,
out towerProjection);
towerProjection.GetComponent <Rigidbody>().detectCollisions = false;
towerProjection.GetComponent <TowerView>().enabled = false;
towerProjection.transform.parent = gameObject.transform;
transform.GetChild(0).transform.localScale = new Vector3(
model.Range.Points * 2,
model.Range.Points * 2,
model.Range.Points * 2);
spawnerView.IsInSpawnMode = data.IsInSpawnMode;
if (!IsInSpawnMode)
{
SetProjectionVisibility(false);
}
}
private void SimulateModifier(TowerController towerController, Card card)
{
if (card.propertyModifiers[0] != PropertyModifier.None)
{
DispatchSimulateTowerModifierRequestEvent(towerController, card.propertyModifiers, card.propertyModifierValues);
}
}
private void AddMultipliers(Tile hoverTile, PropertyModifier[] propertyModifiers, float[] propertyModifierValues, float duration)
{
TowerController tower = towersPlaced[hoverTile];
if (tower == null)
{
towersPlaced.Remove(hoverTile);
return;
}
for (int i = 0; i < propertyModifiers.Length; i++)
{
switch (propertyModifiers[i])
{
case PropertyModifier.Damage:
tower.propertyModifierHandler.AddProjectileDamageMultiplier(propertyModifierValues[i] / 100, duration);
break;
case PropertyModifier.FireRate:
tower.propertyModifierHandler.AddFireRateMultiplier(propertyModifierValues[i] / 100, duration);
break;
case PropertyModifier.AOE:
tower.propertyModifierHandler.AddAOEMultiplier(propertyModifierValues[i] / 100, duration);
break;
case PropertyModifier.Range:
tower.propertyModifierHandler.AddProjectileSpeedMultiplier(propertyModifierValues[i] / 100, duration);
break;
}
}
DispatchPropertyModifiersAppliedEvent(tower.propertyModifierHandler, propertyModifiers);
}
public void AddTower(Cell cell) //adds a tower to the specified cell; this process recylces the towers rather than destroying and reinstantiating them (yes, efficiency)
{
print(towerQ.Count);
int numberOfTowersFound = towerQ.Count; //should be the number of towers in the scene as the queue is modified
Vector3 yIncrease = new Vector3(0f, 3f, 0f); //correction for placement
if (numberOfTowersFound < towerMaxLimit) //only add towers if we have less than the set limit
{
TowerController newTower = Instantiate(tower, cell.transform.position + yIncrease, Quaternion.identity); //add a tower on that cell if possible, this tower is stored in a variable
//the tower is instantiated inside the block rather than on it, so it is instantiated just above it by adding the yIncrease vector
newTower.transform.parent = objectParent.transform; //where the parent of the object is set
newTower.placedOn = cell; //the tower will know what cell is has been placed on
cell.available = false; //cannot place another tower on the same block
towerQ.Enqueue(newTower); //enqueue the instantiated tower
}
else //otherwise move earliest placed existing tower to new chosen cell and update data
{
var earliestPlacedTower = towerQ.Dequeue(); //remove the tower (one that was placed earliest) off front the queue
//when moving the oldest tower, we need to know what became available and what is not available anymore
earliestPlacedTower.placedOn.available = true;
cell.available = false;
earliestPlacedTower.placedOn = cell; //update the cell that the moved tower is now placed on
earliestPlacedTower.transform.position = cell.transform.position + yIncrease; //actually move the tower to the new cell
towerQ.Enqueue(earliestPlacedTower); //readd the tower to the back of the queue (meaning this tower is the most recently placed one)
}
}
public void Upgrade(int level)
{
TowerController tc = GetComponent <TowerController>();
tc.Price = (int)_stats[level, 0];
tc.Range = _stats[level, 1];
tc.AttackCooldown = _stats[level, 2];
tc.Damage = _stats[level, 3];
tc.Level = (int)_stats[level, 4];
tc.ProjectileSpeed = _stats[level, 5];
tc.Slow = _stats[level, 6];
if (!(level + 1 > 3))
{
tc.UpgradePrice = (int)_stats[level + 1, 0];
}
else
{
tc.UpgradePrice = 0;
}
tc.TotalPrice += (int)_stats[level, 0];
UIManager.Instance.SetTowerStats(tc);
}
void Start()
{
Agent = GetComponent <NavMeshAgent>();
TargetLocation = Target.transform.position;
towerController = GameObject.Find("EnemyTower").GetComponent <TowerController>();
SetTarget(TargetLocation);
}
public void Render()
{
TowerController.Render();
EnemyController.Render();
ProjectileController.Render();
Statistics.Render();
}
public void UpgradeTower()
{
SpotState spotState = currentSpot.GetComponent<SpotState>();
towerController = spotState.towerPlaced.GetComponent<TowerController> ();
if (gameManager.money >= towerController.upgradeCosts[towerController.currLevel - 1]) {
if (towerController.currLevel < towerController.damages.Length) {
towerController.currLevel += 1;
towerController.gameObject.GetComponent<SphereCollider>().radius = towerController.radiuses[towerController.currLevel - 1];
towerController.projector.GetComponent<Projector>().orthographicSize = towerController.radiuses[towerController.currLevel - 1];
towerController.projector.SetActive(false);
gameManager.money -= towerController.upgradeCosts[towerController.currLevel - 1];
currentSpot = null;
placed = true;
showPanels.addPanel.SetActive(false);
showPanels.upgradePanel.SetActive(false);
//addPanel.GetComponent<RectTransform>().position = new Vector2(Screen.currentResolution.width + 200, Screen.currentResolution.height + 200);
//upgradePanel.GetComponent<RectTransform> ().position = new Vector2 (Screen.currentResolution.width + 200, Screen.currentResolution.height + 200);
poppedUp = false;
}
else {
Debug.Log("Maximum Level Reached");
}
}
else {
Debug.Log("Not enough money");
}
}
private void OnDestroy()
{
if (TowerController.HasInstance())
{
TowerController.Instance.OnMoveTower -= OnMove;
}
}
public static int GetUnitCountForFaction(int faction)
{
int unitsFromTowers = TowerController.GetUnitCountFromTowersForFaction(faction);
int unitsFromGroups = GetFieldUnitCountForFaction(faction);
return(unitsFromGroups + unitsFromTowers);
}
public static TowerController CreateTower(TowerType type, Tower model, TowerSpawnerController spawnerController, out GameObject gameObject)
{
GameObject towerInstance = null;
GameObject prefab = null;
switch (type)
{
case TowerType.EARTH_TOWER:
prefab = instance.earthTowerPrefab;
break;
case TowerType.FIRE_TOWER:
prefab = instance.fireTowerPrefab;
break;
}
towerInstance = Instantiate(prefab, instance.spawner.transform.position, instance.spawner.transform.rotation);
TowerView view = towerInstance.GetComponent <TowerView>();
TowerController controller = new TowerController(model, view, spawnerController);
view.Controller = controller;
controller.UpdateView();
gameObject = towerInstance;
return(controller);
}
/// <summary>
/// Called when a unit is to enter/attack this tower.
/// See documenation for full explaination and metrics.
/// If unit is friendly, stationed units is increased.
/// Raises ChangedFaction and AttackedByUnit events.
/// </summary>
/// <param name="unit">Unit.</param>
public void UnitEntered(UnitBehavior unit)
{
if (unit.Faction == Faction)
{
// Friendly units are transfered to this towers group
unit.TransferGroup(stationedGroup);
unit.gameObject.SetActive(false);
}
else
{
// Hostile units damage this towers stationed unit group
int strength = FactionController.GetAttackStrengthForFaction(unit.Faction);
stationedGroup.Damage(strength);
// Change tower's faction if last unit was killed
if (stationedGroup.Empty)
{
TowerController.ConvertTowerToFaction(this, unit.Faction);
if (ChangedFaction != null)
{
ChangedFaction(Faction);
SetGraphic();
}
}
unit.ImpactKill();
if (AttackedByUnit != null)
{
AttackedByUnit(unit);
}
}
}
void Start()
{
_towerExist = false;
_confirmed = false;
_towerIndex = -1;
_clearBeforeBattle = false;
_currentTowerType = -1;
_levelManager = GameManager.Instance.CurrentLevelManager;
_gameBoard = _levelManager.GameBoardSystem;
_towerController = TowerController.Instance;
_towerBuildPanel = TowerBuildPanel.Instance;
_towerOperationPanel = TowerOperationPanel.Instance;
_towerInfoPanel = TowerInfoPanel.Instance;
_buildCheckPanel = BuildCheckPanel.Instance;
_notificationPanel = NotificationPanel.Instance;
_tankTowerButton = TankTowerButton.Instance;
_rangeTowerButton = RangeTowerButton.Instance;
_slowTowerButton = SlowTowerButton.Instance;
_healTowerButton = HealTowerButton.Instance;
_goldTowerButton = GoldTowerButton.Instance;
_upgradeButton = UpgradeButton.Instance;
_repairButton = RepairButton.Instance;
_sellButton = SellButton.Instance;
_yesButton = BCP_Yes.Instance;
TowerOperation = Operation.Nop;
}
// Update is called once per frame
void Update()
{
// DEBUG
if (Target == null)
{
Target = FindObjectOfType <TowerManager>().enemyTowers[0].GetComponent <TowerController>();
}
float distanceToTarget = Vector3.Distance(Target.gameObject.transform.position, this.gameObject.transform.position);
if (distanceToTarget < 0.1)
{
// End
Debug.Log("Im There");
return;
}
Vector3 vectorToTarget = Target.gameObject.transform.position - this.gameObject.transform.position;
gameObject.transform.position += vectorToTarget.normalized * speed;
Debug.Log("Angle: " + Vector3.Angle(Vector3.up, Target.gameObject.transform.position - this.gameObject.transform.position));
// gameObject.transform.rotation = Vector3.Angle(Vector3.up, Target.gameObject.transform.position - this.gameObject.transform.position));
gameObject.transform.rotation = Quaternion.FromToRotation(Vector3.up, Target.gameObject.transform.position - this.gameObject.transform.position);
gameObject.transform.RotateAround(gameObject.transform.position, new Vector3(0, 0, 1),
Mathf.Sin(Vector3.Distance(Target.gameObject.transform.position, this.gameObject.transform.position)) * 10);
}
public void UpgradeTower()
{
if (_currentTower == null)
{
return;
}
TowerController tc = _currentTower.GetComponent <TowerController>();
if (UIManager.Instance.Currency - tc.UpgradePrice < 0)
{
Debug.Log("Not enough money");
return;
}
UIManager.Instance.Currency -= tc.UpgradePrice;
tc.Upgrade();
Debug.Log(tc.Level);
_currentTower.transform.GetChild(tc.Level).GetComponent <SpriteRenderer>().enabled = true;
if (tc.Level <= 3)
{
return;
}
Debug.Log("MAX LEVEL");
UIManager.Instance.UpgradeBtn.gameObject.SetActive(false);
}
// Update is called once per frame
void Update()
{
int horizontal = 0;
int vertical = 0;
horizontal = (int)Input.GetAxisRaw("Horizontal");
vertical = (int)Input.GetAxisRaw("Vertical");
if (horizontal != 0)
{
vertical = 0;
}
if (horizontal != 0 || vertical != 0)
{
RaycastHit2D hit;
MoveObject(horizontal, vertical, out hit);
}
if (Input.GetKeyDown("space"))
{
TowerController tower = GetComponentInChildren <TowerController>();
tower.FireEvent("Player");
}
if (life == 0)
{
Destroy(this.gameObject);
SceneManager.LoadScene("Lose");
}
}
private void Update()
{
if (selectedTower != null)
{
upgradeButtonText.text = "lvl: " + Convert.ToString(selectedTower.lvl) + "\nUpgrade: " + Convert.ToString(selectedTower.upgradeGold) + " gold";
}
if (Input.GetMouseButtonDown(0))
{
Vector3 mousePos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
Vector2 mousePos2D = new Vector2(mousePos.x, mousePos.y);
RaycastHit2D hit = Physics2D.Raycast(mousePos2D, Vector2.zero);
if (hit.transform != null)
{
if (hit.transform.gameObject.tag == "Tower")
{
selectedTower = hit.transform.gameObject.GetComponent <TowerController>();
isSelectTower = true;
}
else if (hit.transform.gameObject.tag == "UpgradeTowerButton")
{
if (selectedTower != null)
{
isSelectTower = true;
}
}
else
{
isSelectTower = false;
}
}
else
{
isSelectTower = false;
}
}
if (isSelectTower)
{
upgradeButton.SetActive(true);
}
else
{
upgradeButton.SetActive(false);
}
UIgold.text = Convert.ToString(gold);
UIhp.text = Convert.ToString(hp);
UIpoints.text = Convert.ToString(points);
if (hp <= 0)
{
GameOver();
}
if (waveSpawnTime + timeBetweenWaves <= Time.time)
{
int enemiesInWave = UnityEngine.Random.Range(waveNuber, waveNuber + X);
StartCoroutine(SpawnWave(enemiesInWave));
}
}
IEnumerator CheckIfBlockGoal(EnemyController testPath, TowerController tower, Vector3Int cell, float waitTime)
{
yield return(new WaitForSeconds(waitTime));
testPath.agent.CalculatePath(goalTransform.position, path);
if (testPath.CheckPath(path))
{
GameManager.AddMoney(-tower.tower.buildCost);
}
else
{
Destroy(tower.gameObject);
failCount++;
GameManager.AddMoney(Mathf.Min(-10 * failCount, 0));
towers.Remove(cell);
Debug.Log("Would block goal");
}
testPath.gameObject.SetActive(false);
//SpawnController.spawnController.PathEnemiesToGoal();
}
/// <summary>
/// Attempt to add a non-combo tower to a new combo.
///
/// If the # of non-combo towers selected is >=2, will create a new combo automatically and clear mid-combo state.
/// </summary>
/// <param name="tower"></param>
public void AddToTowersBeingCombod(TowerController tower)
{
towersBeingCombod.Add(tower);
tower.IsBeingCombod = true;
if (towersBeingCombod.Count > 1)
{
TowerController towerController0 = towersBeingCombod[0];
TowerController towerController1 = towersBeingCombod[1];
TowerController additionalTower;
ComboTowerController?combo = CreateCombo(towerController0, towerController1);
if (combo == null)
{
// Invalid combo atm. Continue keeping things in "mid combo" state.
// TODO: How to handle first two towers being valid but subsequent towers after 2nd tower making invalid?
return;
}
for (int i = 2; i < towersBeingCombod.Count; i++)
{
additionalTower = towersBeingCombod[i];
combo.AddTowerToCombo(additionalTower);
}
print($"ComboTowerController: {combo}");
ClearTowersBeingCombod(false);
}
}
void SoldierDead(GameObject gameObject, TowerController tower)
{
if (tower == this)
{
targets.Remove(gameObject);
}
}
public static MeshRenderer FindCorrectMeshRendererForProperty(TowerController tower, PropertyModifier[] propertyModifiers)
{
MeshRenderer meshRenderer = null;
switch (propertyModifiers[0])
{
case PropertyModifier.AOE:
case PropertyModifier.Range:
meshRenderer = tower.TowerBaseRenderer;
break;
case PropertyModifier.Damage:
meshRenderer = tower.TowerTurretRenderer;
break;
case PropertyModifier.ProjectileSpeed:
case PropertyModifier.FireRate:
meshRenderer = tower.TowerBarrelRenderer;
break;
}
if (meshRenderer == null)
{
meshRenderer = tower.TowerBaseRenderer;
}
return(meshRenderer);
}
public void BindInstance(GameObject instance, Button button)
{
TowerInstance = instance;
TowerButton = button;
towerController = instance.GetComponent <TowerController>();
towerController.tower = this;
}
private void OnTriggerStay2D(Collider2D collision)
{
//rotate
Vector3 targ = collision.transform.position;
targ.z = 0f;
Vector3 objectPos = transform.position;
targ.x = targ.x - objectPos.x;
targ.y = targ.y - objectPos.y;
float angle = Mathf.Atan2(targ.y, targ.x) * Mathf.Rad2Deg;
transform.rotation = Quaternion.Euler(new Vector3(0, 0, angle));
if (moveTo.x == 0 && moveTo.y == 0 && collision.tag == "Turret")
{
Vector2 temp = offset(collision.transform.position, transform.position);
moveTo.x = temp.x;
moveTo.y = temp.y;
Vector3 lookingAt = new Vector3(collision.transform.localPosition.x, collision.transform.localPosition.y, 0);
transform.LookAt(lookingAt);
this.CurrentTarget = collision.GetComponent <TowerController>();
}
}
// Use this for initialization
void Start()
{
turretHealthUI = GetComponentsInChildren<Image>();
//activeTurretMarker = transform.Find("Marker").GetComponent<Image>();
if(!towerController)
towerController = transform.Find("Towers").GetComponent<TowerController>();
}
public float Sell(TowerController towerController)
{
float sellPrice = towerService.Sell(towerController.Model);
controllers.Remove(towerController);
return(sellPrice);
}
void CheckResult()
{
// Victory condition to be move to separate class.
int playerTowerCount = TowerController.GetTowerCountForFaction(FactionController.PlayerFaction);
int playerUnitCount = UnitController.GetFieldUnitCountForFaction(FactionController.PlayerFaction);
int enemyUnitCount = UnitController.GetFieldUnitCountForFaction(FactionController.OtherFaction1);
int enemyTowerCount = TowerController.GetTowerCountForFaction(FactionController.OtherFaction1);
//Debug.Log("Player (Towers:" + playerTowerCount + " | Units:" + playerUnitCount);
//Debug.Log("Enemy (Towers:" + enemyTowerCount + " | Units:" + enemyUnitCount);
if (enemyTowerCount == 0 && enemyUnitCount == 0)
{
LevelController.EndLevel();
if (routine != null)
{
StopCoroutine(routine);
}
}
else if (playerTowerCount == 0 && playerUnitCount == 0)
{
LevelController.EndLevel(false);
if (routine != null)
{
StopCoroutine(routine);
}
}
if (routine == null)
{
routine = StartCoroutine(RedundantCheckResult());
}
}
protected override void Start()
{
base.Start();
myFirstName = "Tower";
offenseLayer = 9;
towerController = GetComponent <TowerController>();
}
/// <summary>
/// Attempts to create a new tower. Will return bool representing success.
/// </summary>
/// <param name="spell"></param>
/// <param name="towerSlotTransform"></param>
/// <returns>True if tower was created. False if something failed like not being able to afford the price/</returns>
public bool CreateTower(Spell spell, Transform towerSlotTransform)
{
int towerPrice = spell.TowerPrice;
print(playerState);
print(towerPrice);
if (!playerState.CanAffordPurchase(towerPrice))
{
return(false);
}
playerState.DeductPoints(towerPrice);
GameObject tower = Instantiate(towerPrefab, towerSlotTransform);
tower.layer = Layers.Friendly;
Material spellMaterial = spell.InstancePrefab.GetComponent <Renderer>().sharedMaterial;
UpdateTowerColor(tower.transform, spellMaterial);
TowerController towerController = tower.GetComponent <TowerController>();
towerController.SetAbility(spell);
towerControllers.Add(towerController);
towerToController.Add(tower, towerController);
controllerToTower.Add(towerController, tower);
return(true);
}
void OnTriggerExit(Collider c)
{
if (c.gameObject.tag == "Tower") {
towerController = c.gameObject.GetComponent<TowerController> ();
if (this == towerController.target) {
towerController.target = null;
}
}
}
void OnTriggerStay(Collider c)
{
if (c.gameObject.tag == "Tower") {
towerController = c.gameObject.GetComponent<TowerController>();
if (towerController.target == null) {
towerController.target = this;
}
}
}
public void Initialize(TowerController _TowerController) {
GenRangeDisplay (_TowerController.TowerRange);
TowerSprite.sprite = _TowerController.TowerImage.sprite;
TowerPrefab = _TowerController.gameObject;
Update ();
gameObject.SetActive (true);
}
// Use this for initialization
void Start () {
if(this.gameObject.transform.parent.transform.parent.gameObject.GetComponent<Buttons_Clicked>().isClicked(this.gameObject.name)==true){//---------------------------------
GameObject unclickeable = Instantiate(Resources.Load("Buttons/Unclickeable"), this.transform.position , Quaternion.identity)as GameObject;
unclickeable.transform.parent = this.transform.parent;
Destroy(this.gameObject);
}else{
instancer = this.gameObject.transform.parent.transform.parent.GetComponent<TowerController>();
masterPoint = GameObject.Find("Master_Instance").GetComponent<Master_Instance>();
if(masterPoint.countMoney()<masterPoint.getPrice(this.gameObject)){master.isHide(this.gameObject);}//---------------------------------prices
aux = GetComponent<SpriteRenderer>().sprite;
master.setLayer("interface",this.gameObject);
}
}
public void SetTower(TowerController tower)
{
_towerController = tower;
if (_towerController.Level == TowerController.MAX_TOWER_LEVEL)
{
SpriteRenderer sr = _upgradeButton.GetComponent<SpriteRenderer>();
SetDisabledView(sr);
SetDisabledView(_upgradeLabel);
_upgradeButton.enabled = false;
}
if (_towerController is KT_Controller || _towerController is CannonTowerController)
_flagButton.SetActive(true);
}
// Use this for initialization
void Start () {
tower = GameObject.FindGameObjectWithTag ("tower");
<<<<<<< HEAD
Debug.Log(tower);
=======
>>>>>>> cd3c54cdc1382c9281f8215a0e5df8fe489c3d23
pie = tower.GetComponent<PieSliceSensor> ();
cont = tower.GetComponent<TowerController> ();
rec = new Recorder ();
time = Time.time;
<<<<<<< HEAD
if (File.Exists(@rec.outputFile))
File.Delete(@rec.outputFile);
}
public void Init()
{
if (!isLocalPlayer)
{
Object.Destroy(mainCamera.gameObject);
}
else
{
terrainCollider = GetComponentInParent<TerrainCollider>();
bulletsEmiter = GetComponentInChildren<BulletsEmiter>();
towerController = GetComponentInChildren<TowerController>();
movementController = GetComponentInChildren<MovementController>();
}
}
public void SetDescriptionValues(TowerController _TowerController) {
TowerNameText.text = _TowerController.TowerName;
ProjectileController _ProjectileController = _TowerController.ProjectilePrefab.GetComponent<ProjectileController>();
MoreDamageToText.text = "+50% damage to " + VictimTypeToString(_ProjectileController.StrongerAgainst);
LessDamageToText.text = "-50% damage to " + VictimTypeToString(_ProjectileController.WeakerAgainst);
ProjectileAbilityText.text = _ProjectileController.ProjectileAbility;
DescriptionValuesText.text =
"$" + _TowerController.Price.ToString () + "\n"
+ _TowerController.Damage.ToString ("F0");
}
public virtual void Start()
{
towerController = GetComponent<TowerController>();
towerAnimation = GetComponentInChildren<TowerAnimation>();
elaspedTime = towerController.attribute.SpawnShoot + 1;
enemyArray = new ArrayList();
SphereCollider collider = (SphereCollider)gameObject.collider;
collider.radius = towerController.attribute.Range;
isShooting = false;
isActivity = false;
isUpdateStart = false;
hasEnemy = false;
positionAnimation = towerAnimation.transform.localPosition;
StartCoroutine(building());
}
// set info tower
public void setTowerInfo(TowerController towerController)
{
isOnTowerInfo = true;
childTowerInfo.SetActive(true);
if(childDragonInfo != null)
childDragonInfo.SetActive(false);
controller = towerController;
sellLabel.text = (towerController.totalMoney / 2).ToString();
Name.text = towerController.attribute.Name;
ATK.text = towerController.attribute.MinATK + "-" + towerController.attribute.MaxATK;
spawnShoot.text = towerController.attribute.SpawnShoot.ToString();
timeBuild.text = towerController.attribute.TimeBuild.ToString();
ATK.parent.transform.GetComponentInChildren<UISprite> ().spriteName = "icon-atk";
//Set color tower name
Color[] colors = PlayConfig.getColorTowerName(towerController.ID);
Name.color = colors[0];
Name.effectColor = colors[1];
if(towerController.nextLevel == null)
{
//Khóa upgrade
lockUpgrade(true);
isLock = true;
}
else
upgradeLabel.text = towerController.nextLevel.attribute.Cost.ToString();
//Check bonus
if(ItemManager.Instance.listItemState.Contains(EItemState.ATK))
ATK.text += " [8aff5c]+ " + towerController.Bonus.ATK + "[-]";
if(ItemManager.Instance.listItemState.Contains(EItemState.SPAWN_SHOOT))
spawnShoot.text += " [8aff5c]- " + towerController.Bonus.SpawnShoot + "[-]";
if(ItemManager.Instance.listItemState.Contains(EItemState.RANGE))
{
PlayManager playManager = PlayManager.Instance;
playManager.rangeTowerBonus.transform.position = playManager.rangeTower.transform.position;
float scale = (float)(towerController.attribute.Range + towerController.Bonus.Range) / 100f;
playManager.rangeTowerBonus.transform.localScale = new Vector3(scale, scale, 0);
playManager.rangeTowerBonus.SetActive(true);
((SphereCollider)controller.collider).radius = controller.attribute.Range + controller.Bonus.Range;
}
}
void Start()
{
panelTween = PlayManager.Instance.towerInfoController.GetComponent<TweenPosition>();
foreach (Transform child in PlayManager.Instance.footerBar.transform)
{
if (child.name == PlayNameHashIDs.PanelTowerBuild)
{
GetComponent<UIPlayTween>().tweenTarget = child.gameObject;
break;
}
}
GameObject parent = this.gameObject.transform.parent.gameObject;
towerController = parent.GetComponent<TowerController>();
towerAction = parent.GetComponent<TowerAction>();
}
public void SetDescriptionValues(TowerController _TowerController) {
SelectedTower = _TowerController;
UpgradeRange = _TowerController.TowerRange * 1.07f;
UpgradeCost = _TowerController.Price / 2;
UpgradeDamage = _TowerController.Damage * 1.5f;
SellRefound = (int)((float)(((_TowerController.TowerLevel - 1) * UpgradeCost) + // upgrades
_TowerController.Price) * 0.75f); // base price
TowerNameText.text = _TowerController.TowerName;
TowerLevelValueText.text = _TowerController.TowerLevel.ToString ();
UpgradeDescriptionValuesText.text =
UpgradeDamage.ToString ("F0") + "\n"
+ UpgradeRange.ToString ("F0");
DescriptionValuesText.text =
_TowerController.Damage.ToString ("F0") + "\n"
+ _TowerController.TowerRange.ToString ("F0");
TowerUpgradePrice.text = "(price: " + UpgradeCost.ToString () + ")";
TowerAIValueText.text = AIBehaviorToString(_TowerController.TowerAIBehavior);
SellTowerValueText.text = "for: $" + SellRefound;
if (SelectedTower.TowerLevel >= 10) {
UpgradeButton.interactable = false;
TowerUpgradePrice.color = Color.cyan;
TowerUpgradePrice.text = "Can't upgrade";
} else {
if (Cash.instance.CashValue < UpgradeCost) {
TowerUpgradePrice.color = Color.red;
UpgradeButton.interactable = false;
} else {
TowerUpgradePrice.color = Color.green;
UpgradeButton.interactable = true;
}
}
}
string AIBehaviorToString(TowerController.AIBehavior ai) {
switch (ai) {
case TowerController.AIBehavior.CLOSEST:
return "near";
case TowerController.AIBehavior.FURTHEST:
return "far";
case TowerController.AIBehavior.SLOWEST:
return "slow";
case TowerController.AIBehavior.FASTEST:
return "fast";
case TowerController.AIBehavior.LESS_HP:
return "low hp";
case TowerController.AIBehavior.MORE_HP:
return "high hp";
case TowerController.AIBehavior.LESS_POISONED:
return "less poison";
case TowerController.AIBehavior.MORE_POISONED:
return "more poison";
}
return "NOAI";
}
void OnMouseOver() {
bool NotOverMenu = false;
if (Input.mousePosition.x < (float)Screen.width - (270.0f * (float)Screen.width / CameraController.instance._CanvasScaler.referenceResolution.x)) {
NotOverMenu = true;
}
if (MouseTowerPlacement.instance.gameObject.activeSelf && !TowerPlaced) {
MouseTowerPlacement.instance.TowerParent.transform.position = transform.position;
if (Input.GetMouseButtonDown(0)) {
if (NotOverMenu) {
GameObject InstantiatedTower = (GameObject)Instantiate(MouseTowerPlacement.instance.TowerPrefab);
InstantiatedTower.transform.SetParent(transform);
InstantiatedTower.transform.localPosition = Vector3.zero;
TowerPlaced = true;
InstantiatedTowerController = InstantiatedTower.GetComponent<TowerController>();
Cash.instance.DecCash(MouseTowerPlacement.instance.TowerPrefab.GetComponent<TowerController>().Price);
OnMouseExit();
MouseTowerPlacement.instance.gameObject.SetActive(false);
}
}
} else if (InstantiatedTowerController != null && !MouseTowerPlacement.instance.gameObject.activeSelf) {
if (Input.GetMouseButtonDown(0)) {
if (NotOverMenu) {
_SpriteRenderer.color = Color.red;
UpgradeController.instance.SetPermanent (true);
UpgradeController.instance.SetDescriptionValues(InstantiatedTowerController);
UpgradeController.instance.gameObject.SetActive(true);
}
}
} else {
_SpriteRenderer.color = Color.white;
MouseTowerPlacement.instance.TowerFieldHighlighted = false;
}
}
protected override void Start()
{
base.Start();
myFirstName = "Tower";
offenseLayer = 9;
towerController = GetComponent<TowerController>();
}
public void ResetField() {
TowerPlaced = false;
InstantiatedTowerController = null;
}
void Start () {
master = GameObject.Find("Master_Instance").GetComponent<Master_Instance>();
aux = GetComponent<SpriteRenderer>().sprite;
setLayer();
_towerController = transform.parent.parent.GetComponent<TowerController>();
}
void Start()
{
towerSpots = GameObjectsManager.towerSpots;//GameObject.FindGameObjectWithTag ("Tower spots");
towerController = tower.GetComponent<TowerController>();
gameManager = GetComponent<GameManager>();
spots = EnemySpawner.GetChildren (towerSpots);
showPanels = GameObjectsManager.UI.GetComponent<ShowPanels> ();
//addPanel = showPanels.addPanel;
//upgradePanel = showPanels.upgradePanel;
}
public void setCurrentTowerInfo(TowerController towerController)
{
controller = towerController;
Name.text = towerController.attribute.Name;
ATK.text = towerController.attribute.MinATK + "-" + towerController.attribute.MaxATK;
spawnShoot.text = towerController.attribute.SpawnShoot.ToString();
timeBuild.text = towerController.attribute.TimeBuild.ToString();
//Check bonus
if(ItemManager.Instance.listItemState.Contains(EItemState.ATK))
ATK.text += " [8aff5c]+ " + towerController.Bonus.ATK + "[-]";
if(ItemManager.Instance.listItemState.Contains(EItemState.SPAWN_SHOOT))
spawnShoot.text += " [8aff5c]- " + towerController.Bonus.SpawnShoot + "[-]";
if(ItemManager.Instance.listItemState.Contains(EItemState.RANGE))
{
PlayManager playManager = PlayManager.Instance;
playManager.rangeTowerBonus.transform.position = playManager.rangeTower.transform.position;
float scale = (float)(controller.attribute.Range + controller.Bonus.Range) / 100f;
playManager.rangeTowerBonus.transform.localScale = new Vector3(scale, scale, 0);
playManager.rangeTowerBonus.SetActive(true);
((SphereCollider)controller.collider).radius = controller.attribute.Range + controller.Bonus.Range;
}
}
public void setNextTowerInfo(TowerController towerController)
{
controller = towerController;
Name.text = towerController.attribute.Name;
ATK.text = towerController.attribute.MinATK + "-" + towerController.attribute.MaxATK;
spawnShoot.text = towerController.attribute.SpawnShoot.ToString();
timeBuild.text = towerController.attribute.TimeBuild.ToString();
//Check bonus
if(ItemManager.Instance.listItemState.Contains(EItemState.ATK))
{
ATK.text += " [8aff5c]+ " + (int)((towerController.attribute.MinATK + towerController.attribute.MaxATK) * ItemManager.Instance.BonusATK / 2) + "[-]";
}
if(ItemManager.Instance.listItemState.Contains(EItemState.SPAWN_SHOOT))
{
spawnShoot.text += " [8aff5c]- " + towerController.attribute.SpawnShoot * ItemManager.Instance.BonusSpawnShoot + "[-]";
}
if(ItemManager.Instance.listItemState.Contains(EItemState.RANGE))
{
PlayManager playManager = PlayManager.Instance;
playManager.rangeTowerBonus.transform.position = playManager.rangeTower.transform.position;
float scale = (float)(controller.attribute.Range + (int)(towerController.attribute.Range * ItemManager.Instance.BonusRange)) / 100f;
playManager.rangeTowerBonus.transform.localScale = new Vector3(scale, scale, 0);
playManager.rangeTowerBonus.SetActive(true);
}
}
// selects an object by instantiating the selection indicator around it
void Select(GameObject o)
{
selectedObject = o;
selectedTowerInfo = o.GetComponent<TowerController>();
selectedTowerInfo.range = selectedObject.GetComponent<SphereCollider>().radius * selectedObject.transform.localScale.y;
selectedTowerInfo.startRange = selectedTowerInfo.range;
// sight radius
vCollider = (GameObject) Instantiate(selectionCollider, o.transform.position, Quaternion.identity);
float diameter = selectedTowerInfo.range * 2.0f;
vCollider.transform.localScale = new Vector3(diameter, diameter, diameter);
// small white sphere around tower
vIndicator = (GameObject) Instantiate(selectionIndicator, o.transform.position, Quaternion.identity);
diameter = o.transform.localScale.y * 3;
vIndicator.transform.localScale = new Vector3(diameter, diameter, diameter);
// get info to display
}
// Use this for initialization
void Start () {
parent_ = this.transform.parent.gameObject;
Properties = parent_.GetComponent<TowerController>();
}
void Start()
{
currentState = GameState.Running;
//DontDestroyOnLoad(this);
PlaneTargetTransform = GameObject.Find("PLANE_TARGET").transform;
planeHealth = GameObject.Find("PlayerOne").GetComponent<Health>();
PlaneCam = GameObject.Find("Camera1").GetComponent<Camera>();
islandCam = GameObject.Find("Camera").GetComponent<Camera>();
winnerText = GameObject.Find("WinnerText").GetComponent<Text>();
towerController = GameObject.Find("Towers").GetComponent<TowerController>();
inGameUI = GameObject.Find("InGame");
postGameUI = GameObject.Find("PostGame");
postGameUI.SetActive(false);
}
public VictimController GetVictimInRange(Vector2 from, float radius, TowerController.AIBehavior TowerAIBehavior) {
VictimController result = null;
switch (TowerAIBehavior) {
case TowerController.AIBehavior.FASTEST:
result = GetFastestVictimInRange(from, radius);
break;
case TowerController.AIBehavior.SLOWEST:
result = GetSlowestVictimInRange(from, radius);
break;
case TowerController.AIBehavior.LESS_HP:
result = GetLessHpVictimInRange(from, radius);
break;
case TowerController.AIBehavior.MORE_HP:
result = GetMostHpVictimInRange(from, radius);
break;
case TowerController.AIBehavior.LESS_POISONED:
result = GetLessPoisonedVictimInRange(from, radius);
break;
case TowerController.AIBehavior.MORE_POISONED:
result = GetMostPoisonedVictimInRange(from, radius);
break;
case TowerController.AIBehavior.FURTHEST:
result = GetFurthestVictimInRange(from, radius);
break;
case TowerController.AIBehavior.CLOSEST:
default:
result = GetColosestVictimInRange(from, radius);
break;
}
return result;
}
void Update()
{
if (Input.touchSupported) {
if (Input.touchCount > 0) {
touch = Input.touches [0];
inputType = touch.phase == TouchPhase.Began;
position = touch.position;
fingerId = Input.touches[0].fingerId;
}
} else {
inputType = Input.GetButtonDown ("Fire1");
position = Input.mousePosition;
}
if (inputType) {
Ray ray = Camera.main.ScreenPointToRay (position);
RaycastHit hit = new RaycastHit ();
spotFound = false;
misclicked = true;
if (Physics.Raycast (ray, out hit)) {
foreach (Transform s in spots) {
if (hit.collider.gameObject == s.gameObject) {
spot = s;
spotFound = true;
}
}
bool UIEvent = false;
if (Input.touchSupported) {
UIEvent = EventSystem.current.IsPointerOverGameObject (fingerId);
}
else {
UIEvent = EventSystem.current.IsPointerOverGameObject ();
}
if (UIEvent) {
GameObject currUIElement = EventSystem.current.currentSelectedGameObject;
if (currUIElement == null) {
spotFound = true;
notPanels = false;
}
else if ((currUIElement.transform.parent.gameObject == showPanels.addPanel) || (currUIElement.transform.parent.gameObject == showPanels.upgradePanel)) {
spotFound = true;
notPanels = false;
}
else {
notPanels = true;
}
}
if (!spotFound) {
if (currentSpot != null) {
SpotState spotState = currentSpot.GetComponent<SpotState>();
if (spotState.towerPlaced != null) {
towerController = spotState.towerPlaced.GetComponent<TowerController> ();
towerController.projector.SetActive(false);
}
}
currentSpot = null;
}
if (!poppedUp) {
if (spotFound) {
currentSpot = spot.gameObject;
SpotState spotState = currentSpot.gameObject.GetComponent<SpotState> ();
placed = spotState.placed;
if (placed) {
showPanels.upgradePanel.SetActive(true);
showPanels.upgradePanel.GetComponent<RectTransform> ().position = position;
currPanel = showPanels.upgradePanel;
spotState.towerPlaced.GetComponent<TowerController>().projector.SetActive(true);
}
else {
showPanels.addPanel.SetActive(true);
showPanels.addPanel.GetComponent<RectTransform> ().position = position;
currPanel = showPanels.addPanel;
}
placePosition = spot.transform.position;
//Debug.DrawLine (ray.origin, hit.point);
poppedUp = true;
misclicked = false;
} else {
currentSpot = null;
}
} else {
if (UIEvent) {
if (notPanels) {
misclicked = true;
}
else {
misclicked = false;
}
}
if (misclicked) { /*&& urrentSpot != spot.gameObject)*/
if (currentSpot != spot.gameObject) {
showPanels.addPanel.SetActive(false);
showPanels.upgradePanel.SetActive(false);
//addPanel.GetComponent<RectTransform> ().position = new Vector2 (Screen.currentResolution.width + 200, Screen.currentResolution.height + 200);
//upgradePanel.GetComponent<RectTransform> ().position = new Vector2 (Screen.currentResolution.width + 200, Screen.currentResolution.height + 200);
if (currentSpot != null) {
SpotState spotState = currentSpot.GetComponent<SpotState>();
if (spotState.towerPlaced != null) {
towerController = spotState.towerPlaced.GetComponent<TowerController> ();
towerController.projector.SetActive(false);
}
}
currPanel = null;
currentSpot = null;
poppedUp = false;
misclicked = false;
}
}
}
}
}
if (poppedUp) {
if (Camera.main.transform.position != cameraCurrPosition) {
currPanel.GetComponent<RectTransform> ().position = Camera.main.WorldToScreenPoint(spot.transform.position);
}
cameraCurrPosition = Camera.main.transform.position;
}
}
