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