private void AttachButtonEvent(Content.TowerSelectionPanel buttonName, TowerType type) { var button = (InteractiveButton)GetSceneControl(buttonName.ToString()); button.AddTag(type.ToString()); button.Clicked += () => BuildTower(type); towerButtonPanel.Add(button); }
/// <summary> /// Metoda odpowiedzialna za dodawanie odpowiedniego obiektu wieży, definiowanego przez argument type, w miejscu i jako dziecko obiektu parent. Zwraca koszt wieży. /// </summary> /// <param name="type">Argument typu TowerType określająca typ wieży, jak ma zostać utworzona.</param> /// <param name="parent">Argument typu GameObject, którego dzieckiem stanie się nowa wieża.</param> /// <returns>Wzraca koszt wybudowania wieży.</returns> public int SpawnTower(TowerType type, GameObject parent) { Tower tempTower = new Tower(); GameObject tempGameObject = null; switch (type) { case TowerType.Wall: tempTower = WallTower; tempGameObject = Resources.Load("Prefabs/Towers/Wall") as GameObject; break; case TowerType.Shooting: tempTower = ShootingTower; tempGameObject = Resources.Load("Prefabs/Towers/Shooting") as GameObject; break; case TowerType.Aoe: tempTower = AoeTower; tempGameObject = Resources.Load("Prefabs/Towers/Aoe") as GameObject; break; } GameObject tower = Instantiate(tempGameObject, parent.transform.position, Quaternion.identity) as GameObject; tower.transform.parent = parent.transform; tower.transform.localPosition = new Vector3(tower.transform.localPosition.x, -(2.0f/parent.transform.localScale.y), tower.transform.localPosition.z); return tempTower.Cost; }
public static void ChangeStatesIfGlassCreep(TowerType damageType, Creep creep) { if (damageType == TowerType.Fire) SetAffectedByFire(creep); else if (damageType == TowerType.Impact) SetAffectedByImpact(creep); }
public static Tower Add(int playerNum, int teamNum, int money, TowerType towerType, Vector3 position) { //////////////////////REFACTOR FOR EFFICIENCY Tile tile = TileMap.GetTileFromPos(position); Tower tower; if (!tile.IsWalkable() || tile.IsBase()) return null; if (towers[playerNum][(int)towerType][0].Cost > money) return null; for (int i = 0; i < MAX_TOWERS; i++) { tower = towers[playerNum][(int)towerType][i]; if (!tower.IsActive()) { tower.Activate(playerNum, teamNum); tower.Type = towerType; tower.Setup(position); towerCount[playerNum][(int)towerType]++; if (TileMap.SetTower(ref tower, ref tile)) { return tower; } tower.Status = TowerStatus.Inactive; } } return null; }
public virtual void GetTowerStats(TowerType type) { switch (type) { case TowerType.RIFLE: cost = 100; fireRate = 1; damage = 40; range = 250; projectileSpeed = 250; CanShootAircraft = false; break; case TowerType.MG: cost = 300; fireRate = .2f; damage = 15; range = 250; projectileSpeed = 250; CanShootAircraft = false; break; case TowerType.BAZOOKA: cost = 400; fireRate = 2; damage = 250; range = 250; projectileSpeed = 150; CanShootAircraft = false; break; case TowerType.SNIPER: cost = 300; fireRate = 3; damage = 150; range = 750; projectileSpeed = 750; CanShootAircraft = false; break; case TowerType.AAGUN: cost = 300; fireRate = .1f; damage = 10; range = 350; projectileSpeed = 400; CanShootAircraft = true; break; case TowerType.FLAMETHROWER: cost = 500; fireRate = .1f; damage = 10; range = 100; projectileSpeed = 100; CanShootAircraft = false; break; } }
public static Tower CreateTower(TowerType type, Texture2D texture, Vector2 position) { var tower = CreateTowerFromType(type, texture, position); Towers.Add(tower); return(tower); }
public override TowerData Get(TowerType type) { foreach (TowerData d in agentData.Where(d => (TowerType)d.Type == type)) return d; var newTowerData = DefaultTowerPropertiesForTesting.DefaultTowerValuesForTesting(type); agentData.Add(newTowerData); return newTowerData; }
static Tower CreateTowerFromType(TowerType type, Texture2D texture, Vector2 position) { return(type switch { TowerType.Basic => new BasicTower(texture, position), TowerType.Fire => new FireTower(texture, position), _ => null, });
public override void FireShots(GameObject _towerTarget, GameObject _ammoToFire, Transform _ammoSpawnPt, TowerType _type) { base.FireShots(_towerTarget, _ammoToFire, _ammoSpawnPt, _type); towerTarget = _towerTarget; ammoToFire = _ammoToFire; ammoSpawnPt = _ammoSpawnPt; towerType = _type; }
public void SpawnTower(Vector3 position, TowerType towerType) { var towerToSpawn = towerType == TowerType.Simple ? config.towerPrefab : config.otherTowerPrefab; var tower = SpawnObject(towerToSpawn, new Vector3(position.x, config.towerPrefab.transform.position.y, position.z)) as SimpleTower; tower.Initialize(spawnedEnemies); tower.ShootingSystem?.SetSpawner(this); }
public Tower Get(TowerType type) { Debug.Assert((int)type < towerPrefabs.Length, "Unsupported tower type!"); Tower prefab = towerPrefabs[(int)type]; Debug.Assert(type == prefab.TowerType, "Tower prefab at wrong index!"); return(Get(prefab)); }
public Bullet(Game1 game, Vector3 position, BaseObject owner, TowerType towerType) : base(game, position) { _owner = owner; this.towerType = towerType; this.MaxDistanceFromOwner = 100; this.texture = new Texture2D(game.GraphicsDevice, 1, 1, false, SurfaceFormat.Color); this.texture.SetData(new[] { Color.White }); }
private GameObject Create(TowerType type) { towers.TryGetValue(type.GetHashCode(), out Object res); if (res == null) { return(null); } return(Instantiate(res as GameObject, Container)); }
public Tower( int damage, int fireSpeed, TowerType towerType ) { this.damage = damage; this.fireSpeed = fireSpeed; this.towerType = towerType; shootedSpells = new LinkedList<GameObject>(); }
private void ApplyDotEffect(TowerType damageType, float damage) { AdjustStat(new StatAdjustment("Hp", "", -damage)); SpawnHitSparks(damageType); if (GetStatValue("Hp") <= 0.0f) { Die(); } }
private void SpawnTurretInShop(TowerType type) { //Get turret spawn position Vector3 spawnPosition = this.towerSpawnInfo[type].spawnPosition; //Spawn turret GameObject obj = GameObject.Instantiate <GameObject>(this.towerSpawnInfo[type].objPrefab, this.shopItemsHolder.transform); obj.transform.position = spawnPosition; }
private void AddClickEvent(InteractiveButton button, TowerType type, string towerName) { button.Clicked += () => { //ContentLoader.Load<Sound>(GameSounds.PressButton.ToString()).Play(); //game.Get<InGameCommands>().HideTowerPanel(); //game.CreateTower(game.Get<InGameCommands>().PositionInGrid, type, towerName); }; }
Tower CreateTower(TowerType towerType, Vector3 pos) { GameObject tower = EntityManager.S.GetEntity(towerType).gameObject; tower.transform.position = pos; tower.transform.eulerAngles = new Vector3(0, 180, 0); return(tower.GetComponent <Tower>()); }
public UIElement(Bitmap image, int xPos, int yPos, bool isClickable, TowerType tower) : this(xPos, yPos, isClickable) { this.image = image; width = image.Width; height = image.Height; text = ""; textSize = 0; this.tower = tower; }
public UIElement(string text, int textSize, int xPos, int yPos) : this(xPos, yPos, false) { image = null; width = 0; height = 0; this.text = text; this.textSize = textSize; tower = TowerType.None; }
public GameObject GetTowerObject(TowerType towerType) { if (towerObject.ContainsKey(towerType)) { return(towerObject[towerType]); } return(null); }
public int GetTowerMaxLevels(TowerType type) { if (towerMaxLevels.ContainsKey(type)) { return(towerMaxLevels[type]); } return(-1); }
protected override void AttackEnemy(TowerType type) { base.AttackEnemy(type); GameObject stone = (GameObject)Instantiate(stonePrefab, towerPieceToAim.position, Quaternion.identity); stone.GetComponent <Stone>().enemyToFollow = targetEnemy; stone.GetComponent <Stone>().damage = attackPower; }
public Tower Get(TowerType type) { // acessa a prefab da torre com o tipo respectivo Debug.Assert((int)type < towerPrefabs.Length, "Unsupported tower type!"); Tower prefab = towerPrefabs[(int)type]; Debug.Assert(type == prefab.TowerType, "Tower prefab at wrong index!"); return(Get(prefab)); }
public int GetTowerCost(TowerType towerType) { /* * Get cost considering how many towers of this type we've created. */ var upgradeCost = upgradeTowerCost * towerCount[towerType]; return(baseTowerCost + upgradeCost); }
protected TowerData(TowerType type, TowerAssetData assetData, TowerLevelData[] levels) { Type = type; AssetData = assetData; CurrentLevel = 1; Upgraded = new UnityEvent(); Levels = levels; }
void FixedUpdate() { EnemyTarget enemyTarget = GetComponent <EnemyTarget>(); if (enemyTarget) { //Attach progress bar if (!progressBar) { GameObject go = Instantiate(PrefabManager.instance.progressBarType, transform.position, Quaternion.identity); go.transform.Translate(new Vector3(0.3f, +0.5f)); progressBar = go.GetComponent <HealthBar>(); } //Detect if any enemy in range GameObject[] enemies = EnemiesInRange(); if (enemies.Length > 0) { enemyTowerProgress += enemies.Length / 5f; progressBar.SetHealthRatio(enemyTowerProgress / 100f); if (enemyTowerProgress >= 100f) { if (towerController == null) { tower = FindObjectOfType <TowerSpawner>().InitTower(transform); towerController = tower.GetComponentInChildren <TowerController>(); towerType = tower.GetComponentInChildren <TowerType>(); isOccupied = true; towerController.UpdateOwnerToEnemy(); } else if (towerController.owner != TowerOwner.ENEMY) { towerController.UpdateOwnerToEnemy(); } else if (towerController.owner == TowerOwner.ENEMY) { towerController.UpgradeTower(); } Destroy(progressBar.gameObject); progressBar = null; enemyTowerProgress = 0f; } } } else { enemyTowerProgress = 0f; if (progressBar) { Destroy(progressBar.gameObject); progressBar = null; } } }
public UIElement(int spriteIndex, Vector2 position, int width, int height, bool isClickable, TowerType tower) : this(position, isClickable) { this.spriteIndex = spriteIndex; Width = width; Height = height; text = ""; fontIndex = 0; this.tower = tower; type = UIElementType.Image; }
public UIElement(string text, int fontIndex, Vector2 position) : this(position, false) { spriteIndex = -1; Width = 0; Height = 0; this.text = text; this.fontIndex = fontIndex; tower = TowerType.None; type = UIElementType.Text; }
GameObject CreateTower(TowerType type) { if (type == TowerType.None) throw new UnityException("Create Tower was passed TowerType.None..."); GameObject tower = Instantiate(TowerPrefabs[type]); tower.transform.parent = TowerContainer.transform; tower.SetActive(false); return tower; }
//Init tower from Tower scriptable object public virtual void Init(TowerSO towerData) { currentTower = towerData; enemyLayerMask = LayerMask.GetMask("Enemy"); _type = towerData.type; _buildCost = towerData.buildCost; range = towerData.range; _nextUpgrade = towerData.nextUpgrade; }
public Tower(TowerType type, Vector3D position, float rotationZ = 0.0f) { Type = type; CreateStats(type, ContentLoader.Load <TowerPropertiesXml>(Xml.TowerProperties.ToString())); Position = position; ScaleFactor = 1.0f; RotationZ = rotationZ; SetMultipliersFromAvatar(); Cooldown = 1 / GetStatValue("AttackFrequency"); }
private void CreateStats(TowerType type, TowerPropertiesXml properties) { TowerData towerData = properties.Get(type); Name = towerData.Name; AttackType = towerData.AttackType; CreateStat("Range", towerData.Range); CreateStat("AttackFrequency", towerData.AttackFrequency); CreateStat("Power", towerData.BasePower); CreateStat("Cost", towerData.Cost); }
public void AddTower(TowerType towerType) { var data = GetTowerData(towerType); Tower tower = Instantiate(data.towerPrefab).GetComponent <Tower>(); tower.Stats.SetCost(data.cost); TowerPositioner.Instance.SetTower(tower); }
public void BuildTower(TowerType towerType) { if (TileType != TileType.Build || hadBuild) { return; } hadBuild = true; towerObj.GetComponent <SpriteRenderer>().sortingOrder = point.Y; }
public Tower(TowerType type, Vector3D position, float rotationZ = 0.0f) { Type = type; CreateStats(type, ContentLoader.Load<TowerPropertiesXml>(Xml.TowerProperties.ToString())); Position = position; ScaleFactor = 1.0f; RotationZ = rotationZ; SetMultipliersFromAvatar(); Cooldown = 1 / GetStatValue("AttackFrequency"); }
private bool buy(TowerType type) //определяет возможность покупки и покупает при наличии таковой { switch (type) { case TowerType.Arrow: if (money >= Tower.COST_ARROW_TOWER) { money -= Tower.COST_ARROW_TOWER; break; } else { return(false); } case TowerType.Splash: if (money >= Tower.COST_SPLASH_TOWER) { money -= Tower.COST_SPLASH_TOWER; break; } else { return(false); } case TowerType.Poison: if (money >= Tower.COST_POISON_TOWER) { money -= Tower.COST_POISON_TOWER; break; } else { return(false); } case TowerType.Ice: if (money >= Tower.COST_ICE_TOWER) { money -= Tower.COST_ICE_TOWER; break; } else { return(false); } case TowerType.AntiAir: money -= Tower.COST_AIR_TOWER; break; case TowerType.Ultimate: money -= Tower.COST_ULTIMATE_TOWER; break; } //lblMoney.Text = money.ToString(); return(true); }
public TowerData(TowerType type, string name, AttackType attackType, float range, float frequency, float basePower, int cost) : base(name) { Type = type; AttackType = attackType; Range = range; AttackFrequency = frequency; BasePower = basePower; Cost = cost; }
public static void ChangeStatesIfSandCreep(TowerType damageType, Creep creep) { if (damageType == TowerType.Impact) SetAffectedByImpact(creep); else if (damageType == TowerType.Water) SetAffectedByWater(creep); else if (damageType == TowerType.Ice) SetAffectedByIce(creep); else if (damageType == TowerType.Fire) SetAffectedByFire(creep); }
public int GetUpgradePrice(TowerType type) { switch (type) { case TowerType.Laser: return(laser.upgradePrice); case TowerType.Ballistic: return(ballistic.upgradePrice); default: throw new System.Exception("Unsupported tower type"); } }
public static void ChangeStatesIfIronCreep(TowerType damageType, Creep creep) { if (damageType == TowerType.Fire) SetAffectedByFire(creep); else if (damageType == TowerType.Acid) SetAffectedByAcid(creep); else if (damageType == TowerType.Water) SetAffectedByWater(creep); else if (damageType == TowerType.Ice) SetAffectedByIce(creep); }
public Tower Get(TowerType type) { switch (type) { case TowerType.Laser: return(Get(laser.prefab)); case TowerType.Ballistic: return(Get(ballistic.prefab)); default: throw new System.Exception("Unsupported tower type"); } }
public static ParticleSystem GetAttackEffect(TowerType towerType, AttackType attackType) { try { var effectData = ContentLoader.Load<ParticleSystemData>(towerType + attackType.ToString() + EffectType.Attack); return new ParticleSystem(effectData); } catch //ncrunch: no coverage start, MockContentLoader will have the above lines always pass { return FallbackEffects.AttackEffect(); } //ncrunch: no coverage end }
public virtual void ReceiveAttack(TowerType damageType, float rawDamage, float typeInteraction = 1.0f) { if (!IsActive) return; UpdateDamageState(damageType); SpawnHitSparks(damageType); float resistance = GetStatValue("Resistance"); var damage = CalculateDamage(rawDamage, resistance, typeInteraction); AdjustStat(new StatAdjustment("Hp", "", -damage)); if (GetStatValue("Hp") <= 0.0f) Die(); }
public GameObject Build(TowerType requestedType) { BuildableTower requestedTowerBlueprint = Array.Find (BuildableTowers, (tower) => tower.towerType == requestedType); if (Gold.useGold (requestedTowerBlueprint.cost)) { requestedTowerBlueprint.towerObject.SetActive (true); gameObject.SetActive (false); return requestedTowerBlueprint.towerObject; } else { Debug.Log ("Moar gold is required"); return this.gameObject; } }
public int GetSkillAmount(TowerType s) { switch(s){ case TowerType.shoot: return shoot; case TowerType.build: return build; case TowerType.silence: return silence; case TowerType.skillCap: return skillCap; } return -1; }
private void AddTowers(IEnumerable<Land> defenceLessLands, int num, TowerType type) { foreach (var defenceLessLand in defenceLessLands) { for (var i = 0; i < num; i++) { defenceLessLand.Towers.Add(new Tower { Height = _height, ID = (_context.LastId + 1).ToString(), Type = type }); } } }
public static ParticleSystem GetHitEffect(TowerType attackType) { if (HitEffects[(int)attackType] != null) return HitEffects[(int)attackType]; try { var effectData = ContentLoader.Load<ParticleSystemData>(attackType.ToString() + EffectType.Hit); return HitEffects[(int)attackType] = new ParticleSystem(effectData); } catch //ncrunch: no coverage start { return HitEffects[(int)attackType] = FallbackEffects.AttackEffect(); } //ncrunch: no coverage end }
private Color GetColor(TowerType t) { switch(t){ case TowerType.shoot: return shootColor; case TowerType.build: return buildColor; case TowerType.silence: return silenceColor; case TowerType.skillCap: return skillCapColor; default: return Color.white; } }
public static string GetDescription(TowerType tower) { switch(tower){ case TowerType.shoot: return "Shoot Tower: \nThe player may destroy another piece on the board. The piece is ruined, and the tile cannot be built upon. It is not possible to shoot gray pieces"; case TowerType.build: return "Build Tower: \nAllows the player to place one more piece on the board, however, to be able to use this more than once, aditional Power is required"; case TowerType.silence: return "Silence Tower: \nFor the next turn, the opponent cannot place a piece where it would make a tower, or 5 in a row."; case TowerType.skillCap: return "Power Tower: \nIncreases the power by one for the player who builds it. Power is the cap for how many times one skilltype can be used in one turn."; default: return ""; } }
public static ParticleSystem GetProjectileEffect(TowerType towerType, AttackType attackType) { try { var effectData = ContentLoader.Load<ParticleSystemData>(towerType + attackType.ToString() + EffectType.Projectile); var effect = new ParticleSystem(effectData); foreach (var emitter in effect.AttachedEmitters) emitter.EmitterData.DoParticlesTrackEmitter = true; return effect; } catch //ncrunch: no coverage start { return FallbackEffects.ProjectileEffect(); } //ncrunch: no coverage end }
public static bool CheckSolution(Tutorial.Chapter chapter, TowerType tower) { switch(tower){ case TowerType.shoot: return CheckShoot(chapter); case TowerType.build: return CheckBuild(chapter); case TowerType.silence: return CheckSilence(chapter); case TowerType.skillCap: return CheckSkillCap(chapter); default: Debug.LogError("Invalid tutorial"); return false; } }
public void SetVulnerabilityWithValue(TowerType towerType, float value) { if (value == 0.1f) SetVulnerability(towerType, Vulnerability.Immune); else if (value == 0.25f) SetVulnerability(towerType, Vulnerability.HardBoiled); else if (value == 0.5f) SetVulnerability(towerType, Vulnerability.Resistant); else if (value == 1.0f) SetVulnerability(towerType, Vulnerability.Normal); else if (value == 2.0f) SetVulnerability(towerType, Vulnerability.Weak); else if (value == 3.0f) SetVulnerability(towerType, Vulnerability.Vulnerable); else SetVulnerability(towerType, Vulnerability.Sudden); }
// Constructor public Tower(TowerType myTowerType, int posX, int posY, Canvas myCanvas, MainWindow mainWindow) { MainWindow = mainWindow; MyCanvas = myCanvas; MyTowerType = myTowerType; PosX = posX; PosY = posY; // use case select based on towertype switch (myTowerType) { case TowerType.Arrow: // need to add new image and update path pathImage = @"..\..\Tower Images\tower.png"; pathImage_attack = @"..\..\Tower Images\tower_attack.png"; attackAnimationLength = 200; // set initial weapon MyWeapon = new Weapon(500, 100, 2); break; // case TowerType.Flame: // // need to add new image and update path // uriPath = @"..\..\Tower Images\tower.png"; // // set initial weapon // MyWeapon = new Weapon(10, 100, 1); // break; // case TowerType.Radial: // // need to add new image and update path // uriPath = @"..\..\Tower Images\tower.png"; // // set initial weapon // break; default: pathImage = ""; break; } // instantiate at posX, posY MyCanvas.Dispatcher.Invoke(new Action(() => DrawTower(pathImage))); }
public IActionResult Index(string name, string city, string district, TowerType? type, TowerStatus? status, Provider? provider) { IEnumerable<Tower> towers = DB.Towers; if (!string.IsNullOrEmpty(name)) towers = towers.Where(x => x.Name.Contains(name) || name.Contains(x.Name)); if (!string.IsNullOrEmpty(city)) towers = towers.Where(x => x.City.Contains(city) || city.Contains(x.City)); if (!string.IsNullOrEmpty(district)) towers = towers.Where(x => x.District.Contains(district) || district.Contains(x.District)); if (type.HasValue) towers = towers.Where(x => x.Type == type.Value); if (status.HasValue) towers = towers.Where(x => x.Status == status.Value); if (provider.HasValue) towers = towers.Where(x => x.Provider == provider.Value); return PagedView(towers); }
public static Color GetSkillColor(TowerType skill) { switch(skill){ case TowerType.shoot: return Color.magenta; case TowerType.build: return Color.cyan; case TowerType.silence: return Color.green; case TowerType.skillCap: return Color.yellow; case TowerType.five: return Color.white; default: Debug.LogError("Skill "+skill+" not found"); return Color.clear; } }
public static void ChangeStatesIfClothCreep(TowerType damageType, Creep creep) { switch (damageType) { case TowerType.Ice: SetAffectedByIce(creep); break; case TowerType.Impact: SetAffectedByImpact(creep); break; case TowerType.Water: SetAffectedByWater(creep); break; case TowerType.Acid: SetAffectedByAcid(creep); break; case TowerType.Fire: SetAffectedByFire(creep); break; } }
public float GetVulnerabilityValue(TowerType type) { var vulnerability = GetVulnerability(type); switch (vulnerability) { case Vulnerability.Vulnerable: return 3; case Vulnerability.Weak: return 2; case Vulnerability.Normal: return 1; case Vulnerability.Resistant: return 0.5f; case Vulnerability.HardBoiled: return 0.25f; case Vulnerability.Immune: return 0.1f; default: return 9001; //ncrunch: no coverage } }