public static void GetStatsForTowerType(TowerTypes type, out TowerStats[] towerStats, out WeaponStats[] weaponStats)
{
switch (type)
{
case TowerTypes.Lawyer://Base cost 15 min delay is 4
towerStats = new TowerStats[7] {new TowerStats(15, 150, 25), new TowerStats(12, 160, 50), new TowerStats(9, 170, 90),
new TowerStats(7, 180, 200), new TowerStats(6, 190, 450),new TowerStats(5, 195, 700),new TowerStats(4, 200, -1) };
weaponStats = new WeaponStats[7] { new WeaponStats(5, 10, 1), new WeaponStats(18, 10, 1), new WeaponStats(40, 10, 1),
new WeaponStats(120, 10, 1), new WeaponStats(500, 10, 1),new WeaponStats(1500, 10, 1),new WeaponStats(3000, 10, 1) };
break;
//case TowerTypes.Splash:
case TowerTypes.Teacher://base 20
Debuff slow = new Debuff(CreepStats.Speed, 1, 10);
Debuff slow2 = new Debuff(CreepStats.Speed, 2, 20);
towerStats = new TowerStats[5] { new TowerStats(70, 140, 40), new TowerStats(50, 150, 60),
new TowerStats(30, 150, 100), new TowerStats(20, 160, 200), new TowerStats(10, 170, -1) };
weaponStats = new WeaponStats[5] { new WeaponStats(20, 6, 1, slow), new WeaponStats(40, 6, 1, slow),
new WeaponStats(80, 6, 1, slow), new WeaponStats(200, 6, 1, slow2), new WeaponStats(500, 6, 1, slow2) };
break;
//case TowerTypes.Gavel:
default: //normal for now (judge) Base 10;
towerStats = new TowerStats[6] { new TowerStats(13, 160, 30), new TowerStats(12, 170, 50), new TowerStats(10, 190, 100),
new TowerStats(10, 210, 180), new TowerStats(9, 230, 400), new TowerStats(8, 250, -1) };
weaponStats = new WeaponStats[6] { new WeaponStats(5, 10, 1), new WeaponStats(20, 10, 1), new WeaponStats(50, 10, 1),
new WeaponStats(150, 10, 1), new WeaponStats(700, 10, 1), new WeaponStats(2000, 10, 1) };
break;
}
}
public void BuyPlaceTower(TowerTypes type)
{
if (!towers.ContainsKey(selectedTile) && CurrentPlayer.WithdrawalMoney(TowerFactory.GetTowerCost(type)))
{
towers.Add(selectedTile, TowerFactory.GetTower(type, new Vector2(selectedTile.X * TileDimensions.X, selectedTile.Y * TileDimensions.Y)));
}
}
private Transform GetTowerTop(TowerTypes towerType)
{
Transform towerBase;
switch (towerType)
{
case TowerTypes.DefaultTower:
towerBase = GameAssets.GetInstance().defaultTowerTop;
break;
case TowerTypes.MagicTower:
towerBase = GameAssets.GetInstance().magicTowerTop;
break;
case TowerTypes.SniperTower:
towerBase = GameAssets.GetInstance().sniperTowerTop;
break;
case TowerTypes.MachineGunTower:
towerBase = GameAssets.GetInstance().machineGunTowerTop;
break;
default:
towerBase = GameAssets.GetInstance().defaultTowerTop;
break;
}
return(towerBase);
}
public TreeNode(TowerTypes towerType, int goldCost, string description)
{
_children = new List <TreeNode>();
_towerType = towerType;
_goldCost = goldCost;
_description = description;
}
public List <TowerSettings> GetUpgradeOptions(TowerTypes towerType)
{
UtilityFunctions.DebugMessage("TreeList Key Count: " + TreeLists.Count);
List <TreeNode> children = null;
Debug.Log(towerType);
if (towerType != TowerTypes.Unknown)
{
Debug.Log(TreeLists.First(x => x.Value.Any(y => y.TowerType == towerType)).Value);
//Debug.Log();
children = TreeLists.First(x => x.Value.Any(y => y.TowerType == towerType)).Value.First(z => z.TowerType == towerType).Children;
}
else
{
children = new List <TreeNode>();
foreach (var towerTree in TreeLists)
{
children.Add(towerTree.Value.ElementAt(0));
}
}
return((children != null)
? children.Select(x => new TowerSettings {
TowerType = x.TowerType, GoldCost = x.GoldCost, Description = x.Description
}).ToList()
: null);
}
public void AddTower()
{
Tower nt = null;
switch (this.TowerType)
{
case TowerTypes.ARROW_TOWER:
nt = new ArrowTower(this.towertextures[(int)TowerTypes.ARROW_TOWER - 1], this.bullettextures[(int)TowerTypes.ARROW_TOWER - 1], this.Tile);
break;
case TowerTypes.SPIKE_TOWER:
nt = new SpikeTower(this.towertextures[(int)TowerTypes.SPIKE_TOWER - 1], this.bullettextures[(int)TowerTypes.SPIKE_TOWER - 1], this.Tile);
break;
case TowerTypes.SPEED_TOWER:
nt = new SpeedTower(this.towertextures[(int)TowerTypes.SPEED_TOWER - 1], this.bullettextures[(int)TowerTypes.SPEED_TOWER - 1], this.Tile);
break;
case TowerTypes.CANNON_TOWER:
nt = new CannonTower(this.towertextures[(int)TowerTypes.CANNON_TOWER - 1], this.bullettextures[(int)TowerTypes.CANNON_TOWER - 1], this.Tile);
break;
}
if (nt != null && this.CanPlaceTower() && nt.Cost <= this.coins)
{
this.towers.Add(nt);
this.coins -= nt.Cost;
this.TowerType = TowerTypes.TOWER_NONE;
}
this.TowerType = TowerTypes.TOWER_NONE;
}
public void AOEManager(bool b)
{
TowerTypes towerType = transform.parent.GetComponent <Tower>().TowerType;
if (towerType == TowerTypes.Block)
{
//GetComponent<SpriteRenderer>().color = Color.red;
return;
}
GameObject aoeSprite = gameObject.transform.FindChild("AOESprite").gameObject;
if (towerType != TowerTypes.Soul || towerType != TowerTypes.Block)
{
if (towerType == TowerTypes.Normal || towerType == TowerTypes.Magic)
{
if (GameController.instance.UpgradedItem[Constants.UPGRADE_BASIC_RANGE_INDEX] && towerType == TowerTypes.Normal)
{
transform.parent.GetComponent <CircleCollider2D>().radius = Constants.UPGRADE_BASIC_RANGE_MULTIPLY * Constants.NORMAL_TOWER_RANGE;
}
if (GameController.instance.UpgradedItem[Constants.UPGRADE_MAGIC_RANGE_INDEX] && towerType == TowerTypes.Magic)
{
transform.parent.GetComponent <CircleCollider2D>().radius = Constants.UPGRADE_MAGIC_RANGE_MULTIPLY * Constants.MAGIC_TOWER_RANGE;
}
}
aoeSprite.transform.localScale = (transform.parent.GetComponent <CircleCollider2D>().radius *(new Vector3(1, 1, 0)) + Vector3.one) / transform.localScale.x;
if (towerType == TowerTypes.Soul)
{
aoeSprite.SetActive(true);
}
else
{
aoeSprite.SetActive(b);
}
}
}
public void PlaceTower(TowerPlacementInfo towerInfo)
{
Type = towerInfo.TowerType;
Tower = Instantiate(towerInfo.TowerPrefab, transform.position, Quaternion.identity);
TowerState = Tower.GetComponent <TowerState>();
IsEmpty = false;
}
public TowerCommand(TowerFactory factory, Point location, TowerTypes towerType)
{
this._factory = factory;
this._location = location;
this._towerType = towerType;
this._singleton = DebugLogSingleton.GetInstance();
this._singleton.Log <TowerCommand>("Command", "Initializing tower command");
}
public Tower(TowerStats[] tStats, WeaponStats[] wStats, MEDIA_ID textureID, Vector2 startPosition, TowerTypes type)
{
towerStats = tStats;
weaponStats = wStats;
Level = 0;
NextFire = 0;
this._position = startPosition;
Type = type;
TextureID = textureID;
}
internal void DestroyTower()
{
GameObject.Destroy(Tower);
var explosion = Instantiate(TowerExplosionPrefab, transform.position, Quaternion.identity);
GameObject.Destroy(explosion, 1.5f);
TowerState = null;
Type = TowerTypes.Unknown;
IsEmpty = true;
}
public Tower(TowerStats[] tStats, WeaponStats[] wStats, MEDIA_ID textureID, Vector2 startPosition, TowerTypes type)
{
towerStats = tStats;
weaponStats = wStats;
Level = 0;
NextFire = 0;
this._position = startPosition;
Type = type;
TextureID = textureID;
}
public Projectile(WeaponStats stats, Creep targetCreep, Vector2 startPoint, TowerTypes parentTowerType)
{
Stats = stats.GetCopy();
TargetCreep = targetCreep;
CenterPosition = startPoint;
this.type = SelectTypeBasedOnTowerType(parentTowerType);
this.TextureID = TowerFactory.GetProjectileMediaID(type);
this.numFrames = ProjectileDefinitions.ProjectileStats[type].NumFrames;
}
public Projectile(WeaponStats stats, Creep targetCreep, Vector2 startPoint, TowerTypes parentTowerType)
{
Stats = stats.GetCopy();
TargetCreep = targetCreep;
CenterPosition = startPoint;
this.type = SelectTypeBasedOnTowerType(parentTowerType);
this.TextureID = TowerFactory.GetProjectileMediaID(type);
this.numFrames = ProjectileDefinitions.ProjectileStats[type].NumFrames;
}
public static int GetTowerCost(TowerTypes type)
{
switch(type)
{
case TowerTypes.Lawyer:
return 15;
case TowerTypes.Teacher:
return 20;
default:
return 10;//Gavel tower
}
}
public static Tower GetTower(TowerTypes type, Vector2 position)
{
WeaponStats[] wStats;
TowerStats[] tStats;
GetStatsForTowerType(type, out tStats, out wStats);
return(new Tower(tStats, wStats, GetTowerMediaID(type), position, type));
//switch (type)
//{
// case TowerTypes.Gavel:
// case TowerTypes.Lawyer:
// case TowerTypes.Teacher:
// case TowerTypes.Splash:
//}
}
public static GameObject BlankTowerForType(TowerTypes type) {
switch (type) {
case TowerTypes.ORANGE_TOWER:
return instance.blankOrangeTower;
case TowerTypes.GREEN_TOWER:
return instance.blankGreenTower;
case TowerTypes.WHITE_TOWER:
return instance.blankWhiteTower;
case TowerTypes.BLUE_TOWER:
return instance.blankBlueTower;
default:
return instance.blankOrangeTower;
}
}
public static Tower GetTower(TowerTypes type, Vector2 position)
{
WeaponStats[] wStats;
TowerStats[] tStats;
GetStatsForTowerType(type, out tStats, out wStats);
return new Tower(tStats, wStats, GetTowerMediaID(type), position, type);
//switch (type)
//{
// case TowerTypes.Gavel:
// case TowerTypes.Lawyer:
// case TowerTypes.Teacher:
// case TowerTypes.Splash:
//}
}
private ProjectileTypes SelectTypeBasedOnTowerType(TowerTypes type)
{
if (type == TowerTypes.Judge)
{
return(ProjectileTypes.Gavel);
}
else if (type == TowerTypes.Lawyer)
{
return(ProjectileTypes.Scroll);
}
return(ProjectileTypes.Teacher);
//have a switch here at some point
}
public static int GetTowerCost(TowerTypes type)
{
switch (type)
{
case TowerTypes.Lawyer:
return(15);
case TowerTypes.Teacher:
return(20);
default:
return(10); //Gavel tower
}
}
public static Tower GetTower(TowerTypes type)
{
WeaponStats[] wStats;
TowerStats[] tStats;
GetStatsForTowerType(type, out tStats, out wStats);
return new Tower(tStats, wStats);
//switch (type)
//{
// case TowerTypes.Normal:
// case TowerTypes.Fast:
// case TowerTypes.Slow:
// case TowerTypes.Splash:
//}
}
public static void GetStatsForTowerType(TowerTypes type, out TowerStats[] towerStats, out WeaponStats[] weaponStats)
{
//switch (type)
//{
// case TowerTypes.Fast:
// case TowerTypes.Slow:
// case TowerTypes.Splash:
// case TowerTypes.Normal:
// case default :
towerStats = new TowerStats[5] { new TowerStats(20, 5, 5), new TowerStats(15, 6, 10), new TowerStats(13, 7, 20), new TowerStats(11, 8, 40), new TowerStats(10, 9, -1) };
weaponStats = new WeaponStats[5] { new WeaponStats(10, 10, 1), new WeaponStats(20, 10, 1), new WeaponStats(40, 10, 1), new WeaponStats(80, 10, 1), new WeaponStats(200, 10, 1) };
//break;
//}
}
public static void GetStatsForTowerType(TowerTypes type, out TowerStats[] towerStats, out WeaponStats[] weaponStats)
{
//switch (type)
//{
// case TowerTypes.Fast:
// case TowerTypes.Slow:
// case TowerTypes.Splash:
// case TowerTypes.Normal:
// case default :
towerStats = new TowerStats[5] { new TowerStats(20, 5, 5), new TowerStats(15, 6, 10), new TowerStats(13, 7, 20), new TowerStats(11, 8, 40), new TowerStats(10, 9, -1) };
weaponStats = new WeaponStats[5] { new WeaponStats(10, 10, 1), new WeaponStats(20, 10, 1), new WeaponStats(40, 10, 1), new WeaponStats(80, 10, 1), new WeaponStats(200, 10, 1) };
//break;
//}
}
public static Tower GetTower(TowerTypes type)
{
WeaponStats[] wStats;
TowerStats[] tStats;
GetStatsForTowerType(type, out tStats, out wStats);
return new Tower(tStats, wStats);
//switch (type)
//{
// case TowerTypes.Normal:
// case TowerTypes.Fast:
// case TowerTypes.Slow:
// case TowerTypes.Splash:
//}
}
/// <summary>
/// Should eventually return an array, for different levels
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static MEDIA_ID GetTowerMediaID(TowerTypes type)
{
if (type == TowerTypes.Judge)
{
return(MEDIA_ID.TOWER_0);
}
else if (type == TowerTypes.Lawyer)
{
return(MEDIA_ID.TOWER_1);
}
return(MEDIA_ID.TOWER_2);
//switch(type) <-needs that eventually
}
private void EnterPlacementMode(TowerTypes mode)
{
StartCoroutine(DelayMouseClickDetection());
//UI
ui.TowerPlacementMode(mode);
//Ghost
SetCurrentGhostVisibility(false);
currentGhost = ghostLookup[mode];
SetCurrentGhostVisibility(true);
//Status
IsInPlacementMode = true;
towerMode = mode;
}
public bool PurchaseTower(TowerPlatform _platform, TowerTypes _towerType)
{
// true - if enough money, false - if not enough money
bool towerWasBought = Player.instance.PurchaseTower(towers[_towerType]);
if (towerWasBought)
{
Tower newTower = Instantiate(towers[_towerType]);
_platform.AddTower(newTower);
return(true);
}
else
{
return(false);
}
}
public void PurchaseTower(string towerTypeName)
{
TowerTypes towerType = RecognizeTowerType(towerTypeName);
// true - if enough money, false - if not enough money
bool towerWasBought = TowerManager.instance.PurchaseTower(currentTowerPlatform, towerType);
if (towerWasBought)
{
towerExists = true;
towerBuyMenu.gameObject.SetActive(false);
towerUpgradeMenu.gameObject.SetActive(true);
currentTower = currentTowerPlatform.GetComponentInChildren <TowerCheck>();
currentTower.GetComponent <TowerType>().upgradeCost = currentTower.GetComponent <TowerType>().initialUpgradeCost;
upgradePriceText.text = "$" + currentTower.GetComponentInChildren <TowerType>().upgradeCost;
}
}
public GameObject GetUpgrade(Tower currentTower, int coins)
{
TowerTypes type = currentTower.type;
if (!IsUpgradeAvailable(currentTower))
{
return(null);
}
if (IsEnoughMoneyProvided(towers[currentTower.upgradeLevel + 1], coins))
{
return(towers[currentTower.upgradeLevel + 1]);
}
else
{
return(null);
}
}
public static Tower PickATower(Teams team, TowerTypes towerType)
{
GameObject blueprintTowerObject = _defaultTower.gameObject;
foreach (var t in _sampleTowers)
{
if (t.Team == team && t.TowerType == towerType)
{
blueprintTowerObject = t.gameObject;
break;
}
}
Tower newTower = Instantiate(blueprintTowerObject, LevelsMgr.CurrentLevel.transform).GetComponent <Tower>();
newTower.transform.gameObject.AddComponent <LevelChildDeleteOnReset>();
return(newTower);
}
public Button(bool vis, TowerTypes towerType)
{
Visible = vis;
switch (towerType)
{
case TowerTypes.Teacher:
id = BUTTON_MEDIA_ID.TEACHER;
break;
case TowerTypes.Lawyer:
id = BUTTON_MEDIA_ID.LAWYER;
break;
case TowerTypes.Judge:
id = BUTTON_MEDIA_ID.JUDGE;
break;
default:
id = BUTTON_MEDIA_ID.TEACHER;
break;
}
}
public static void GetStatsForTowerType(TowerTypes type, out TowerStats[] towerStats, out WeaponStats[] weaponStats)
{
switch (type)
{
case TowerTypes.Lawyer: //Base cost 15 min delay is 4
towerStats = new TowerStats[7] {
new TowerStats(15, 150, 25), new TowerStats(12, 160, 50), new TowerStats(9, 170, 90),
new TowerStats(7, 180, 200), new TowerStats(6, 190, 450), new TowerStats(5, 195, 700), new TowerStats(4, 200, -1)
};
weaponStats = new WeaponStats[7] {
new WeaponStats(5, 10, 1), new WeaponStats(18, 10, 1), new WeaponStats(40, 10, 1),
new WeaponStats(120, 10, 1), new WeaponStats(500, 10, 1), new WeaponStats(1500, 10, 1), new WeaponStats(3000, 10, 1)
};
break;
//case TowerTypes.Splash:
case TowerTypes.Teacher: //base 20
Debuff slow = new Debuff(CreepStats.Speed, 1, 10);
Debuff slow2 = new Debuff(CreepStats.Speed, 2, 20);
towerStats = new TowerStats[5] {
new TowerStats(70, 140, 40), new TowerStats(50, 150, 60),
new TowerStats(30, 150, 100), new TowerStats(20, 160, 200), new TowerStats(10, 170, -1)
};
weaponStats = new WeaponStats[5] {
new WeaponStats(20, 6, 1, slow), new WeaponStats(40, 6, 1, slow),
new WeaponStats(80, 6, 1, slow), new WeaponStats(200, 6, 1, slow2), new WeaponStats(500, 6, 1, slow2)
};
break;
//case TowerTypes.Gavel:
default: //normal for now (judge) Base 10;
towerStats = new TowerStats[6] {
new TowerStats(13, 160, 30), new TowerStats(12, 170, 50), new TowerStats(10, 190, 100),
new TowerStats(10, 210, 180), new TowerStats(9, 230, 400), new TowerStats(8, 250, -1)
};
weaponStats = new WeaponStats[6] {
new WeaponStats(5, 10, 1), new WeaponStats(20, 10, 1), new WeaponStats(50, 10, 1),
new WeaponStats(150, 10, 1), new WeaponStats(700, 10, 1), new WeaponStats(2000, 10, 1)
};
break;
}
}
public Building CreateNew(TowerTypes towerType, Point location)
{
if (towerType == TowerTypes.Arrow)
{
var tower = new Tower(location);
tower.SetSpwaner(new ArrowSpawn());
return(new ArrowTower(tower));
}
if (towerType == TowerTypes.Cannon)
{
var tower = new Tower(location);
tower.SetSpwaner(new BombSpawn());
return(new CannonTower(tower));
}
return(null);
}
private GameObject ChoosePrefab(TowerTypes towerType)
{
switch (towerType)
{
case TowerTypes.Basic:
return(_typeMap.BasicTowerPrefab);
case TowerTypes.Fire:
return(_typeMap.FireTowerPrefab);
case TowerTypes.Ice:
return(_typeMap.IceTowerPrefab);
case TowerTypes.Plasma:
return(_typeMap.PlasmaTowerPrefab);
default:
throw new InvalidOperationException($"Unknown Tower Type {towerType}");
}
}
private static string GetTowerTypeStringP(TowerTypes type)
{
switch (type)
{
case TowerTypes.Basic:
return("basic");
case TowerTypes.Fire:
return("fire");
case TowerTypes.Air:
return("air");
case TowerTypes.Earth:
return("earth");
case TowerTypes.Water:
return("water");
default: return(null);;
}
}
public Button(bool vis, TowerTypes towerType)
{
Visible = vis;
switch (towerType)
{
case TowerTypes.Teacher:
id = BUTTON_MEDIA_ID.TEACHER;
break;
case TowerTypes.Lawyer:
id = BUTTON_MEDIA_ID.LAWYER;
break;
case TowerTypes.Judge:
id = BUTTON_MEDIA_ID.JUDGE;
break;
default:
id = BUTTON_MEDIA_ID.TEACHER;
break;
}
}
public UIButton(int buttonX, int buttonY, BuildButton buildButton, GraphicsDevice graphicsDevice, Player player, Level level)
{
this.buttonX = buttonX;
this.buttonY = buttonY;
this.buildButton = buildButton;
this.player = player;
this.level = level;
this.graphicsDevice = graphicsDevice;
centerPositionTower = new Vector2(buttonX, buttonY) + new Vector2(buildButton.Texture.Width / 2, buildButton.Texture.Height / 2);
singleShotTexture = ContentConverter.Convert(singleShotPath, graphicsDevice);
singleShotUITexture = ContentConverter.Convert(singleShotUIPath, graphicsDevice);
doubleShotTexture = ContentConverter.Convert(doubleShotPath, graphicsDevice);
doubleShotUITexture = ContentConverter.Convert(doubleShotUIPath, graphicsDevice);
slowTexture = ContentConverter.Convert(slowPath, graphicsDevice);
slowUITexture = ContentConverter.Convert(slowUIPath, graphicsDevice);
rocketLauncherTexture = ContentConverter.Convert(rocketLauncherPath, graphicsDevice);
rocketLauncherUITexture = ContentConverter.Convert(rocketLauncherUIPath, graphicsDevice);
towerBuild = ContentConverter.Convert("Content/Assets/TD/UI/towerBuild.png", graphicsDevice);
towerType = TowerTypes.Single;
//texture = singleShotTexture;
}
public static Material GetMaterial(TowerTypes tower)
{
switch (tower)
{
case TowerTypes.Air:
return(airTowerMat);
case TowerTypes.Basic:
return(basicTowerMat);
case TowerTypes.Earth:
return(earthTowerMat);
case TowerTypes.Fire:
return(fireTowerMat);
case TowerTypes.Water:
return(waterTowerMat);
}
return(null);
}
public void CreateNewTower(TowerTypes type)
{
this.TowerType = type;
}
public void AddTower()
{
Tower nt = null;
switch(this.TowerType)
{
case TowerTypes.ARROW_TOWER:
nt = new ArrowTower(this.towertextures[(int)TowerTypes.ARROW_TOWER - 1], this.bullettextures[(int)TowerTypes.ARROW_TOWER - 1], this.Tile);
break;
case TowerTypes.SPIKE_TOWER:
nt = new SpikeTower(this.towertextures[(int)TowerTypes.SPIKE_TOWER - 1], this.bullettextures[(int)TowerTypes.SPIKE_TOWER - 1], this.Tile);
break;
case TowerTypes.SPEED_TOWER:
nt = new SpeedTower(this.towertextures[(int)TowerTypes.SPEED_TOWER - 1], this.bullettextures[(int)TowerTypes.SPEED_TOWER - 1], this.Tile);
break;
case TowerTypes.CANNON_TOWER:
nt = new CannonTower(this.towertextures[(int)TowerTypes.CANNON_TOWER - 1], this.bullettextures[(int)TowerTypes.CANNON_TOWER - 1], this.Tile);
break;
}
if (nt != null && this.CanPlaceTower() && nt.Cost <= this.coins)
{
this.towers.Add(nt);
this.coins -= nt.Cost;
this.TowerType = TowerTypes.TOWER_NONE;
}
this.TowerType = TowerTypes.TOWER_NONE;
}
public void HandleClick(TowerTypes towerType)
{
BuyPlaceTower(towerType);
}
public void BuyPlaceTower(TowerTypes type)
{
if(!towers.ContainsKey(selectedTile) && CurrentPlayer.WithdrawalMoney(TowerFactory.GetTowerCost(type)))
{
towers.Add(selectedTile, TowerFactory.GetTower(type, new Vector2(selectedTile.X * TileDimensions.X, selectedTile.Y * TileDimensions.Y)));
}
}
public void TowerPlacementMode(TowerTypes mode)
{
//Tell HDU manager we're in placement mode
hud.EnterPlacementMode(mode);
}
/// <summary>
/// Should eventually return an array, for different levels
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static MEDIA_ID GetTowerMediaID(TowerTypes type)
{
if (type == TowerTypes.Judge)
{
return MEDIA_ID.TOWER_0;
}
else if (type == TowerTypes.Lawyer)
{
return MEDIA_ID.TOWER_1;
}
return MEDIA_ID.TOWER_2;
//switch(type) <-needs that eventually
}
private ProjectileTypes SelectTypeBasedOnTowerType(TowerTypes type)
{
if (type == TowerTypes.Judge)
{
return ProjectileTypes.Gavel;
}
else if (type == TowerTypes.Lawyer)
{
return ProjectileTypes.Scroll;
}
return ProjectileTypes.Teacher;
//have a switch here at some point
}
