public void StartBuildMode(string type)
{
TowerGUI.instance.Deactivate();
buildTower = true;
switch (type)
{
case "Common":
tower = prefabCommonTower.GetComponent <TowerClass>();
break;
case "Slow":
tower = prefabSlowTower.GetComponent <TowerClass>();
break;
case "Poison":
tower = prefabPoisonTower.GetComponent <TowerClass>();
break;
case "Splash":
tower = prefabSplashTower.GetComponent <TowerClass>();
break;
case "AntiAir":
tower = prefabAntiAirTower.GetComponent <TowerClass>();
break;
}
}
/// <summary>
/// Build Tower
/// </summary>
/// <param name="key"></param>
public bool BuildTower(string key)
{
if (mTower == null)
{
mWalkable = false;
if (!GameManager.Instance.GetWaveManager().GetIsWaving())
{
mMap.GetPathFinding().PathFind();
if (!mMap.GetPathFinding().GetPathSuccess())
{
mWalkable = true;
return(false);
}
}
mTower = CreateTower(key);
if (!mTower.Build(this, key))
{
Debug.Log("Failed Tower Initialize.");
return(false);
}
GameManager.Instance.GetPlayerInfo().Gold -= mTower.GetPrice();
return(true);
}
return(false);
}
/// <summary>
/// Create Tower Class
/// </summary>
/// <param name="towerName"></param>
/// <returns></returns>
private TowerClass CreateTower(string towerName)
{
GameObject towerObject = GameManager.Instance.GetObjectPool().SpawnTowerFromPool(towerName, transform);
TowerData towerData = GameManager.Instance.GetObjectPool().TowerDataDictionary[towerName];
TowerClass tower = null;
switch (towerData.TOWERTYPE)
{
case TowerType.Attack:
tower = towerObject.AddComponent <AttackTowerClass>();
break;
case TowerType.Buff:
tower = AddBuffTowerClass(towerObject, towerData);
break;
default:
tower = null;
Debug.LogError("Tower is null");
break;
}
mSoundManager.PlayTowerBuildSfx();
mMap.AddTower(tower);
return(tower);
}
public void Activate(string type)
{
switch (type)
{
case "Common":
tower = commonTower;
break;
case "Slow":
tower = slowTower;
break;
case "Poison":
tower = poisonTower;
break;
case "Splash":
tower = splashTower;
break;
case "AntiAir":
tower = antiAirTower;
break;
}
}
// Update is called once per frame
void Update()
{
if (MainClass.instance.gameState != GameState.Lose && MainClass.instance.gameState != GameState.Win)
{
if (Input.GetKey("1"))
{
StartBuildMode("Common");
}
if (Input.GetKey("2"))
{
StartBuildMode("Slow");
}
if (Input.GetKey("3"))
{
StartBuildMode("Poison");
}
if (Input.GetKey("4"))
{
StartBuildMode("Splash");
}
if (Input.GetKey("5"))
{
StartBuildMode("AntiAir");
}
if (Input.GetKey(KeyCode.Escape))
{
buildTower = false;
}
if (buildTower)
{
if (Input.GetMouseButtonDown(0))
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity, placementLayerMask))
{
Debug.DrawLine(ray.origin, hit.point, Color.green, 20);
if (hit.transform.tag == "Open")
{
if (PlayerScript.instance.gold - tower.towerCost >= 0)
{
PlayerScript.instance.gold -= tower.towerCost;
TowerClass temp = null;
temp = Instantiate(tower, new Vector3(hit.transform.position.x, hit.transform.position.y + 0.5f, hit.transform.position.z), hit.transform.rotation) as TowerClass;
temp.GetComponent <TowerClass>().place = hit.transform.gameObject;
hit.transform.tag = "Close";
buildTower = false;
}
else
{
Debug.Log("Not enough gold!");
}
}
}
}
}
}
}
public float GetRange(TowerClass towerClass, int towerLevel)
{
for (int i = 0; i < updateSettings.Length; i++)
{
if (updateSettings[i].towers == towerClass)
{
if (towerLevel > updateSettings[i].range.Length)
{
return(updateSettings[i].range[updateSettings[i].range.Length - 1]);
}
return(updateSettings[i].range[towerLevel - 1]);
}
}
return(0);
}
public float GetUpdatePrice(TowerClass towerClass, int towerLevel)
{
foreach (UpdateSettings setting in updateSettings)
{
if (setting.towers == towerClass)
{
if (towerLevel > setting.updatePrice.Length)
{
return(0);
}
return(setting.updatePrice[towerLevel - 1]);
}
}
return(0);
}
public float GetShotInterval(TowerClass towerClass, int towerLevel)
{
foreach (UpdateSettings setting in updateSettings)
{
if (setting.towers == towerClass)
{
if (towerLevel > setting.shotInterval.Length)
{
return(setting.shotInterval[setting.shotInterval.Length - 1]);
}
return(setting.shotInterval[towerLevel - 1]);
}
}
return(0);
}
/// <summary>
/// Destory Tower
/// </summary>
/// <returns></returns>
public bool DestoryTower()
{
if (mTower == null)
{
return(false);
}
else
{
mTower.DestroyTower(this);
mWalkable = true;
mMap.SetSelectedCell(null);
mTower = null;
if (!GameManager.Instance.GetWaveManager().GetIsWaving())
{
mMap.GetPathFinding().PathFind();
}
mSoundManager.PlayTowerDestroySfx();
return(true);
}
}
/// <summary>
/// 버프를 줄 수 있는 좌표에 있는 타워들을 가져오는 함수.
/// </summary>
/// <param name="coordi"></param>
/// <returns></returns>
protected TowerClass[] GetTargetTowers(List <Tuple <int, int> > coordi)
{
List <TowerClass> targetTowers = new List <TowerClass>();
CellClass[,] map = GameManager.Instance.GetMapManager().GetMap();
for (int i = 0; i < coordi.Count; i++)
{
int x = coordi[i].Item1;
int y = coordi[i].Item2;
TowerClass targetTower = map[x, y].GetTower();
if (targetTower != null)
{
if (targetTower.TowerType == TowerType.Attack)
{
targetTowers.Add(targetTower);
}
}
}
return(targetTowers.ToArray());
}
private TowerClass AddBuffTowerClass(GameObject towrObj, TowerData data)
{
TowerClass tower = null;
BuffShapeType buffShapeType = data.BUFFSHAPETYPE;
switch (buffShapeType)
{
case BuffShapeType.Plus:
tower = towrObj.AddComponent <PlusBuffTowerClass>();
break;
case BuffShapeType.Cross:
tower = towrObj.AddComponent <CrossBuffTowerClass>();
break;
case BuffShapeType.Cube:
tower = towrObj.AddComponent <CubeBuffTowerClass>();
break;
case BuffShapeType.Knight:
tower = towrObj.AddComponent <KnightBuffTowerClass>();
break;
case BuffShapeType.HorizontalSteppingStone:
tower = towrObj.AddComponent <HorizontalSteppingStoneBuffTowerClass>();
break;
case BuffShapeType.VerticalSteppingStone:
tower = towrObj.AddComponent <VerticalSteppingStoneBuffTowerClass>();
break;
}
if (tower == null)
{
Debug.Log("Buff Tower Class is null");
}
return(tower);
}
public void SetTower(TowerClass tower)
{
targetByTower.Add(tower);
}
public void Init(TowerClass twr, Transform enmy)
{
enemy = enmy;
tower = twr;
}
public void RemoveTower(TowerClass tower)
{
targetByTower.Remove(tower);
}
/// <summary>
/// Cell Class Initialize
/// </summary>
/// <param name="x"> cell index x</param>
/// <param name="y"> cell index y</param>
/// <param name="towerData">tower data</param>
/// <returns></returns>
public bool Initialize(int x, int y, string towerData)
{
mCellIndexX = x;
mCellIndexY = y;
mWalkable = true;
mSoundManager = GameManager.Instance.GetSoundManager();
if (!mSoundManager)
{
Debug.Log("Failed Get mSoundManager");
return(false);
}
mMap = GetComponentInParent <MapManager>();
if (!mMap)
{
Debug.Log("Failed Initialize Map Component");
return(false);
}
if (x == 0 && y == 0)
{
mState = CellState.EStart;
}
else if (x == mMap.GetMapSizeX() - 1 && y == mMap.GetMapSizeY() - 1)
{
mState = CellState.EGoal;
}
else
{
mState = CellState.EDefault;
}
string matPath = "02.Materials/01.Cells/";
mMaterials = new Material[(int)CellState.End];
mMaterials[(int)CellState.EDefault] = Resources.Load(matPath + "CellDefault") as Material;
if (!mMaterials[(int)CellState.EDefault])
{
Debug.Log("Failed Load CellDefault Material.");
return(false);
}
mMaterials[(int)CellState.EStart] = Resources.Load(matPath + "CellStart") as Material;
if (!mMaterials[(int)CellState.EStart])
{
Debug.Log("Failed Load CellStart Material.");
return(false);
}
mMaterials[(int)CellState.EGoal] = Resources.Load(matPath + "CellGoal") as Material;
if (!mMaterials[(int)CellState.EGoal])
{
Debug.Log("Failed Load CellGoal Material.");
return(false);
}
mMaterials[(int)CellState.ERoad] = Resources.Load(matPath + "CellRoad") as Material;
if (!mMaterials[(int)CellState.ERoad])
{
Debug.Log("Failed Load CellRoad Material.");
return(false);
}
mMaterials[(int)CellState.ESelected] = Resources.Load(matPath + "CellSelected") as Material;
if (!mMaterials[(int)CellState.ESelected])
{
Debug.Log("Failed Load CellSelected Material.");
return(false);
}
mMaterials[(int)CellState.EBuff] = Resources.Load(matPath + "CellBuff") as Material;
if (!mMaterials[(int)CellState.EBuff])
{
Debug.Log("Failed Load CellBuff Material.");
return(false);
}
mMeshRenderer = GetComponent <MeshRenderer>();
if (!mMeshRenderer)
{
Debug.Log("Failed Initialize mMeshRenderer Component");
return(false);
}
if (mMaterials[(int)mState] == null)
{
Debug.Log("Failed Found Material in mMaterials Array.");
return(false);
}
mMeshRenderer.material = mMaterials[(int)mState];
if (towerData == "0")
{
mTower = null;
}
else
{
mTower = CreateTower(towerData);
if (!mTower.Initialize(towerData))
{
Debug.Log("Failed Tower Initialize");
return(false);
}
mWalkable = false;
}
return(true);
}
public void SetTower(TowerClass tower)
{
targetByTower.Add(tower);
}
// Use this for initialization
void Start()
{
towerInfo = null;
groupWidth = Screen.width / 2;
groupHeight = Screen.height / 3 + 25;
}
public void Activate(GameObject tower)
{
towerInfo = tower.GetComponent <TowerClass>();
}
// Update is called once per frame
void Update()
{
tower = null;
}
void Start()
{
tower = null;
}
public void Init(TowerClass twr, Transform enmy)
{
enemy = enmy;
tower = twr;
}
/// <summary>
/// 현재 맵에 있는 타워 List에서 제거.
/// </summary>
/// <param name="tower"></param>
public void RemoveTower(TowerClass tower)
{
mTowers.Remove(tower);
}
public void Deactivate()
{
towerInfo = null;
}
public void RemoveTower(TowerClass tower)
{
targetByTower.Remove(tower);
}
/// <summary>
/// 현재 맵에 있는 타워 List에서 추가
/// </summary>
/// <param name="tower"></param>
public void AddTower(TowerClass tower)
{
mTowers.Add(tower);
}
