// Update is called once per frame
void Update()
{
if (enemySpawnSequence.Count <= 0)
{
return;
}
float currentTime = Time.time - sceneLoadTime;
EnemySpawnData data = (EnemySpawnData)enemySpawnSequence[0];
if (data.isSpawnCheckpoint())
{
gameData.checkpointReached();
enemySpawnSequence.RemoveAt(0);
}
else
{
float yCoordinate = determineBulletLocationWithPercentage(data.getYSpawnPercentage());
UnityEngine.Object enemyToSpawn = (UnityEngine.Object)enemyTypeList[data.getEnemyType()];
if (currentTime >= data.getLocation())
{
Instantiate(enemyToSpawn,
new Vector3(enemySpawnerObject.position.x, yCoordinate, enemySpawnerObject.position.z),
enemySpawnerObject.rotation);
enemySpawnSequence.RemoveAt(0);
}
}
}
public void CreateEnemyList(int pWaveIndex)
{
//Will hold number of Enemys present in wave
int enemyCount = 0;
//*** Cached reference to current enemy gameobject
GameObject currentEnemyGameObject = null;
//*** Iterate through different enemy spawn types
for (int x = 0; x < enemyRounds[pWaveIndex].EnemyTypesInWave.Count; x++)
{
//*** Get number of enemies spawning in the wave
enemyCount = enemyRounds [pWaveIndex].EnemyTypesInWave [x].enemiesInWave;
//*** Create Spawn data
for (int z = 0; z < enemyCount; z++)
{
//*** Get Current enemy GameObject
currentEnemyGameObject = enemyRounds [pWaveIndex].EnemyTypesInWave [x].enemyType;
//*** Create enemy spawn data
EnemySpawnData enemySpawn = new EnemySpawnData();
//*** Assign reference to enemy
enemySpawn.enemyGameObject = currentEnemyGameObject;
//*** Get random enemy position seed for sorting
enemySpawn.spawnSeed = Random.Range(0, 500);
//*** Add enemy Data to the list
basicEnemySpawnList.Add(enemySpawn);
}
}
}
private void AddEnemyToWave(EnemyType type, int wave, float health)
{
EnemySpawnData enemyToAdd = new EnemySpawnData();
enemyToAdd.type = type;
enemyToAdd.wave = wave;
enemyToAdd.health = health;
waveData.Add(enemyToAdd);
}
// Check that the spawn data is still usable
public static bool CheckDataActive(EnemySpawnData data, float time)
{
if (!IsDataValid(data))
{
return(false);
}
return(data.startSpawnTime <= time && time <= data.endSpawnTime);
}
private void LoadStageData()
{
enemiesToSpawn = new Queue <EnemySpawnData>();
for (int i = 0; i < stageData.enemyType.Length; ++i)
{
EnemySpawnData enemySpawnData = new EnemySpawnData();
enemySpawnData.enemyType = stageData.enemyType[i];
enemySpawnData.spawnTime = stageData.enemySpawnTime[i];
enemiesToSpawn.Enqueue(enemySpawnData);
}
}
void Awake()
{
ins = this;
enemySpawnData = GetComponent <EnemySpawnData> ();
gridPallete = transStartPointPallete.GetComponent <UIGrid> ();
CreatePallete();
CreateTile();
InitFirst();
}
public void Spawn(string prefabId, string uniqueId = "")
{
EnemySpawnData spawnData = new EnemySpawnData()
{
Position = transform.position,
EnemyType = prefabId,
OverrideId = uniqueId,
PatrolLoopId = _patrolLoopId
};
EnemyManager.Instance.SpawnEnemy(spawnData);
}
EnemyMovement SetMove(EnemySpawnData data, GameObject obj)
{
switch (data.moveType)
{
case MoveType.None: return(null);
case MoveType.Default: return(obj.AddComponent <DefaultMove>());
case MoveType.Sucide: return(obj.AddComponent <SuicideMove>());
default: Debug.Assert(false, "not come here..."); return(null);
}
}
// Create a controller if the data is valid
public static SpawnController CreateController(EnemySpawnData spawnData, int id)
{
if (EnemyUtils.IsDataValid(spawnData))
{
SpawnController newController = new SpawnController();
newController.data = spawnData;
newController.time = 0f;
newController.count = 0;
newController.id = id;
//UnityEngine.Debug.Log("Creating spawn controller, " + spawnData.enemyId + ", time: " + spawnData.startSpawnTime + " - " + spawnData.endSpawnTime);
return(newController);
}
return(null);
}
public void SpawnEnemy(EnemySpawnData spawnData)
{
EnemyData data;
if (!_enemyDataConfig.TryGetValue(spawnData.EnemyType, out data))
{
CustomLogger.Error(nameof(EnemyManager), $"Could not retrieve {nameof(EnemyData)} from id {spawnData.EnemyType}");
return;
}
// Get a pooled enemy object
PooledObject pooledObject;
if (!PooledObjectManager.Instance.UsePooledObject(data.UnitPrefabId, out pooledObject))
{
PooledObjectManager.Instance.RegisterPooledObject(data.UnitPrefabId, 1);
CustomLogger.Log(nameof(EnemyManager), $"{data.UnitPrefabId} not yet registered with object pool. Registering now...");
SpawnEnemy(spawnData);
return;
}
EnemyUnit unit = pooledObject as EnemyUnit;
if (unit == null)
{
CustomLogger.Error(nameof(EnemyManager), $"Pooled Object was not of type {nameof(EnemyUnit)}");
return;
}
// prep unit
unit.transform.position = spawnData.Position;
UnitInitializationData initData = new UnitInitializationData()
{
OverrideUniqueId = spawnData.OverrideId,
UnitData = data
};
unit.Initialize(initData);
unit.CombatController.SetWeapon(data.EquippedWeapon);
AddUnitListeners(unit);
unit.Spawn();
UnitsManager.Instance.RegisterUnit(unit);
// add enemy controller to list and dictionary
_enemyUnitsById.Add(unit.UnitId, new EnemyInfo(unit.UnitId, spawnData.PatrolLoopId, unit));
OnEnemySpawned?.Invoke(unit);
}
// Check spawn data if new enemies must be spawned
public static bool CheckSpawnNeeded(EnemySpawnData data, float currentTime, float controllerTime, int spawnCount)
{
if (!CheckDataActive(data, currentTime))
{
return(false);
}
if (spawnCount == 0)
{
// on first spawn, check spawn timer
return(controllerTime >= data.startSpawnTime);
}
else
{
// after the first spawn, rely on checking timer vs spawn intervals
return(controllerTime >= data.spawnIntervals);
}
}
public int SpawnEnemies(EnemySpawnData data, int count, int controllerId)
{
//Debug.Log("SPAWN ENEMY: id " + data.enemyId + ", count " + count);
int created = 0;
if (data == null)
{
return(created);
}
// First count existing enemies
int existingEnemies = CountEnemiesFromController(controllerId);
int allowableEnemies = data.maxEnemies - existingEnemies;
if (allowableEnemies <= 0)
{
return(created);
}
if (count > allowableEnemies)
{
count = allowableEnemies; // Limit the enemies to create
}
//EnemyData.Type enemyType = data.type;
int enemyID = data.enemyId;
MovingEnemy refEnemy = GetEnemyReference(enemyID);
if (refEnemy != null)
{
for (int i = 0; i < count; i++)
{
MovingEnemy newEnemy = (MovingEnemy)refEnemy.Create(transform, target);
newEnemy.id = AddEnemy(newEnemy);
newEnemy.gameObject.name = "enemy_" + newEnemy.GetDataId() + "_" + newEnemy.id;
newEnemy.spawnControllerId = controllerId;
newEnemy.Enter();
}
}
return(created);
}
public LevelController(EnemyLevelData data)
{
level = data.level;
spawners = new SpawnController[data.spawnData.Length];
int created = 0;
for (int i = 0; i < data.spawnData.Length; i++)
{
EnemySpawnData spawnData = data.spawnData[i];
spawners[i] = SpawnController.CreateController(spawnData, i);
if (spawners[i] != null)
{
created++;
// Setting extremes of spawn times as the level time range.
if (minTime < 0f)
{
minTime = spawnData.startSpawnTime;
}
else
{
if (minTime > spawnData.startSpawnTime)
{
minTime = spawnData.startSpawnTime;
}
}
if (maxTime < 0f)
{
maxTime = spawnData.endSpawnTime;
}
else
{
if (maxTime < spawnData.endSpawnTime)
{
maxTime = spawnData.endSpawnTime;
}
}
}
}
//Debug.Log("spawners.Length : " + spawners.Length + ", created: " + created);
}
// Check that data content is valid
public static bool IsDataValid(EnemySpawnData data)
{
bool isValid = false;
//string log = "null? " + (data == null);
if (data != null)
{
isValid = (data.endSpawnTime > data.startSpawnTime) &&
data.startCount > 0 &&
data.spawnIntervals > 0f;
//log += ", start " + data.startSpawnTime +
// ", end " + data.endSpawnTime +
// ", startcount " + data.startCount +
// ", interval " + data.spawnIntervals;
//Debug.Log("EnemySpawnData invalid: " + log + ", isValid " + isValid);
}
return(isValid);
}
IEnumerator MakeEnemy()
{
// 読み出し位置
int position = 0;
while (position < enemySpawnData.Length)
{
// 読み出す
EnemySpawnData data = enemySpawnData[position];
// 出現時間まで待機
yield return(new WaitForSeconds(data.delaySeconds));
// 敵を出現させる
SpawnEnemy(data);
// 次の読み出し位置に進める
position++;
}
yield break;
}
// 敵を生成する
void SpawnEnemy(EnemySpawnData data)
{
Vector3 pos = new Vector3(data.x, data.y, transform.position.z);
switch (data.type)
{
case BaseEnemy.Type.GHOST:
// 敵を生成
Instantiate(enemyGhostPrefab, pos, transform.rotation);
break;
case BaseEnemy.Type.BOSS:
// Bossを生成
Instantiate(bossEnemyPrefab, pos, transform.rotation);
break;
default:
break;
}
}
private IEnumerator EnemySpawnCoroutine(EnemySpawnData enemyData)
{
Debug.Log("Start coroutine: enemy spawn. Enemy: " + enemyData.enemyPoolable + ". Enemy count:" + enemyData.numberOfEnemies);
int index = 0;
if (enemyData.spawnAtWaveStart)
{
SpawnEnemy(enemyData.enemyPoolable);
index++;
yield return(new WaitForSeconds(enemyData.spawnTimeInterval));
}
for ( ; index < enemyData.numberOfEnemies; index++)
{
SpawnEnemy(enemyData.enemyPoolable);
yield return(new WaitForSeconds(enemyData.spawnTimeInterval));
}
completedCoroutines++;
}
void Awake()
{
//Debug.Log (this + " Awake");
ins = this;
trans = transform;
int i, iMax;
Transform _t;
//SpawnPoint -> Dic<int, Transform>
for (i = 0, iMax = transform.childCount; i < iMax; i++)
{
_t = trans.GetChild(i);
dicSpawnPoint.Add(int.Parse(_t.name), _t);
}
//EnemyKind -> Dic<int, GameObject>
for (i = 0, iMax = listEnemyKind.Count; i < iMax; i++)
{
dicEnemyName.Add(listEnemyKind [i].enemyNum, listEnemyKind [i].enemyPrefab.name);
}
}
private void FilterSpawnToCheckpointIndex(int index)
{
int checkpointsReached = 0;
while (enemySpawnSequence.Count >= 0)
{
EnemySpawnData data = (EnemySpawnData)enemySpawnSequence[0];
if (data.isSpawnCheckpoint())
{
checkpointsReached++;
if (checkpointsReached >= index)
{
sceneLoadTime -= data.getLocation();
return;
}
}
else
{
enemySpawnSequence.RemoveAt(0);
}
}
}
void Update()
{
while (spawnCounter < enemySpawns.Count)
{
EnemySpawnData data = enemySpawns[spawnCounter];
if (data.frameCount < Time.frameCount)
{
Instantiate(LoadablePrefabSet[data.enemyPrefab], data.position, Quaternion.identity);
spawnCounter++;
continue;
}
break;
}
if (Input.GetKeyDown(KeyCode.P))
{
string json = "";
foreach (EnemySpawnData data in enemySpawnHistory)
{
json += JsonUtility.ToJson(data) + "\n";
}
WriteString(json);
}
}
void Start()
{
if (!onDebug)
{
debugMode = false; selectedStage = (EStage)PlayerPrefs.GetInt("StageNumbers");
}
else
{
debugMode = true;
}
if (selectedStage != EStage.DEBUG_MODE)
{
//// string[0] : waveNum
//// string[1] : enemyID
//// string[2] : enemyName
//// string[3] : startTime
//// string[4] : respawnTime
//// string[5] : spawnLimit
//var waveDataList = GameManager.Member.WaveDataList;
//for (int i = 0; i < 3; ++i) { waves[i] = new List<EnemySpawnData>(); }
//foreach (var strings in waveDataList)
//{
// GameObject obj = null;
// Vector3 offset = Vector3.zero;
// // ザコ
// // ID : 101 : スライム
// // ID : 102 : ゴブリン
// // ID : 103 : オーク
// // ボス
// // ID : 1001 : スライム
// // ID : 1002 : ゴブリン
// // ID : 1003 : オーク
// if (strings[1] == "101") { obj = slime; offset = offset_slime; }
// else if (strings[1] == "102") { obj = skeleton; offset = offset_skeleton; }
// else if (strings[1] == "103") { obj = ork; offset = offset_ork; }
// else if (strings[1] == "1001") { obj = boss_slime; offset = offset_boss_slime; }
// else if (strings[1] == "1002") { obj = boss_skeleton; offset = offset_boss_skeleton; }
// else if (strings[1] == "1003") { obj = boss_ork; offset = offset_boss_ork; }
// // スポーンデータに各要素を格納
// EnemySpawnData esd = new EnemySpawnData(
// obj, // enemyObj
// strings[2], // enemyName
// offset, // position
// float.Parse(strings[3]), // startTime
// float.Parse(strings[4]), // respawnTime
// int.Parse(strings[5]), // spawnLimit
// transform); // parentTransform
// // 対応するwaveにスポーンデータ追加
// waves[int.Parse(strings[0]) - 1].Add(esd);
//}
for (int i = 0; i < 3; ++i)
{
waves[i] = new List <EnemySpawnData>();
}
for (var i = 0; i < 3; i++)
{
var waveData = GameManager.Member.WavesData[i];
for (var j = 0; j < 3; j++)
{
var spawnData = waveData.SpawnData[j];
GameObject obj = null;
Vector3 offset = Vector3.zero;
switch (spawnData.Name)
{
case "Ork": obj = ork; offset = offset_ork; break;
case "Skeleton": obj = skeleton; offset = offset_skeleton; break;
case "Boss Skeleton": obj = boss_skeleton; offset = offset_boss_skeleton; break;
}
// スポーンデータに各要素を格納
EnemySpawnData esd = new EnemySpawnData(
obj, // enemyObj
spawnData.Name, // enemyName
offset, // position
spawnData.SpawnStartTime, // spawnStartTime
spawnData.SpawnInterval, // spawnInterval
spawnData.SpawnLimitNum, // spawnLimitNum
transform); // parentTransform
// 対応するwaveにスポーンデータ追加
waves[i].Add(esd);
}
}
Debug.Log("waves[0].Count" + waves[0].Count);
Debug.Log("waves[1].Count" + waves[1].Count);
Debug.Log("waves[2].Count" + waves[2].Count);
// 現在のウェーブの最大スポーン数を格納
total_spawnLimit = 0;
foreach (var esd in waves[cur_waveNum])
{
total_spawnLimit += esd.SpawnLimit;
}
}
StartCoroutine(MainCoroutine());
if (debugMode)
{
StartCoroutine(GameManager.Member.PlayerAttack.AttackCoroutine());
}
}
IEnumerator main_loop()
{
for (;;) {
switch (scene_type_) {
// title loop
case SceneType.Title:
for (;;) {
if (true &&
Input.GetKey(KeyCode.O) &&
Input.GetKey(KeyCode.K) &&
Input.GetKey(KeyCode.M) &&
Input.GetKey(KeyCode.Z) &&
Input.GetKey(KeyCode.X) &&
Input.GetKey(KeyCode.C) &&
true) {
yield return new WaitForSeconds(0.25f);
UnityEngine.SceneManagement.SceneManager.LoadScene("main",
UnityEngine.SceneManagement.LoadSceneMode.Single);
break;
}
yield return null;
}
scene_type_ = SceneType.Main;
break;
// game start
case SceneType.Main:
if (score_manager_ == null) {
score_manager_ = GameObject.Find("ScorePanel").GetComponent<ScoreManager>();
}
if (camera_damage_effect_ == null) {
camera_damage_effect_ = GameObject.Find("Main Camera").GetComponent<CameraDamageEffect>();
}
// if (message_actor_ == null) {
// message_actor_ = GameObject.Find("MessagePanel").GetComponent<WidgetActor>();
// }
if (message_start_actor_ == null) {
message_start_actor_ = GameObject.Find("MessageStart").GetComponent<WidgetActor>();
}
if (message_finish_actor_ == null) {
message_finish_actor_ = GameObject.Find("MessageFinish").GetComponent<WidgetActor>();
}
if (message_win_actor_ == null) {
message_win_actor_ = GameObject.Find("MessageWin").GetComponent<WidgetActor>();
}
if (message_lose_actor_ == null) {
message_lose_actor_ = GameObject.Find("MessageLose").GetComponent<WidgetActor>();
}
if (score_actor_ == null) {
score_actor_ = GameObject.Find("ScorePanel").GetComponent<WidgetActor>();
}
if (player_ == null) {
player_ = GameObject.Find("player").GetComponent<Player>();
}
yield return null;
GetComponent<AudioSource>().Play();
enemy_spawn_data_ = new EnemySpawnData();
enemy_spawn_data_.createData();
score_manager_.setup(enemy_spawn_data_.getTotalNum());
start_time_ = Time.time;
// message_actor_.beginMessage("START!");
message_start_actor_.begin();
player_.InPlay = true;
for (;;) {
float game_time = Time.time - start_time_;
bool runout;
List<EnemySpawnDataUnit> spawn_list = enemy_spawn_data_.getSpawnList(game_time, out runout);
foreach (var spawn in spawn_list) {
Debug.Assert(enemy_prefabs_[(int)spawn.element_type_] != null);
var go = Instantiate(enemy_prefabs_[(int)spawn.element_type_],
spawn.position_,
Quaternion.identity) as GameObject;
var enemy = go.GetComponent<Enemy>();
enemy.setup(spawn);
}
yield return null;
if (runout && GameObject.FindGameObjectsWithTag("Enemy").Length <= 0) {
break;
}
}
player_.InPlay = false;
yield return new WaitForSeconds(1);
// message_actor_.beginMessage("FINISH!");
message_finish_actor_.begin();
yield return new WaitForSeconds(1);
GetComponent<AudioSource>().Stop();
score_actor_.beginResult();
yield return new WaitForSeconds(2);
if (score_manager_.won()) {
// message_actor_.beginMessage("WIN!");
message_win_actor_.begin();
} else {
// message_actor_.beginMessage("LOSE");
message_lose_actor_.begin();
}
yield return new WaitForSeconds(3);
scene_type_ = SceneType.Title;
UnityEngine.SceneManagement.SceneManager.LoadScene("title",
UnityEngine.SceneManagement.LoadSceneMode.Single);
break;
}
yield return null;
}
}
public void spawnMinions()
{
if (gamePhase.Equals("Attack") && sleep < 1)
{
/*
* int maxSpawn = wave + 1;
* if (maxSpawn > 11) {
* maxSpawn = 11;
* }
*
* int rnd = Random.Range(1,maxSpawn); // 1-10
*
* spawns[maxSpawn-2].transform.GetChild(0).GetComponent<Digger>().activateDigger(); //play digger animation
*/
//int maxSpawn = wave; 18.7
//if(wave > 5 ) { //10 muutettu
// maxSpawn = 5; //10 muutettu
//} 18.7
//int rnd = Random.Range(0, maxSpawn);
//Testing Enemy spawngin. Needs to be reworked in future! -------------------------------------------------HOX HOX HOX!
//int rndEnemy = Random.Range(1, 20 + wave); //Starst from 1-20
//SpeedFly level 1 1-15
/*
* if(rndEnemy >= 1 && rndEnemy <= 12){
* spawndable = enemy1;
* sleep = 300;
* }
* //LadyBug level 1 16 - 30
* else if (rndEnemy >= 13 && rndEnemy <= 26){
* sleep = 600;
* spawndable = enemy2;
* } //Beetle level 1
* else if( rndEnemy >= 27 && rndEnemy <= 999 ) {
* sleep = 600;
* spawndable = enemy3;
* }
*
* if (musteringPoints >= spawndable.GetComponent<EnemyScript>().getCost()) {
*
* Debug.Log("Spawnpoint RND was : " + rnd);
* Instantiate(spawndable, activatedSpawns[rnd].transform.position, Quaternion.identity);
*
* musteringPoints -= spawndable.GetComponent<EnemyScript>().getCost();
* activeMinionsOnField++;
* }
* //------------------------------Nopee korjaus------------------------------
* else if(musteringPoints >= enemy2.GetComponent<EnemyScript>().getCost()){
* Instantiate(enemy2, activatedSpawns[rnd].transform.position, Quaternion.identity);
*
* musteringPoints -= enemy2.GetComponent<EnemyScript>().getCost();
* activeMinionsOnField++;
* musteringPoints = 0;
* }
* else{
* musteringPoints = 0;
* }*/
//------------------------------Nopee korjaus------------------------------
if (spawnProgress < listOfEnemies.Count) //new spawnsystem
{
if (listOfEnemies[spawnProgress].getEnemyNumber() == 1)
{
spawnable = enemy1; //speedfly
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 2)
{
spawnable = enemy2; //ladybug
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 3)
{
spawnable = enemy3; //beetle
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 4)
{
spawnable = enemy4; //fly elite
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 5)
{
spawnable = enemy5; //ladybug elite
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 6)
{
spawnable = enemy6; //beetle
sleep = 600f;
}
else if (listOfEnemies[spawnProgress].getEnemyNumber() == 7)
{
spawnable = enemy7Bumblebee; //bumblebee
sleep = 600f;
}
Instantiate(spawnable, activatedSpawns[listOfEnemies[spawnProgress].getSpwnPoint()].transform.position, Quaternion.identity);
spawnProgress++;
activeMinionsOnField++; //new spawnsystem
}
}
//Enemy Spawn speed over waves
//HighScores :
//2.7 Mikko - Wave 17 - vaikeus 2f
if (gamePhase.Equals("Attack"))
{
//sleep -= (100 + (wave * wave * 2f)) * Time.deltaTime; //19.7 asti
sleep -= (100 + (wave * wave)) * Time.deltaTime;
}
//Check for wave end condition
if (gamePhase.Equals("Attack") && activeMinionsOnField == 0 && spawnProgress == listOfEnemies.Count && leafHP > 0)
{
spawnProgress = 0; //new spawnsystem
//for (int i = 0; i < wave ;i++) { //new spawnsystem
EnemySpawnData newEnemy = new EnemySpawnData(wave + 1);
//If new enemy is Beetle, insert it to beginnig of list. Else add to end
if (newEnemy.getEnemyNumber() == 3 || newEnemy.getEnemyNumber() == 6)
{
listOfEnemies.Insert(0, newEnemy);
}
else
{
listOfEnemies.Add(newEnemy);
}
//listOfEnemies.Add(new EnemySpawnData(wave + 1)); //new spawnsystem
//Enemy roster maximum size
//if (listOfEnemies.Count > 20) {
// listOfEnemies.RemoveAt(0);
//}
//} //new spawnsystem
gamePhase = "Build";
if (leafHP > 0)
{
uiCanvas.transform.GetChild(5).gameObject.GetComponent <TextAnnouncer>().startAnnounce("Wave " + wave + " complete!");
playAudio(textPhaseAnnounce, 0.8f);
}
wave++;
//money += 50;
buildableTowers += 1;
money += 1;
//Debug.Log("Mustring : " + musteringPoints + " Wave : " + wave);
TileScript.cursorActive = true;
GameObject[] towers = GameObject.FindGameObjectsWithTag("Tower");
int income = 0;
foreach (GameObject tower in towers)
{
income += tower.GetComponent <TowerScript>().getMoneyProduction();
}
// Debug.Log("Towers found : " +towers.Length);
money += income;
uiCanvas.GetComponent <CanvasScript>().setAttackPhase(false);
uiCanvas.GetComponent <CanvasScript>().updateWave(wave);
uiCanvas.GetComponent <CanvasScript>().updateMoney(money);
uiCanvas.GetComponent <CanvasScript>().updateTowers(buildableTowers);
GameObject.Find("MusicPlayer").GetComponent <MusicPlayerScript>().playBuildMusic();
setGameSpeed(1);
//update spawnpoint
bool doUntil = false;
if (wave < 6) //11 kumitettu
{
while (!doUntil)
{
int rnd = Random.Range(0, 10); // 0-9
if (!spawns[rnd].transform.GetChild(0).GetComponent <Digger>().getActivated())
{
spawns[rnd].transform.GetChild(0).GetComponent <Digger>().activateDigger();
activatedSpawns[wave - 1] = spawns[rnd];
doUntil = true;
}
}
}
}
}
void Start()
{
// string[0] : waveNum
// string[1] : enemyID
// string[2] : enemyName
// string[3] : startTime
// string[4] : respawnTime
// string[5] : spawnLimit
var waveDataList = GameManager.Member.WaveDataList;
for (int i = 0; i < 3; ++i)
{
waves[i] = new List <EnemySpawnData>();
}
foreach (var strings in waveDataList)
{
GameObject obj = null;
Vector3 offset = Vector3.zero;
// ザコ
// ID : 101 : スライム
// ID : 102 : ゴブリン
// ID : 103 : オーク
// ボス
// ID : 1001 : スライム
// ID : 1002 : ゴブリン
// ID : 1003 : オーク
if (strings[1] == "101")
{
obj = slime; offset = offset_slime;
}
else if (strings[1] == "102")
{
obj = skeleton; offset = offset_skeleton;
}
else if (strings[1] == "103")
{
obj = ork; offset = offset_ork;
}
else if (strings[1] == "1001")
{
obj = boss_slime; offset = offset_boss_slime;
}
else if (strings[1] == "1002")
{
obj = boss_skeleton; offset = offset_boss_skeleton;
}
else if (strings[1] == "1003")
{
obj = boss_ork; offset = offset_boss_ork;
}
// スポーンデータに各要素を格納
EnemySpawnData esd = new EnemySpawnData(
obj, // enemyObj
strings[2], // enemyName
offset, // position
float.Parse(strings[3]), // startTime
float.Parse(strings[4]), // respawnTime
int.Parse(strings[5]), // spawnLimit
transform); // parentTransform
// 対応するwaveにスポーンデータ追加
waves[int.Parse(strings[0]) - 1].Add(esd);
}
// 現在のウェーブの最大スポーン数を格納
total_spawnLimit = 0;
foreach (var esd in waves[cur_waveNum])
{
total_spawnLimit += esd.SpawnLimit;
}
}
