569 lines
16 KiB
C#
569 lines
16 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using DG.Tweening;
|
|
using URandom = UnityEngine.Random;
|
|
|
|
public class BlockManager : MonoBehaviour
|
|
{
|
|
[SerializeField] int mBP = 0;
|
|
|
|
[SerializeField] bool mIsPlayer;
|
|
[SerializeField] Transform mCtnSlots;
|
|
[SerializeField] SellSlot mMySellSlot;
|
|
[SerializeField] Renderer mRdrFloor;
|
|
[SerializeField] GameObject mGobMergeFx;
|
|
|
|
private List<BlockSlot> mBlocks;
|
|
|
|
private BlockSlot mPickedBlock;
|
|
private BlockSlot mTouchedBlock;
|
|
private SellSlot mTouchedSellSlot;
|
|
|
|
private bool mInteractable;
|
|
private bool mIsForbidden = false;
|
|
private List<int> mExcludeIndexes;
|
|
|
|
private bool mIsAutoMerge;
|
|
private Queue<Vector2Int> mAutoMergeQueue = new Queue<Vector2Int>();
|
|
private string mNewCardID;
|
|
|
|
private void Awake()
|
|
{
|
|
mBlocks = Utils.GetChildListFirstLayer<BlockSlot>(mCtnSlots);
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mIsPlayer)
|
|
{
|
|
mBlocks[i].Init(i, OnPickUpSlot, OnMoveSlot, OnDropDownSlot);
|
|
mBlocks[i].ShowFloor(true);
|
|
}
|
|
else
|
|
{
|
|
mBlocks[i].Init(i);
|
|
mBlocks[i].ShowFloor(false);
|
|
}
|
|
}
|
|
|
|
EnableInteraction(mIsPlayer);
|
|
}
|
|
|
|
public List<SoldierUnit> GetAllSoldier()
|
|
{
|
|
List<SoldierUnit> tSoldierlist = new List<SoldierUnit>();
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mBlocks[i].HasUnit)
|
|
{
|
|
tSoldierlist.AddRange(mBlocks[i].MyUnit.GetAllSoldier());
|
|
}
|
|
}
|
|
|
|
return tSoldierlist;
|
|
}
|
|
|
|
public void CreateBaseHumanBlock()//only for player
|
|
{
|
|
CreateBlockAtRandomPos(BlockType.Human);
|
|
|
|
CheckAutoMerge();
|
|
|
|
AudioManager.Instance.PlaySound(AudioClipType.BuyUnit);
|
|
}
|
|
|
|
public void CreateBaseMonsterBlock()//only for player
|
|
{
|
|
CreateBlockAtRandomPos(BlockType.Monster);
|
|
|
|
CheckAutoMerge();
|
|
|
|
AudioManager.Instance.PlaySound(AudioClipType.BuyUnit);
|
|
}
|
|
|
|
public void CreateBlockAtRandomPos(BlockType pBType, int pLevel = 1)
|
|
{
|
|
List<int> tEmptyList = new List<int>();
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (!mBlocks[i].HasUnit)
|
|
{
|
|
tEmptyList.Add(i);
|
|
}
|
|
}
|
|
|
|
if (tEmptyList.Count > 0)
|
|
{
|
|
CreateBlock(tEmptyList[URandom.Range(0, tEmptyList.Count)], pBType, pLevel);
|
|
}
|
|
}
|
|
|
|
public void CreateBlocksByData(string pDataStr)//eg:0_0_1;1_1_5
|
|
{
|
|
string[] tData = pDataStr.Split(';');
|
|
|
|
int tPosIndex = 0, tBType = 0, tLevel = 1;
|
|
|
|
for (int i = 0; i < tData.Length; i++)
|
|
{
|
|
if (string.IsNullOrEmpty(tData[i]))
|
|
continue;
|
|
|
|
string[] tNums = tData[i].Split('_');
|
|
tPosIndex = int.Parse(tNums[0]);
|
|
tBType = int.Parse(tNums[1]);
|
|
tLevel = int.Parse(tNums[2]);
|
|
|
|
CreateBlock(tPosIndex, (BlockType)tBType, tLevel);
|
|
}
|
|
}
|
|
|
|
public BlockUnit CreateBlock(int pIndex, BlockType pBType, int pLevel)
|
|
{
|
|
if (pIndex < 0 || pIndex >= mBlocks.Count)
|
|
return null;
|
|
|
|
if (mBlocks[pIndex].HasUnit)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
BlockUnit tNewUnit = Instantiate(ResourceManager.Instance.LoadRes<BlockUnit>(Const.Path.GetBlockUnit(pBType, pLevel)));
|
|
mBlocks[pIndex].SetUnit(tNewUnit);
|
|
|
|
mBP += Utils.GetBpByLv(tNewUnit.Level);
|
|
RefreshBPUI();
|
|
|
|
if (mIsPlayer)
|
|
{
|
|
if (tNewUnit != null)
|
|
{
|
|
DisplayNewUnit(tNewUnit);
|
|
VibrateManager.Instance.Vibrate(VibrateType.Medium);
|
|
}
|
|
SavePlayerArmy();
|
|
}
|
|
|
|
return tNewUnit;
|
|
}
|
|
|
|
public string GetFormationStr()
|
|
{
|
|
string tDataStr = "";
|
|
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mBlocks[i].HasUnit)
|
|
{
|
|
tDataStr += string.Format("{0}_{1}_{2}", i, (int)mBlocks[i].MyUnit.BType, mBlocks[i].MyUnit.Level) + ";";
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(tDataStr))
|
|
{
|
|
tDataStr = tDataStr.Remove(tDataStr.LastIndexOf(';'));//remove last ';'
|
|
}
|
|
|
|
return tDataStr;
|
|
}
|
|
|
|
public void ClearAll()
|
|
{
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mBlocks[i].HasUnit)
|
|
{
|
|
Destroy(mBlocks[i].MyUnit.gameObject);
|
|
mBlocks[i].SetUnit(null);
|
|
}
|
|
}
|
|
|
|
if (mIsPlayer)
|
|
{
|
|
SavePlayerArmy();
|
|
}
|
|
|
|
mBP = 0;
|
|
RefreshBPUI();
|
|
}
|
|
|
|
private void MergeBlock(BlockSlot pBlockSrc, BlockSlot pBlockDst)
|
|
{
|
|
int tOldBP = Utils.GetBpByLv(pBlockSrc.MyUnit.Level) * 2;
|
|
BlockUnit tNewUnit = Instantiate(ResourceManager.Instance.LoadRes<BlockUnit>(Const.Path.GetBlockUnit(pBlockSrc.MyUnit.BType, pBlockSrc.MyUnit.Level + 1)));
|
|
Destroy(pBlockDst.MyUnit.gameObject);
|
|
Destroy(pBlockSrc.MyUnit.gameObject);
|
|
|
|
pBlockDst.SetUnit(tNewUnit);
|
|
pBlockSrc.SetUnit(null);
|
|
|
|
mBP += Utils.GetBpByLv(tNewUnit.Level) - tOldBP;
|
|
RefreshBPUI();
|
|
AudioManager.Instance.PlaySound(AudioClipType.MergeUnit);
|
|
|
|
if (mIsPlayer)
|
|
{
|
|
DisplayNewUnit(tNewUnit);
|
|
|
|
string tCardID = Utils.GetCardID(tNewUnit.BType, tNewUnit.Level);
|
|
if (!PlayerData.Instance.HasCard(tCardID))
|
|
{
|
|
mNewCardID = tCardID;
|
|
PlayerData.Instance.GetCard(mNewCardID);
|
|
TimerManager.Instance.Schedule(ShowNewCard, 0.3f);
|
|
}
|
|
else
|
|
{
|
|
mNewCardID = "";
|
|
}
|
|
|
|
if (GuideManager.Instance.CurGuideIndex == 2)
|
|
{
|
|
GuideManager.Instance.FinishCurrentStep();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SwitchBlock(BlockSlot pBlockA, BlockSlot pBlockB)
|
|
{
|
|
BlockUnit tTempUnit = pBlockB.MyUnit;
|
|
pBlockB.SetUnit(pBlockA.MyUnit);
|
|
pBlockA.SetUnit(tTempUnit);
|
|
|
|
if (GuideManager.Instance.CurGuideIndex == 1)
|
|
{
|
|
GuideManager.Instance.FinishCurrentStep();
|
|
}
|
|
}
|
|
|
|
private void RemoveBlock(BlockSlot pBlockA)
|
|
{
|
|
BlockUnit tUnit = pBlockA.MyUnit;
|
|
pBlockA.SetUnit(null);
|
|
Destroy(tUnit.gameObject);
|
|
}
|
|
|
|
public void EnableInteraction(bool pEnabled)
|
|
{
|
|
if (!pEnabled && mPickedBlock != null)
|
|
{
|
|
OnDropDownSlot(mPickedBlock.Index);
|
|
}
|
|
|
|
mInteractable = pEnabled;
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mInteractable)
|
|
{
|
|
mBlocks[i].SetDelegate(OnPickUpSlot, OnMoveSlot, OnDropDownSlot);
|
|
}
|
|
else
|
|
{
|
|
mBlocks[i].SetDelegate(null, null, null);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void ShowFloor(bool pShow)
|
|
{
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
mBlocks[i].ShowFloor(pShow);
|
|
}
|
|
|
|
if (mIsPlayer)
|
|
{
|
|
if (mRdrFloor != null)
|
|
{
|
|
mRdrFloor.material.DOFloat(pShow ? 0 : 1, "_Dissolve", 1f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mRdrFloor.gameObject.SetActive(pShow);
|
|
}
|
|
}
|
|
|
|
public void SetForbidden(bool pIsForbidden, List<int> pExcludeIndexes = null)
|
|
{
|
|
mIsForbidden = pIsForbidden;
|
|
mExcludeIndexes = pExcludeIndexes;
|
|
}
|
|
|
|
private void OnPickUpSlot(int pIndex)
|
|
{
|
|
if (!mInteractable || mIsAutoMerge)
|
|
return;
|
|
|
|
VibrateManager.Instance.Vibrate(VibrateType.Light);
|
|
|
|
mPickedBlock = mBlocks[pIndex];
|
|
mPickedBlock.SetState(IsSlotForbidden(pIndex) ? BlockState.Forbidden : BlockState.Picked);
|
|
|
|
if (PlayerData.Instance.IsAutoMergeEnabled && mPickedBlock.MyUnit != null && mMySellSlot != null)
|
|
{
|
|
int tSellPrice = PlayerData.Instance.CurrentSellBase * Mathf.RoundToInt(Mathf.Pow(2, mPickedBlock.MyUnit.Level - 1));
|
|
mMySellSlot.SetSellPrice(tSellPrice);
|
|
mMySellSlot.Show(true);
|
|
}
|
|
}
|
|
|
|
private void OnMoveSlot(int pIndex)
|
|
{
|
|
if (!mInteractable || mIsAutoMerge)
|
|
return;
|
|
|
|
if (mPickedBlock == null || mPickedBlock.MyUnit == null || IsSlotForbidden(pIndex))
|
|
return;
|
|
|
|
RaycastHit[] tHits = Physics.RaycastAll(Camera.main.ScreenPointToRay(Input.mousePosition), 100, Const.Layer.OpLayer);
|
|
|
|
mTouchedSellSlot = null;
|
|
BlockSlot tHitBlock = null;
|
|
GameObject tGround = null;
|
|
RaycastHit tGroundHit = new RaycastHit();
|
|
for (int i = 0; i < tHits.Length; i++)
|
|
{
|
|
if (tHitBlock == null && tHits[i].collider.gameObject.layer == Const.Layer.BlockSlot)
|
|
{
|
|
tHitBlock = tHits[i].collider.gameObject.GetComponent<BlockSlot>();
|
|
}
|
|
|
|
if (tHits[i].collider.gameObject.layer == Const.Layer.SellSlot)
|
|
{
|
|
mTouchedSellSlot = tHits[i].collider.gameObject.GetComponent<SellSlot>();
|
|
}
|
|
|
|
if (tHits[i].collider.gameObject.layer == Const.Layer.Ground)
|
|
{
|
|
tGround = tHits[i].collider.gameObject;
|
|
tGroundHit = tHits[i];
|
|
}
|
|
}
|
|
|
|
if (mTouchedBlock != null && mTouchedBlock != tHitBlock)//reset last touched
|
|
{
|
|
mTouchedBlock.SetState(BlockState.Normal);
|
|
mTouchedBlock = null;
|
|
VibrateManager.Instance.Vibrate(VibrateType.Light);
|
|
}
|
|
|
|
if (tHitBlock != null && tHitBlock != mPickedBlock)//if hit new slot,set new touched
|
|
{
|
|
mTouchedBlock = tHitBlock;
|
|
if (!IsSlotForbidden(mTouchedBlock.Index))
|
|
{
|
|
if (mTouchedBlock.MyUnit != null && mPickedBlock.MyUnit != null && mTouchedBlock.MyUnit.IsMergable(mPickedBlock.MyUnit))
|
|
{
|
|
mTouchedBlock.SetState(BlockState.Mergable);
|
|
}
|
|
else
|
|
{
|
|
mTouchedBlock.SetState(BlockState.Movable);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mTouchedBlock.SetState(BlockState.Forbidden);
|
|
}
|
|
}
|
|
|
|
if (mMySellSlot != null)
|
|
{
|
|
mMySellSlot.SetTouched(mTouchedSellSlot == mMySellSlot);
|
|
}
|
|
|
|
if (tGround != null)
|
|
{
|
|
mPickedBlock.MyUnit.transform.position = tGroundHit.point + Vector3.up * 2;
|
|
}
|
|
}
|
|
|
|
private void OnDropDownSlot(int pIndex)
|
|
{
|
|
if (!mInteractable || mIsAutoMerge)
|
|
return;
|
|
|
|
VibrateManager.Instance.Vibrate(VibrateType.Light);
|
|
|
|
if (mPickedBlock == null || mPickedBlock.MyUnit == null || IsSlotForbidden(pIndex))
|
|
{
|
|
mPickedBlock?.SetState(BlockState.Normal);
|
|
return;
|
|
}
|
|
|
|
if (mMySellSlot != null && mTouchedSellSlot == mMySellSlot)
|
|
{
|
|
BlockSlot tSellBlock = mPickedBlock;
|
|
mPickedBlock = null;
|
|
|
|
if (tSellBlock.MyUnit.Level < TKGSDKManager.Instance.GetConfigInt(TKGParamKey.SellWarningLevel))
|
|
{
|
|
RemoveBlock(tSellBlock);
|
|
mMySellSlot.Sell();
|
|
|
|
tSellBlock.SetState(BlockState.Normal);
|
|
mMySellSlot.SetSellPrice(0);
|
|
mMySellSlot.Show(false);
|
|
SavePlayerArmy();
|
|
}
|
|
else
|
|
{
|
|
PanelDialog tUIDialog = UIManager.Instance.OpenUI<PanelDialog>();
|
|
tUIDialog.Init(LanguageConfig.Instance.GetText("Caution"), string.Format(LanguageConfig.Instance.GetText("SellUnit"), UIUtils.NumForShort(mMySellSlot.CurPrice), tSellBlock.MyUnit.Level),
|
|
() =>
|
|
{
|
|
RemoveBlock(tSellBlock);
|
|
mMySellSlot.Sell();
|
|
|
|
tSellBlock.SetState(BlockState.Normal);
|
|
mMySellSlot.SetSellPrice(0);
|
|
mMySellSlot.Show(false);
|
|
SavePlayerArmy();
|
|
},
|
|
() =>
|
|
{
|
|
tSellBlock.SetUnit(tSellBlock.MyUnit);
|
|
|
|
tSellBlock.SetState(BlockState.Normal);
|
|
mMySellSlot.SetSellPrice(0);
|
|
mMySellSlot.Show(false);
|
|
SavePlayerArmy();
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (mTouchedBlock != null && mTouchedBlock != mPickedBlock)
|
|
{
|
|
if (!IsSlotForbidden(mTouchedBlock.Index))
|
|
{
|
|
if (mTouchedBlock.MyUnit != null && mPickedBlock.MyUnit != null && mTouchedBlock.MyUnit.IsMergable(mPickedBlock.MyUnit))
|
|
{
|
|
MergeBlock(mPickedBlock, mTouchedBlock);
|
|
}
|
|
else
|
|
{
|
|
SwitchBlock(mPickedBlock, mTouchedBlock);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mPickedBlock.SetUnit(mPickedBlock.MyUnit);
|
|
}
|
|
|
|
mTouchedBlock.SetState(BlockState.Normal);
|
|
mTouchedBlock = null;
|
|
}
|
|
else
|
|
{
|
|
mPickedBlock.SetUnit(mPickedBlock.MyUnit);
|
|
}
|
|
|
|
if (PlayerData.Instance.IsAutoMergeEnabled && mMySellSlot != null)
|
|
{
|
|
mMySellSlot.SetSellPrice(0);
|
|
mMySellSlot.Show(false);
|
|
}
|
|
|
|
mPickedBlock.SetState(BlockState.Normal);
|
|
mPickedBlock = null;
|
|
|
|
SavePlayerArmy();
|
|
}
|
|
}
|
|
|
|
private bool IsSlotForbidden(int pIndex)
|
|
{
|
|
return mIsForbidden && (mExcludeIndexes == null || !mExcludeIndexes.Contains(pIndex));
|
|
}
|
|
|
|
private void DisplayNewUnit(BlockUnit pUnit)
|
|
{
|
|
Instantiate(mGobMergeFx, pUnit.transform.position, Quaternion.identity);
|
|
|
|
pUnit.transform.localScale = Vector3.zero;
|
|
pUnit.transform.DOScale(1, 0.5f).SetEase(Ease.OutBounce);
|
|
}
|
|
|
|
private void ShowNewCard()
|
|
{
|
|
if (!mIsPlayer)
|
|
return;
|
|
|
|
if (!string.IsNullOrEmpty(mNewCardID))
|
|
{
|
|
PanelNewCard tUINew = UIManager.Instance.OpenUI<PanelNewCard>();
|
|
tUINew.InitCard(mNewCardID);
|
|
|
|
AudioManager.Instance.PlaySound(AudioClipType.NewCard);
|
|
}
|
|
}
|
|
|
|
private void SavePlayerArmy()
|
|
{
|
|
if (!mIsPlayer)
|
|
return;
|
|
|
|
PlayerData.Instance.ArmyStr = GetFormationStr();
|
|
}
|
|
|
|
private void RefreshBPUI()
|
|
{
|
|
if (mIsPlayer)
|
|
{
|
|
UIManager.Instance.GetUI<PanelTopBar>().SetPlayerBP(mBP);
|
|
}
|
|
else
|
|
{
|
|
UIManager.Instance.GetUI<PanelTopBar>().SetEnemyBP(mBP);
|
|
}
|
|
}
|
|
|
|
public void CheckAutoMerge()
|
|
{
|
|
if (!PlayerData.Instance.IsAutoMergeEnabled || PlayerData.Instance.AutoMergeCount <= 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Dictionary<string, List<int>> tCheckDic = new Dictionary<string, List<int>>();
|
|
|
|
for (int i = 0; i < mBlocks.Count; i++)
|
|
{
|
|
if (mBlocks[i].MyUnit != null && mBlocks[i].MyUnit.Level < GameConfig.Instance.BlockMaxLevel)
|
|
{
|
|
string tKey = mBlocks[i].MyUnit.BType.ToString() + mBlocks[i].MyUnit.Level.ToString();
|
|
if (!tCheckDic.ContainsKey(tKey))
|
|
{
|
|
tCheckDic[tKey] = new List<int>();
|
|
}
|
|
|
|
tCheckDic[tKey].Add(i);
|
|
|
|
if (tCheckDic[tKey].Count >= 2)
|
|
{
|
|
mAutoMergeQueue.Enqueue(new Vector2Int(tCheckDic[tKey][0], tCheckDic[tKey][1]));
|
|
mIsAutoMerge = true;
|
|
UIManager.Instance.GetUI<PanelMain>().EnableRecruitBtns(!mIsAutoMerge);
|
|
mBlocks[tCheckDic[tKey][0]].MyUnit.transform.DOMove(mBlocks[tCheckDic[tKey][1]].MyUnit.transform.position, 0.3f).SetEase(Ease.Linear).onComplete = ExcuteAutoMerge;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void ExcuteAutoMerge()
|
|
{
|
|
Vector2Int tMergePair = mAutoMergeQueue.Dequeue();
|
|
MergeBlock(mBlocks[tMergePair.x], mBlocks[tMergePair.y]);
|
|
SavePlayerArmy();
|
|
|
|
PlayerData.Instance.AutoMergeCount--;
|
|
UIManager.Instance.GetUI<PanelMain>().RefreshAutoMerge();
|
|
mIsAutoMerge = false;
|
|
UIManager.Instance.GetUI<PanelMain>().EnableRecruitBtns(!mIsAutoMerge);
|
|
|
|
CheckAutoMerge();
|
|
}
|
|
} |