using System;
|
using Core.Economy;
|
using Core.Health;
|
using Core.Utilities;
|
using JetBrains.Annotations;
|
using TowerDefense.Economy;
|
using TowerDefense.Towers.Data;
|
using TowerDefense.Towers.Placement;
|
using TowerDefense.UI.HUD;
|
using UnityEngine;
|
|
namespace TowerDefense.Level
|
{
|
/// <summary>
|
/// The level manager - handles the level states and tracks the player's currency
|
/// </summary>
|
[RequireComponent(typeof(WaveManager))]
|
public class LevelManager : Singleton<LevelManager>
|
{
|
protected static readonly int MAX_TOWER = 5;
|
|
/// <summary>
|
/// The configured level intro. If this is null the LevelManager will fall through to the gameplay state (i.e. SpawningEnemies)
|
/// </summary>
|
public LevelIntro intro;
|
|
/// <summary>
|
/// The tower library for this level
|
/// </summary>
|
public TowerLibrary towerLibrary;
|
|
|
/// <summary>
|
/// 怪物重生的特效.
|
/// </summary>
|
public GameObject agentRegenPrefab;
|
|
/// <summary>
|
/// The currency that the player starts with
|
/// </summary>
|
public int startingCurrency;
|
|
/// <summary>
|
/// 自身所在的PlacementArea和对方所有的PlaceArea.
|
/// </summary>
|
public TowerPlacementGrid selfPlacementArea;
|
public TowerPlacementGrid oppoPlacementArea;
|
|
/// <summary>
|
/// The controller for gaining currency
|
/// </summary>
|
public CurrencyGainer currencyGainer;
|
|
/// <summary>
|
/// Configuration for if the player gains currency even in pre-build phase
|
/// </summary>
|
[Header("Setting this will allow currency gain during the Intro and Pre-Build phase")]
|
public bool alwaysGainCurrency;
|
|
/// <summary>
|
/// The home bases that the player must defend
|
/// </summary>
|
public PlayerHomeBase[] homeBases;
|
/// <summary>
|
/// 对手盘的HomeBase,如果死亡，则胜利发生.
|
/// </summary>
|
public PlayerHomeBase[] opponentHomeBases;
|
|
public Collider[] environmentColliders;
|
|
|
/// <summary>
|
/// 全局的JSON数据初始化.
|
/// </summary>
|
protected JsonDataInit mJsonData;
|
|
/// <summary>
|
/// The attached wave manager
|
/// </summary>
|
public WaveManager waveManager { get; protected set; }
|
|
|
/// <summary>
|
/// Number of enemies currently in the level
|
/// </summary>
|
public int numberOfEnemies { get; protected set; }
|
|
/// <summary>
|
/// The current state of the level
|
/// </summary>
|
public LevelState levelState { get; protected set; }
|
|
/// <summary>
|
/// The currency controller
|
/// </summary>
|
public Currency currency { get; protected set; }
|
|
/// <summary>
|
/// Number of home bases left
|
/// </summary>
|
public int numberOfHomeBasesLeft { get; protected set; }
|
/// <summary>
|
/// 对手盘的HomeBase数据.
|
/// </summary>
|
public int oppoNumOfHomeBaseLeft { get; protected set; }
|
|
/// <summary>
|
/// Starting number of home bases
|
/// </summary>
|
public int numberOfHomeBases { get; protected set; }
|
|
/// <summary>
|
/// 对手盘的homeBase数目
|
/// </summary>
|
public int oppoNumOfHomeBases { get; protected set; }
|
|
/// <summary>
|
/// 每一个Tower对应的AttributeID.
|
/// </summary>
|
protected int[] towerAttributeID = new int[5];
|
protected int[] towerLevel = new int[5];
|
|
/// <summary>
|
/// An accessor for the home bases
|
/// </summary>
|
public PlayerHomeBase[] playerHomeBases
|
{
|
get { return homeBases; }
|
}
|
|
/// <summary>
|
/// 设置每一条兵线对应的AttID
|
/// </summary>
|
/// <param name="waveline"></param>
|
/// <param name="id"></param>
|
public void SetTowerAttID( int waveline,int id,int lvl )
|
{
|
towerAttributeID[waveline] = id;
|
towerLevel[waveline] = lvl;
|
|
//if( lvl>=1 )
|
UpdateWaveSpawn(waveline, id);
|
}
|
|
public int GetTowerAttID( int waveline)
|
{
|
return towerAttributeID[waveline];
|
}
|
|
public int GetTowerLevel( int waveline)
|
{
|
return towerLevel[waveline];
|
}
|
|
/// <summary>
|
/// 重设当前的Currency数据
|
/// </summary>
|
/// <param name="curnum"></param>
|
public void ResetCurrency( int curnum)
|
{
|
int curChg = curnum - currency.currentCurrency;
|
currency.AddCurrency(curChg);
|
}
|
|
/// <summary>
|
/// 更新刷怪时间
|
/// </summary>
|
/// <param name="gridx"></param>
|
/// <param name="attid"></param>
|
protected void UpdateWaveSpawn(int gridx, int attid)
|
{
|
OpponentMgr.instance.m_WaveManager.UpdateWaveSpawnTime(gridx, attid);
|
}
|
|
/// <summary>
|
/// If the game is over
|
/// </summary>
|
public bool isGameOver
|
{
|
get { return (levelState == LevelState.Win) || (levelState == LevelState.Lose); }
|
}
|
|
/// <summary>
|
/// Fired when all the waves are done and there are no more enemies left
|
/// </summary>
|
public event Action levelCompleted;
|
|
/// <summary>
|
/// Fired when all of the home bases are destroyed
|
/// </summary>
|
public event Action levelFailed;
|
|
/// <summary>
|
/// Fired when the level state is changed - first parameter is the old state, second parameter is the new state
|
/// </summary>
|
public event Action<LevelState, LevelState> levelStateChanged;
|
|
/// <summary>
|
/// Fired when the number of enemies has changed
|
/// </summary>
|
public event Action<int> numberOfEnemiesChanged;
|
|
/// <summary>
|
/// Event for home base being destroyed
|
/// </summary>
|
public event Action homeBaseDestroyed;
|
|
/// <summary>
|
/// Increments the number of enemies. Called on Agent spawn
|
/// </summary>
|
public virtual void IncrementNumberOfEnemies()
|
{
|
numberOfEnemies++;
|
SafelyCallNumberOfEnemiesChanged();
|
}
|
|
/// <summary>
|
/// Returns the sum of all HomeBases' health
|
/// </summary>
|
public float GetAllHomeBasesHealth()
|
{
|
float health = 0.0f;
|
foreach (PlayerHomeBase homebase in homeBases)
|
{
|
health += homebase.configuration.currentHealth;
|
}
|
return health;
|
}
|
|
/// <summary>
|
/// 开启对应索引的兵线。
|
/// </summary>
|
/// <param name="x"></param>
|
/// <returns></returns>
|
public bool startWaveLine(int waveline,bool opponent,int attid )
|
{
|
|
if (opponent)
|
{
|
waveManager.startWaveLine(waveline, attid);
|
}
|
else
|
{
|
OpponentMgr.instance.startWaveLine(waveline,attid);
|
}
|
|
|
return true;
|
}
|
|
/// <summary>
|
/// 停止某一条兵线的出兵.
|
/// </summary>
|
/// <param name="waveLine"></param>
|
public void stopWaveLine( int waveLine,bool opponent )
|
{
|
if( opponent )
|
OpponentMgr.instance.stopWaveLine(waveLine);
|
else
|
waveManager.stopWaveLine(waveLine);
|
return;
|
}
|
|
/// <summary>
|
/// Decrements the number of enemies. Called on Agent death
|
/// </summary>
|
public virtual void DecrementNumberOfEnemies()
|
{
|
numberOfEnemies--;
|
SafelyCallNumberOfEnemiesChanged();
|
if (numberOfEnemies < 0)
|
{
|
Debug.LogError("[LEVEL] There should never be a negative number of enemies. Something broke!");
|
numberOfEnemies = 0;
|
}
|
|
if (numberOfEnemies == 0 && levelState == LevelState.AllEnemiesSpawned)
|
{
|
ChangeLevelState(LevelState.Win);
|
}
|
}
|
|
/// <summary>
|
/// Completes building phase, setting state to spawn enemies
|
/// </summary>
|
public virtual void BuildingCompleted()
|
{
|
ChangeLevelState(LevelState.SpawningEnemies);
|
|
this.selfPlacementArea.startCoinGenMode();
|
this.oppoPlacementArea.startCoinGenMode();
|
}
|
|
public void TestLoadJsonData()
|
{
|
//mJsonData.LoadGlobalJsonData();
|
}
|
|
/// <summary>
|
/// Caches the attached wave manager and subscribes to the spawning completed event
|
/// Sets the level state to intro and ensures that the number of enemies is set to 0
|
/// </summary>
|
protected override void Awake()
|
{
|
base.Awake();
|
|
for( int ti = 0;ti<MAX_TOWER;ti++)
|
{
|
towerAttributeID[ti] = 0;
|
}
|
|
// 初始化全局的JSON数据
|
//mJsonData = new JsonDataInit();
|
//mJsonData.LoadGlobalJsonData();
|
|
waveManager = GetComponent<WaveManager>();
|
waveManager.spawningCompleted += OnSpawningCompleted;
|
|
// Does not use the change state function as we don't need to broadcast the event for this default value
|
levelState = LevelState.Intro;
|
numberOfEnemies = 0;
|
|
// Ensure currency change listener is assigned
|
currency = new Currency(startingCurrency);
|
currencyGainer.Initialize(currency);
|
// 设置对手数据
|
// OpponentMgr.instance.startingCurrency = startingCurrency;
|
|
// If there's an intro use it, otherwise fall through to gameplay
|
if (intro != null)
|
{
|
intro.introCompleted += IntroCompleted;
|
}
|
else
|
{
|
IntroCompleted();
|
}
|
|
// Iterate through home bases and subscribe
|
numberOfHomeBases = homeBases.Length;
|
numberOfHomeBasesLeft = numberOfHomeBases;
|
for (int i = 0; i < numberOfHomeBases; i++)
|
{
|
homeBases[i].homebaseIdx = i;
|
homeBases[i].died += OnHomeBaseDestroyed;
|
}
|
|
// 处理对手盘的HomeBase数据
|
oppoNumOfHomeBases = opponentHomeBases.Length;
|
oppoNumOfHomeBaseLeft = oppoNumOfHomeBases;
|
for( int ti = 0;ti<oppoNumOfHomeBases;ti ++)
|
{
|
opponentHomeBases[ti].homebaseIdx = ti;
|
this.opponentHomeBases[ti].died += OnOppoHomeBaseDestroyed;
|
}
|
}
|
|
/// <summary>
|
/// Updates the currency gain controller
|
/// </summary>
|
protected virtual void Update()
|
{
|
if (alwaysGainCurrency ||
|
(!alwaysGainCurrency && levelState != LevelState.Building && levelState != LevelState.Intro))
|
{
|
currencyGainer.Tick(Time.deltaTime);
|
}
|
}
|
|
/// <summary>
|
/// Unsubscribes from events
|
/// </summary>
|
protected override void OnDestroy()
|
{
|
base.OnDestroy();
|
if (waveManager != null)
|
{
|
waveManager.spawningCompleted -= OnSpawningCompleted;
|
}
|
if (intro != null)
|
{
|
intro.introCompleted -= IntroCompleted;
|
}
|
|
// Iterate through home bases and unsubscribe
|
for (int i = 0; i < numberOfHomeBases; i++)
|
{
|
homeBases[i].died -= OnHomeBaseDestroyed;
|
}
|
for( int ti = 0;ti<oppoNumOfHomeBases;ti ++) {
|
this.opponentHomeBases[ti].died -= this.OnOppoHomeBaseDestroyed;
|
}
|
}
|
|
/// <summary>
|
/// Fired when Intro is completed or immediately, if no intro is specified
|
/// </summary>
|
protected virtual void IntroCompleted()
|
{
|
ChangeLevelState(LevelState.Building);
|
}
|
|
/// <summary>
|
/// Fired when the WaveManager has finished spawning enemies
|
/// </summary>
|
protected virtual void OnSpawningCompleted()
|
{
|
ChangeLevelState(LevelState.AllEnemiesSpawned);
|
}
|
|
/// <summary>
|
/// Changes the state and broadcasts the event
|
/// </summary>
|
/// <param name="newState">The new state to transitioned to</param>
|
protected virtual void ChangeLevelState(LevelState newState)
|
{
|
// If the state hasn't changed then return
|
if (levelState == newState)
|
{
|
return;
|
}
|
|
LevelState oldState = levelState;
|
levelState = newState;
|
if (levelStateChanged != null)
|
{
|
levelStateChanged(oldState, newState);
|
}
|
|
switch (newState)
|
{
|
case LevelState.SpawningEnemies:
|
waveManager.StartWaves();
|
break;
|
case LevelState.AllEnemiesSpawned:
|
// Win immediately if all enemies are already dead
|
if (numberOfEnemies == 0)
|
{
|
ChangeLevelState(LevelState.Win);
|
}
|
break;
|
case LevelState.Lose:
|
SafelyCallLevelFailed();
|
break;
|
case LevelState.Win:
|
SafelyCallLevelCompleted();
|
break;
|
}
|
}
|
|
/// <summary>
|
/// Fired when a home base is destroyed
|
/// </summary>
|
protected virtual void OnHomeBaseDestroyed(DamageableBehaviour homeBase)
|
{
|
// Decrement the number of home bases
|
numberOfHomeBasesLeft--;
|
|
// Call the destroyed event
|
if (homeBaseDestroyed != null)
|
{
|
homeBaseDestroyed();
|
}
|
|
// If there are no home bases left and the level is not over then set the level to lost
|
if ((numberOfHomeBasesLeft < 3) && !isGameOver)
|
{
|
ChangeLevelState(LevelState.Lose);
|
}
|
|
}
|
|
/// <summary>
|
/// 对手盘的HomeBase被破坏掉的接口
|
/// </summary>
|
/// <param name="homeBase"></param>
|
protected void OnOppoHomeBaseDestroyed(DamageableBehaviour homeBase)
|
{
|
// Decrement the number of home bases
|
this.oppoNumOfHomeBaseLeft --;
|
|
// Call the destroyed event
|
if (homeBaseDestroyed != null)
|
{
|
homeBaseDestroyed();
|
}
|
|
// If there are no home bases left and the level is not over then set the level to lost
|
if ((oppoNumOfHomeBaseLeft < 3 ) && !isGameOver)
|
{
|
ChangeLevelState( LevelState.Win );
|
}
|
}
|
|
/// <summary>
|
/// Calls the <see cref="levelCompleted"/> event
|
/// </summary>
|
protected virtual void SafelyCallLevelCompleted()
|
{
|
if (levelCompleted != null)
|
{
|
levelCompleted();
|
}
|
}
|
|
/// <summary>
|
/// Calls the <see cref="numberOfEnemiesChanged"/> event
|
/// </summary>
|
protected virtual void SafelyCallNumberOfEnemiesChanged()
|
{
|
if (numberOfEnemiesChanged != null)
|
{
|
numberOfEnemiesChanged(numberOfEnemies);
|
}
|
}
|
|
/// <summary>
|
/// Calls the <see cref="levelFailed"/> event
|
/// </summary>
|
protected virtual void SafelyCallLevelFailed()
|
{
|
if (levelFailed != null)
|
{
|
levelFailed();
|
}
|
}
|
}
|
}
|
