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