using System.Collections.Generic;
|
using UnityEngine;
|
using Core.Utilities;
|
using TowerDefense.Towers.Placement;
|
using TowerDefense.Nodes;
|
using TowerDefense.Level;
|
using Core.Economy;
|
using TowerDefense.Towers;
|
using TowerDefense.UI.HUD;
|
using TowerDefense.Agents;
|
using KTGMGemClient;
|
|
/// <summary>
|
/// 对战管理器，主要负责屏幕上方的敌方数据结构和相关的显示展示
|
/// 1: 放置塔防的区域。
|
/// 2: OppomentNodeList 对方Agent的刷新和行进路线。
|
/// 3: CurrencyMgr 对方的现金管理
|
/// 4: OpponentAI 对方的AI管理器，用于管理AI相关的内容，是升级，还是购买，还是其它相关。
|
/// 先做一个简单的功能，在开始之后，Opponent先后购买相关的Tower,然后OpponentAgent开始从对方
|
/// Node行进，直到最后死亡。
|
///
|
/// 先能刷新出来OpponentAgent再说下一步
|
/// </summary>
|
public class OpponentMgr : Singleton<OpponentMgr>
|
{
|
protected static readonly int MAX_TOWER = 5;
|
/// <summary>
|
/// 用于对手刷新出来Agent相对应的数据
|
/// </summary>
|
public WaveManager m_WaveManager;
|
|
/// <summary>
|
/// 思考决策的时间间隔.
|
/// </summary>
|
public float thinkInternal = 0.5f; // 改的时间很长是为了调试
|
|
/// <summary>
|
/// 放置塔防的IPlacementArea. Placement area ghost tower is currently on
|
/// </summary>
|
public IPlacementArea m_CurrentArea;
|
|
/// <summary>
|
/// 处理TowerList相关的数据.AI相关的内容也要
|
/// </summary>
|
protected List<Tower> m_listTower = new List<Tower>();
|
|
protected List<int> m_waitBuyTowerPos = new List<int>();
|
|
/// <summary>
|
/// 对方Agent刷新的StartNode区域.
|
/// </summary>
|
protected Node m_StartNode;
|
|
/// <summary>
|
/// 对手的现金管理器
|
/// </summary>
|
protected Currency m_Currency;
|
|
/// <summary>
|
/// 是否已经开始刷怪
|
/// </summary>
|
protected bool bWaveStart = false;
|
|
/// <summary>
|
/// 用于内部判断是否触发智能的时间变量.
|
/// </summary>
|
protected float thinkTimeEle = 0;
|
|
/// <summary>
|
/// 当前空闲的塔位数目
|
/// </summary>
|
protected int freeTowerPos = 0;
|
|
/// <summary>
|
/// 每一个Tower对应的AttributeID.
|
/// </summary>
|
protected int[] towerAttributeID = new int[5];
|
protected int[] towerLevel = new int[5];
|
|
|
// 是否第一次，测试代码：
|
protected static bool bFirst = true;
|
|
|
public int startingCurrency { get; set; }
|
|
public Currency currency
|
{
|
get { return this.m_Currency; }
|
}
|
|
// 待释放技能宝石队列
|
private Queue<Tower> canReleaseSkillsQueue = new Queue<Tower>();
|
|
// 可释放技能的怪物数量限制 >= 4 可释放
|
private int agentQuantityLimit = 4;
|
|
/// <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 )
|
this.UpdateWaveSpawn(waveline, id);
|
}
|
|
public int GetTowerAttID(int waveline)
|
{
|
return towerAttributeID[waveline];
|
}
|
public int GetTowerLevel(int waveline)
|
{
|
return towerLevel[waveline];
|
}
|
|
|
/// <summary>
|
/// 增加一个Tower.
|
/// </summary>
|
/// <param name="tw"></param>
|
public void addTower(Tower tw)
|
{
|
this.m_listTower.Add(tw);
|
}
|
|
/// <summary>
|
/// 根据坐标获取对应的Tower指针.
|
/// </summary>
|
/// <param name="x"></param>
|
/// <param name="y"></param>
|
public Tower getTower(int x, int y)
|
{
|
foreach (Tower t in m_listTower)
|
{
|
if ((t.gridPosition.x == x) && (t.gridPosition.y == y)) return t;
|
}
|
return null;
|
}
|
|
/// <summary>
|
/// 删除一个Tower.
|
/// </summary>
|
/// <param name="tw"></param>
|
public void removeTower(Tower tw)
|
{
|
m_listTower.Remove(tw);
|
}
|
|
|
/// <summary>
|
/// 更新刷怪时间.
|
/// </summary>
|
/// <param name="gridx"></param>
|
/// <param name="attid"></param>
|
protected void UpdateWaveSpawn(int gridx, int attid)
|
{
|
LevelManager.instance.waveManager.UpdateWaveSpawnTime(gridx, attid);
|
}
|
|
//
|
// Start is called before the first frame update
|
void Start()
|
{
|
bFirst = true;
|
bWaveStart = false;
|
|
for (int ti = 0; ti < MAX_TOWER; ti++)
|
towerAttributeID[ti] = 0;
|
|
// 获取IPlaceArea.获取相应的放置区域。
|
GameObject placeObj = GameObject.FindGameObjectWithTag("PlaceTowerOpponent");
|
if (placeObj == null) return;
|
m_CurrentArea = placeObj.GetComponent<IPlacementArea>();
|
|
|
// 初始化全局的Starting Currency.
|
startingCurrency = LevelManager.instance.startingCurrency;
|
m_Currency = new Currency(startingCurrency);
|
m_Currency.currencyChanged += M_Currency_currencyChanged;
|
if (RandomTower.MAX_INTERNAL)
|
this.thinkInternal = 1000;
|
}
|
|
public void ResetCurrency(int currency)
|
{
|
int curChg = currency - m_Currency.currentCurrency;
|
m_Currency.AddCurrency(curChg);
|
}
|
|
private void M_Currency_currencyChanged()
|
{
|
//int cnum = m_Currency.currentCurrency;
|
//Debug.Log("当前反方的现金数目是:" + cnum);
|
}
|
|
|
/* float updateTime = 6.2f;
|
protected void updateTest()
|
{
|
updateTime -= Time.deltaTime;
|
if( updateTime <= 0 )
|
{
|
updateTime = 100;
|
this.upgradeAttackTower(2);
|
}
|
}*/
|
|
// Update is called once per frame
|
void Update()
|
{
|
//if (!this.bWaveStart) return;
|
if (!UIStart.bGameStart) return;
|
|
// TEST CODE:
|
// this.updateTest();
|
|
this.thinkTimeEle += Time.deltaTime;
|
if (thinkInternal > thinkTimeEle) return;
|
thinkTimeEle -= thinkInternal;
|
|
// 触发思考操作：加入一个随机的Tower.
|
if (bFirst)
|
{
|
bFirst = false;
|
RandomTower.instance.randomOpponentTower(false);
|
|
this.currency.TryPurchase(TowerPrice.instance.opponentTowerPrice);
|
TowerPrice.instance.onTowerBuySuccess();
|
}
|
|
// 更新开格子相关
|
this.updateTowerPosBuy();
|
|
// 触发升级Tower的操作.
|
this.UpdateAttackTower();
|
|
PurchaseTower();
|
|
ReleaseSkills();
|
}
|
|
/// <summary>
|
/// 购买产生塔
|
/// </summary>
|
private void PurchaseTower()
|
{
|
// 首先需要钱够
|
if (currency.currentCurrency >= TowerPrice.instance.opponentTowerPrice)
|
{
|
// 如果还不能产生精灵宝石
|
if (UIStart.instance.gameStartTime <= RandomTower.SKILL_TOWER_TIME)
|
{
|
if (freeTowerPos > 0 && m_CurrentArea.hasFreeAttackPos())
|
{
|
--freeTowerPos;
|
RandomTower.instance.randomOpponentTower(false);
|
}
|
}
|
else
|
{
|
// 先获取一个随机的宝石
|
Tower newTower = RandomTower.instance.GetRandomTower(true, false);
|
|
if (newTower.towerFeature == EFeatureTower.NULL && m_CurrentArea.hasFreeAttackPos())
|
{
|
--freeTowerPos;
|
RandomTower.instance.RandomPlaceTower(newTower, true);
|
}
|
else
|
{
|
// 技能宝石的话，直接购买，购买成功放入队列
|
int cost = TowerPrice.instance.opponentTowerPrice;
|
bool purchaseSuccess = OpponentMgr.instance.currency.TryPurchase(cost);
|
|
if (purchaseSuccess)
|
canReleaseSkillsQueue.Enqueue(newTower);
|
}
|
}
|
}
|
}
|
|
/// <summary>
|
/// AI 如果 有技能宝石 并且 某一条路线的怪物数量 >= 4 释放技能
|
/// </summary>
|
private void ReleaseSkills()
|
{
|
if (canReleaseSkillsQueue.Count == 0)
|
return;
|
|
WaveLineAgentInsMgr[] waveLineList = AgentInsManager.instance.getOppoWaveLineList();
|
int index = -1;
|
|
// 找某一条兵线怪物数量 >= 4 的
|
for (int i = 0; i < waveLineList.Length; ++i)
|
{
|
int num = waveLineList[i].getAgentInsNum();
|
|
if (num >= agentQuantityLimit)
|
{
|
index = i;
|
break;
|
}
|
}
|
|
if (index == -1) return;
|
|
Tower tower = canReleaseSkillsQueue.Dequeue();
|
int level = tower.currentLevel;
|
|
if (tower.towerFeature == EFeatureTower.Skill_Fire)
|
{
|
// 火，列攻击，直接在该兵线释放
|
WaveLineOpponentManager.instance.PlayWaveLineEffect(index);
|
AgentInsManager.instance.ExecWavelineAttack(index, tower.ElfId, level, true);
|
}
|
else if (tower.towerFeature == EFeatureTower.Skill_Bomb)
|
{
|
// 控制，技能中心为离塔最近的小怪的中心点
|
Agent agent = AgentInsManager.instance.GetMinDisAgent(index, true);
|
WaveLineOpponentManager.instance.PlayBattleAreaBombEffect(agent.transform.position);
|
AgentInsManager.instance.ExecBombAttack(agent.transform.position, tower.ElfId, level, true);
|
}
|
}
|
|
/// <summary>
|
/// 更新火属性Tower对左右塔的攻击增加.
|
/// </summary>
|
protected void updateFireTowerAttRise()
|
{
|
for (int ti = 0; ti < MAX_TOWER; ti++)
|
{
|
Tower tw = this.getTower(ti, 0);
|
if (tw)
|
tw.attackRise = 0.0f;
|
}
|
|
for (int ti = 0; ti < MAX_TOWER; ti++)
|
{
|
Tower tw = this.getTower(ti, 0);
|
if (tw.towerFeature == EFeatureTower.LightTower)
|
{
|
int nidx = ti - 1;
|
if (nidx >= 0)
|
{
|
tw = getTower(nidx, 0);
|
if (tw)
|
tw.attackRise = 0.1f;
|
}
|
nidx = ti + 1;
|
if (nidx < MAX_TOWER)
|
{
|
tw = getTower(nidx, 0);
|
if (tw)
|
tw.attackRise = 0.1f;
|
}
|
}
|
}
|
}
|
|
|
/// <summary>
|
/// 更新AI开格子逻辑.
|
/// </summary>
|
protected void updateTowerPosBuy()
|
{
|
if (m_waitBuyTowerPos.Count > 0)
|
{
|
if (currency.currentCurrency >= TowerPlacementGrid.GRID_OPENCASH_OPPO)
|
{
|
m_CurrentArea.buyWaitBuyGrid(m_waitBuyTowerPos[0], 0);
|
m_waitBuyTowerPos.RemoveAt(0);
|
}
|
}
|
else
|
{
|
if (currency.currentCurrency >= TowerPlacementGrid.GRID_OPENCASH_OPPO)
|
{
|
if (m_CurrentArea.isWaitBuyGrid(1, 0))
|
{
|
m_CurrentArea.buyWaitBuyGrid(1, 0);
|
freeTowerPos++;
|
}
|
else if (m_CurrentArea.isWaitBuyGrid(3, 0))
|
{
|
m_CurrentArea.buyWaitBuyGrid(3, 0);
|
freeTowerPos++;
|
}
|
else if (m_CurrentArea.isWaitBuyGrid(0, 0))
|
{
|
m_CurrentArea.buyWaitBuyGrid(0, 0);
|
freeTowerPos++;
|
}
|
else if (m_CurrentArea.isWaitBuyGrid(4, 0))
|
{
|
m_CurrentArea.buyWaitBuyGrid(4, 0);
|
freeTowerPos++;
|
}
|
}
|
}
|
|
return;
|
}
|
|
/// <summary>
|
/// 反方攻击塔位的升级逻辑更新,暂时根据场内小怪数目使用简单的逻辑。
|
/// </summary>
|
protected void UpdateAttackTower()
|
{
|
WaveLineAgentInsMgr[] waveLineList = AgentInsManager.instance.getOppoWaveLineList();
|
|
for (int ti = 0; ti < waveLineList.Length; ti++)
|
{
|
int agentNum = waveLineList[ti].getAgentInsNum();
|
|
Tower tower = this.getTower(ti, 0);
|
if (!tower) continue;
|
int lvl = tower.currentLevel;
|
if (lvl >= ElfUpgradeData.MaxTowerLevel)
|
continue;
|
if ((agentNum - 1) <= lvl) continue;
|
|
// 塔位升级相关的数据:
|
if (tower.towerFeature != EFeatureTower.GrowUp)
|
{
|
if ((lvl == 0) && (currency.TryPurchase(80)))
|
{
|
this.upgradeAttackTower(ti);
|
}
|
else if ((lvl == 1) && (currency.TryPurchase(240)))
|
{
|
this.upgradeAttackTower(ti);
|
}
|
else if ((lvl == 2) && (currency.TryPurchase(440)))
|
{
|
this.upgradeAttackTower(ti);
|
}
|
}
|
|
}
|
}
|
|
|
/// <summary>
|
/// 升级某一个攻击位的Tower.
|
/// </summary>
|
/// <param name="x"></param>
|
protected void upgradeAttackTower(int xpos)
|
{
|
Tower newTower = RandomTower.instance.GetRandomTower(true, true);
|
Tower oldTower = this.getTower(xpos, 0);
|
if (oldTower == null) return;
|
|
GameUI.instance.DisplaceTower(newTower, oldTower);
|
|
}
|
|
/// <summary>
|
/// 开启某一个等待购买的塔位。
|
/// </summary>
|
/// <param name="x"></param>
|
/// <returns></returns>
|
public bool openWaitBuyGrid(int x)
|
{
|
if (null == this.m_CurrentArea) return false;
|
if (m_CurrentArea.isWaitBuyGrid(x, 0))
|
{
|
if (currency.currentCurrency < TowerPlacementGrid.GRID_OPENCASH_OPPO)
|
{
|
m_waitBuyTowerPos.Add(x);
|
return true;
|
}
|
return m_CurrentArea.buyWaitBuyGrid(x, 0);
|
}
|
else
|
return true;
|
}
|
|
/// <summary>
|
/// 开始Wave移动
|
/// </summary>
|
public void StartWaves()
|
{
|
this.bWaveStart = true;
|
m_WaveManager.StartWaves();
|
}
|
|
/// <summary>
|
/// 开启一条兵线.
|
/// </summary>
|
/// <param name="x"></param>
|
public void startWaveLine(int x, int attid)
|
{
|
m_WaveManager.startWaveLine(x, attid);
|
if (m_CurrentArea.isWaitBuyGrid(x, 0))
|
{
|
openWaitBuyGrid(x);
|
freeTowerPos++;
|
}
|
}
|
|
public void prepareWaveline(int x)
|
{
|
m_WaveManager.prepareWaveline(x);
|
}
|
|
/// <summary>
|
/// 停止某一条兵线的出兵。
|
/// </summary>
|
/// <param name="x"></param>
|
public void stopWaveLine(int x)
|
{
|
m_WaveManager.stopWaveLine(x);
|
}
|
}
|
