1285 lines
37 KiB
C#
Raw Normal View History

2025-05-18 01:04:31 +08:00
// ***********************************************************************
// Assembly : Game
// Author : Kimch
// Created : 2020-09-12
// Description :
// Last Modified By :
// Last Modified On :
// ***********************************************************************
// <copyright file= "GameLevel" company="KUNPO"></copyright>
// <summary></summary>
// ***********************************************************************
using System.Collections;
using System.Collections.Generic;
using CodeStage.AntiCheat.ObscuredTypes;
using F.ObjectPool;
using UnityEngine;
namespace G
{
/// <summary>
/// 游戏模式
/// </summary>
partial class GameLevel : MonoBehaviour
{
#region Field
public const int MAX_DOOR_COUNT = 1;
public const int MAX_PROP_COUNT = 8;
public const int MAX_SPAWN_POINT_COUNT = 16;
public const string STAGE_POOL_NAME = "stage";
private ItemLevel _curLevelItem;
private ItemStage _curStageItem;
/// <summary>
///
/// </summary>
private ObscuredInt _firstStageIndex;
/// <summary>
///
/// </summary>
private ObscuredInt _curStageIndex;
/// <summary>
///
/// </summary>
private ObscuredInt _maxStageIndex;
/// <summary>
///
/// </summary>
private bool _levelFinish = true;
/// <summary>
///
/// </summary>
private bool _stageFinish = true;
private bool _stageStart = false;
private float _startLevelTime;
private float _startStageTime;
private bool _studyLevelSkill;
private bool _studyStageSkill;
/// <summary>
/// 加载状态
/// </summary>
private int _loadState = 0;
/// <summary>
/// 传送门
/// </summary>
private readonly GameObject[] _portals = new GameObject[MAX_DOOR_COUNT];
/// <summary>
///
/// </summary>
private Transform _stageRoot;
/// <summary>
///
/// </summary>
private List<Vector3> _spawnPoints = new List<Vector3>(MAX_SPAWN_POINT_COUNT);
private Vector3[] _propPoints = new Vector3[MAX_SPAWN_POINT_COUNT];
private Transform _giftBox;
/// <summary>
/// 出生点
/// </summary>
private Vector3 _bornPoint;
/// <summary>
///
/// </summary>
private float _timeScale1 = 1f;
/// <summary>
/// 2级加速
/// </summary>
private float _timeScale2 = 1f;
#endregion
#region Property
/// <summary>
///
/// </summary>
public int curChapterId
{
get => _curLevelItem.chapterId;
}
/// <summary>
///
/// </summary>
public int curLevelId
{
get => _curLevelItem.id;
}
/// <summary>
///
/// </summary>
public int curStageId
{
get => _curStageItem.id;
}
/// <summary>
///
/// </summary>
public int reportStageId
{
get => _curLevelItem.id * 100 + _curStageIndex;
}
/// <summary>
///
/// </summary>
public int curStageIndex => _curStageIndex;
/// <summary>
///
/// </summary>
public int maxStageIndex => _maxStageIndex;
/// <summary>
///
/// </summary>
public bool studyLevelSkill => _studyLevelSkill;
/// <summary>
///
/// </summary>
public bool isBossStage => curStageItem.type == 2;
/// <summary>
///
/// </summary>
public ItemLevel curLevelItem
{
get { return _curLevelItem; }
}
/// <summary>
///
/// </summary>
public ItemStage curStageItem
{
get { return _curStageItem; }
}
/// <summary>
/// 1.正常 2.无尽 3.盗贼 4.爬塔
/// </summary>
public int levelMode
{
get { return curLevelItem.type; }
}
/// <summary>
/// 无尽模式
/// </summary>
public bool infinityMode
{
get { return curLevelItem.type == 2; }
}
/// <summary>
/// 正常闯关
/// </summary>
public bool normalMode
{
get { return curLevelItem.type == 1; }
}
/// <summary>
///
/// </summary>
public bool levelFinish
{
get { return _levelFinish; }
}
public GameObject portalAsset
{
get { return (GameObject)GameScene.Instance.sceneCommonAssets["portal"]; }
}
public GameObject giftBoxAsset
{
get { return (GameObject)GameScene.Instance.sceneCommonAssets["gift_box"]; }
}
/// <summary>
/// 地图资源名
/// </summary>
public string mapAssetName
{
get
{
var assets = _curLevelItem.assets;
if (assets != null && assets.Length > 0)
{
var index = Mathf.Min(_curStageItem.assetIndex, assets.Length - 1);
return assets[index];
}
return _curStageItem.assets;
}
}
/// <summary>
///
/// </summary>
public int stageBoxId
{
get
{
var boxes = curLevelItem.boxes;
if (boxes != null && boxes.Length > 0 && _curStageIndex > 0)
{
if (_curStageIndex < boxes.Length)
return boxes[_curStageIndex];
else
return boxes[boxes.Length - 1];
}
return 0;
}
}
/// <summary>
///
/// </summary>
public int stageStartStory
{
get
{
var stories = curLevelItem.stories;
if (stories != null && _curStageIndex > 0 && _curStageIndex < stories.Length)
{
if (stories[_curStageIndex] != null && stories[_curStageIndex].Length > 0)
return stories[_curStageIndex][0];
}
return 0;
}
}
/// <summary>
///
/// </summary>
public int stageEndStory
{
get
{
var stories = curLevelItem.stories;
if (stories != null && _curStageIndex > 0 && _curStageIndex < stories.Length)
{
if (stories[_curStageIndex] != null && stories[_curStageIndex].Length > 0)
return stories[_curStageIndex][1];
}
return 0;
}
}
/// <summary>
///
/// </summary>
public int stageAdventure
{
get
{
if (curStageItem.type == 3)
{
var stageTypeArgs = curStageItem.typeArgs;
if (stageTypeArgs != null && stageTypeArgs.Length > 0)
{
return stageTypeArgs[0];
}
if (Random.value < 0.618f)
return 0;
}
return -1;
}
}
private float _levelFactor = 0f;
/// <summary>
///
/// </summary>
public float levelFactor
{
get
{
switch (this.levelMode)
{
case 1:
if (_levelFactor == 0f)
{
if (GlobalVar.EnterLevelFactor > 0)
{
_levelFactor = GlobalVar.EnterLevelFactor;
}
else
{
if (curLevelItem.difficulty != null && curLevelItem.difficulty.Length > 0)
_levelFactor = curLevelItem.difficulty[0];
}
_levelFactor = _levelFactor * 0.01f + 1f;
}
return _levelFactor * _dynamicDifficult;
case 2:
return 1f + Mathf.Max(0, _curStageIndex - 100) * 0.08f;//100关以后增加度
default:
return 1f;
}
}
}
/// <summary>
/// 战力压制
/// </summary>
public float difficultyValue
{
get
{
float result = 1f;
if (levelMode == 1)
{
float diffCV = PlayerProxy.Instance.combatValue - curLevelItem.requireCV;
diffCV = diffCV / Mathf.Clamp(curLevelItem.requireCV, 100000f, 1000000f);
diffCV = diffCV * 3f;
result = Mathf.Max(1f - diffCV, 0.6f);
}
else if (levelMode == 4)
{
var swordLevelItem = ItemProxy.Instance.GetStaticItem<ItemSwordLevel>(_curStageIndex);
if (swordLevelItem != null)
{
float diffCV = PlayerProxy.Instance.combatValue - swordLevelItem.requirementCV;
diffCV = diffCV / Mathf.Clamp(swordLevelItem.requirementCV, 10000f, 1000000f);
result = Mathf.Max(1f - diffCV * 6f, 0.6f);
}
}
return result;
}
}
private bool _setStageFactor;
private readonly float[] _stageFactor = new float[4];
private readonly float[] _stageFactorB = new float[4];
private float[] stageFactor
{
get
{
if (_stageFactor[0] == 0f && _stageFactor[1] == 0f)
{
var levelFactors = curLevelItem.difficulty;
var stageFactors = curStageItem.factor;
_stageFactor[0] = stageFactors[0] * 0.01f;
_stageFactor[1] = stageFactors[2] * 0.01f;
_stageFactor[2] = stageFactors[4] * 0.01f;
_stageFactor[3] = stageFactors[6] * 0.01f;
_stageFactorB[0] = stageFactors[1];
_stageFactorB[1] = stageFactors[3];
_stageFactorB[2] = stageFactors[5];
_stageFactorB[3] = stageFactors[7];
int mode = this.levelMode;
if (mode == 1)
{
float diffCV = this.difficultyValue * _dynamicDifficult;
#if UNITY_EDITOR
Debug.Log("战力压制 " + diffCV);
#endif
_stageFactor[0] *= (levelFactors[0] * 0.01f + 1f);
_stageFactor[1] *= (levelFactors[1] * 0.01f + 1f);
_stageFactor[2] *= (levelFactors[2] * 0.01f + 1f) * diffCV;
_stageFactor[3] *= (levelFactors[3] * 0.01f + 1f) * diffCV;
}
else if (mode == 4)
{
float diffCV = this.difficultyValue * _dynamicDifficult;
#if UNITY_EDITOR
Debug.Log("战力压制 " + diffCV);
#endif
_stageFactor[0] *= diffCV;
_stageFactor[1] *= diffCV;
_stageFactor[2] *= diffCV;
_stageFactor[3] *= diffCV;
}
else if (mode == 2)
{
var f = 1f + Mathf.Max(0, _curStageIndex - 100) * 0.08f;//100关以后增加度)
_stageFactor[0] *= f;
_stageFactor[1] *= f;
_stageFactor[2] *= f;
_stageFactor[3] *= f;
}
}
return _stageFactor;
}
}
/// <summary>
///
/// </summary>
public float[] stageFactorA
{
get
{
return stageFactor;
}
}
/// <summary>
///
/// </summary>
public float[] stageFactorB
{
get
{
return _stageFactorB;
}
}
/// <summary>
/// 游戏速度
/// </summary>
public float gameSpeed
{
get { return _timeScale1; }
set
{
_timeScale1 = value;
}
}
/// <summary>
///
/// </summary>
public Vector3 endPosition
{
get;
private set;
}
/// <summary>
///
/// </summary>
public bool supportRampage
{
get { return stageMode != GameMode.Limit && stageMode != GameMode.Escort; }
}
private int _rampageTime = 999999;
/// <summary>
/// 是否暴走
/// </summary>
public bool isRampage
{
get { return supportRampage && _spawnStartTime > _rampageTime; }
}
/// <summary>
/// 进入暴走剩余时间
/// </summary>
public int rampageTime => (int)(_rampageTime - _spawnStartTime);
/// <summary>
/// 场景灯光
/// </summary>
public Light stageMainLight
{
get;
private set;
}
#endregion
#region Method
/// <summary>
/// 进入场景
/// </summary>
public void OnEnterScene()
{
GlobalNotifier.PostNotification(GlobalDefine.EVENT_LEVEL_SCENE, type: "enter");
AssetProxy.Instance.CreateReleasePool(STAGE_POOL_NAME);
StartLevel(GlobalVar.EnterLevelId, GlobalVar.EnterStageIndex);
}
/// <summary>
/// 离开场景
/// </summary>
public void OnExitScene()
{
AssetProxy.Instance.RemoveReleasePool(STAGE_POOL_NAME);
GlobalNotifier.PostNotification(GlobalDefine.EVENT_LEVEL_SCENE, type: "exit");
}
/// <summary>
/// 开始关卡
/// </summary>
/// <param name="levelId"></param>
public void StartLevel(int levelId, int stageIndex)
{
_curLevelItem = ItemProxy.Instance.GetStaticItem<ItemLevel>(levelId);
_firstStageIndex = Mathf.Max(1, stageIndex);
_levelFinish = false;
_startLevelTime = Time.unscaledTime;
_studyLevelSkill = false;
if (_curLevelItem != null)
{
LoadLevel();
_curStageIndex = 1;
_maxStageIndex = _curLevelItem.maxStage;
var stageId = GlobalUtils.GetRandom(_curLevelItem.startStage);
//计算
while (_curStageIndex < stageIndex && _curStageIndex < _maxStageIndex)
{
var stageItem = ItemProxy.Instance.GetStaticItem<ItemStage>(stageId);
if (_curStageIndex < _maxStageIndex - 1)
{
stageId = GlobalUtils.GetRandom(stageItem.nextStages);
if (stageId <= 0)
{
stageId = GlobalUtils.GetRandom(curLevelItem.endStage);
}
_curStageIndex++;
}
else
{
stageId = GlobalUtils.GetRandom(curLevelItem.endStage);
if (stageId <= 0)
{
stageId = GlobalUtils.GetRandom(stageItem.nextStages);
}
_curStageIndex = _maxStageIndex;
}
}
StartStage(stageId);
}
#if UNITY_EDITOR
else
{
Debug.LogError("关卡配置表错误");
}
#endif
InitBattleResult();
}
/// <summary>
///
/// </summary>
/// <param name="success"></param>
public void FinishLevel(bool success, string reason)
{
if (!_levelFinish)
{
if (success)
{
GlobalNotifier.PostNotification(GlobalDefine.EVENT_LEVEL_STATE, null, "finish");
}
_levelFinish = true;
SetLevelResult(success, (int)(Time.unscaledTime - _startLevelTime), reason);
}
}
/// <summary>
/// 加载通用资源
/// </summary>
private void LoadLevel()
{
var assets = GameScene.Instance.sceneCommonAssets;
_loadState = 1;
}
/// <summary>
///
/// </summary>
public void UnloadLevel()
{
StopSpawn();
EntityManager.Instance.RemoveAllEntity();
}
public void StartStage(int stageId)
{
_stageFinish = false;
_startStageTime = Time.time;
_studyStageSkill = false;
for (int i = 0; i < _stageFactor.Length; i++)
{
_stageFactor[i] = 0f;
}
_curStageItem = ItemProxy.Instance.GetStaticItem<ItemStage>(stageId);
if (_curStageItem != null)
{
if (_curStageItem.type == 1 || _curStageItem.type == 3)
_rampageTime = GlobalProxy.Instance.GetInt(6);
else if (_curStageItem.type == 2)
{
_rampageTime = GlobalProxy.Instance.GetInt(7);
}
SetMode(_curStageItem.type);
SetGroundText("", 0, 0);
LoadStage(true);
StartStage();
KStatistics.Instance.ReportEventStartStage(reportStageId.ToString());
}
else
{
Debug.LogError("关卡配置错误.");
}
}
/// <summary>
/// 进入当前关
/// </summary>
public void LoadStage(bool clear)
{
if (clear)
{
this.UnloadStage();
_loadState = 1;
}
else
{
_loadState = 2;
}
StartCoroutine(LoadStageCO(mapAssetName));
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public IEnumerator LoadStageCO(string mapAsset)
{
while (_loadState == 0)
{
yield return null;
}
if (_stageRoot && _stageRoot.name != mapAsset)
{
Destroy(_stageRoot.gameObject);
_stageRoot = null;
}
if (!_stageRoot)
{
var handle = AssetProxy.Instance.TryGetAssetAsync<GameObject>(mapAsset, STAGE_POOL_NAME);
yield return handle;
_stageRoot = Instantiate(handle.Result, Vector3.zero, Quaternion.identity).transform;
_stageRoot.name = mapAsset;
var lights = Light.GetLights(LightType.Directional, 2);
if (lights != null && lights.Length > 0)
{
if (SettingProxy.Instance.lowEffect)
{
lights[0].cookie = null;
}
stageMainLight = lights[0];
}
InitPoint();
_loadState = 2;
}
InitPortal();
InitGiftBox();
_loadState = 3;
////
LoadStageCompleted();
}
/// <summary>
///
/// </summary>
private void LoadStageCompleted()
{
if (UI.GameWindow.Instance == null || !UI.GameWindow.Instance.gameObject || !UI.GameWindow.Instance.gameObject.activeSelf)
KUIWindow.OpenWindow<UI.GameWindow>();
//加个事件
}
/// <summary>
/// 清理关卡数据
/// </summary>
private void UnloadStage()
{
//清理传送门
for (int i = 0; i < _portals.Length; i++)
{
SpawnPool.Despawn(_portals[i]);
_portals[i] = null;
}
//清理道具
if (EntityManager.Instance)
{
EntityManager.Instance.RemoveAllProp();
}
EnemyHelper.Instance.GetComponent<EnemyHelper>().FinishEfs();
UI.QuickBox.Clear();
}
/// <summary>
///
/// </summary>
public void StartStage()
{
StartCoroutine(StartStageCO());
UpdateBattleResult();
if (_curStageIndex > _firstStageIndex)
{
if (this.normalMode)
{
//SaveNormalLevelState();
}
else if (this.infinityMode)
{
SaveEndlessLevelState();
}
else if (this.levelMode == 4)
{
SaveClimbLevelState();
EntityMainPlayer.Instance.curHp = EntityMainPlayer.Instance.maxHp;
}
}
}
private IEnumerator StartStageCO()
{
//等游戏ui
while (UI.GameWindow.Instance == null || !UI.GameWindow.Instance.isRegister)
{
yield return null;
}
//剧情
if (!_curLevelItem.isCompleted)
{
var storyId = stageStartStory;
if (storyId > 0)
{
var storying = false;
storying = StoryProxy.Instance.TriggerStory(storyId, () =>
{
storying = false;
});
while (storying)
{
yield return null;
}
}
}
// 学习关卡技能
if (!_studyLevelSkill)
{
var autoStudySkill = EntityMainPlayer.Instance.autoStudySkill;
if (_curStageIndex > 1)
{
if (infinityMode)
{
MovesShop.Instance.SetMultiMovesPackage(curLevelItem.skillCardPackage[0], Mathf.Clamp(_curStageIndex - 1, 0, 100) / 5 + 1,
this.OnStudyLevelSkill);
}
else
{
LoadNormalLevelState();
_studyLevelSkill = true;
}
}
else if (curLevelItem.skillCardPoint > 0)
{
MovesShop.Instance.SetMovesPackage(curLevelItem.skillCardPackage[curLevelItem.isCompleted ? 1 : 0], autoStudySkill,
(error, message) =>
{
_studyLevelSkill = true;
});
}
else
{
_studyLevelSkill = true;
}
while (!_studyLevelSkill)
{
yield return null;
}
if (autoStudySkill)
{
yield return new WaitForSeconds(1f);
}
}
// 学习路段技能
if (!_studyStageSkill)
{
if (curStageItem.skillCardPackage > 0 && curStageItem.skillCardPoint > 0)
{
var autoStudySkill = EntityMainPlayer.Instance.autoStudySkill;
MovesShop.Instance.AddMovesPoint(curStageItem.skillCardPoint);
MovesShop.Instance.SetMovesPackage(curStageItem.skillCardPackage, autoStudySkill,
(error, message) =>
{
_studyStageSkill = true;
});
while (!_studyStageSkill)
{
yield return null;
}
if (autoStudySkill)
{
yield return new WaitForSeconds(1f);
}
}
else
{
_studyStageSkill = true;
}
}
// 奇遇
if (!_curLevelItem.isCompleted)
{
int adventureId = stageAdventure;
if (adventureId >= 0)
{
var autoSelect = EntityMainPlayer.Instance.autoSelectAdventure;
var showing = true;
showing = AdventureProxy.Instance.ShowStageAdventure(adventureId, autoSelect, () =>
{
showing = false;
});
while (showing)
{
yield return null;
}
}
}
while (_loadState < 3)
{
yield return null;
}
//进入开场
while (!EntityMainPlayer.Instance.EnterScene(_bornPoint))
{
yield return null;
}
//开场特效
UI.ToastBox.ShowText($"第{_curStageIndex}关", 6);
//GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "20681_", "");
if (curStageItem.skillCardPackage > 0 && MovesShop.Instance.totalMovesPoint > 0)
GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_LVUP_EFFECT, MovesShop.Instance.totalMovesPoint + 1, "");
yield return new WaitForSeconds(0.8f);
GlobalNotifier.PostNotification(GlobalDefine.EVENT_STAGE_STATE, curStageItem, "start");
StartSpawn();
}
/// <summary>
///
/// </summary>
/// <param name="error"></param>
private void OnStudyLevelSkill(int error, string message)
{
_studyLevelSkill = true;
}
/// <summary>
///
/// </summary>
/// <param name="error"></param>
private void OnStudyStageSkill(int error)
{
_studyStageSkill = true;
}
/// <summary>
/// 结束当前关卡
/// </summary>
public void FinishStage(bool success = true)
{
if (!_stageFinish)
{
_stageFinish = true;
StopSpawn();
StartCoroutine(FinishStageCO(success));
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
private IEnumerator FinishStageCO(bool success)
{
if (success)
{
UI_Ingame.Instance.ShowEffect("UI_fx_Repel");
}
else
{
UI_Ingame.Instance.ShowEffect("UI_fx_BattleFail");
}
//GlobalNotifier.PostNotification(GlobalDefine.EVENT_SHOW_EFFECT, "20839_", "finish");
yield return null;
if (!_curLevelItem.isCompleted && stageEndStory > 0)
{
var storying = false;
storying = StoryProxy.Instance.TriggerStory(stageEndStory, () =>
{
storying = false;
});
while (storying)
{
yield return null;
}
}
if (success && stageBoxId > 0)
{
Vector3 vector = EntityMainPlayer.Instance.position * Random.Range(0.7f, 0.85f);
OpenGiftBox(vector);
}
else
{
OpenPortal(1f);
}
GlobalNotifier.PostNotification(GlobalDefine.EVENT_STAGE_STATE, curStageItem, "finish");
}
/// <summary>
/// 下一小关
/// </summary>
public void NextStage()
{
if (_curStageIndex < _maxStageIndex - 1)
{
var nextStageId = GlobalUtils.GetRandom(curStageItem.nextStages);
if (nextStageId <= 0)
{
nextStageId = GlobalUtils.GetRandom(curLevelItem.endStage);
}
_curStageIndex++;
StartStage(nextStageId);
}
else
{
var nextStageId = GlobalUtils.GetRandom(curLevelItem.endStage);
if (nextStageId <= 0)
{
nextStageId = GlobalUtils.GetRandom(curStageItem.nextStages);
}
_curStageIndex = _maxStageIndex;
StartStage(nextStageId);
}
}
/// <summary>
///
/// </summary>
private void InitPoint()
{
_spawnPoints.Clear();
var spawnRoot = _stageRoot.Find("aaapoint");
if (spawnRoot)
for (int i = spawnRoot.childCount - 1; i >= 0; i--)
{
_spawnPoints.Add(spawnRoot.GetChild(i).position);
}
var propRoot = _stageRoot.Find("bbbpoint");
if (propRoot)
for (int i = 0; i < MAX_PROP_COUNT; i++)
{
_propPoints[i] = propRoot.GetChild(i).position;
}
var bornPointT = _stageRoot.Find("born_point");
_bornPoint = bornPointT ? bornPointT.position : Vector3.zero;
var doorT = _stageRoot.Find("door1");
endPosition = doorT ? doorT.position : new Vector3(0f, 0f, 4f);
}
private void InitGiftBox()
{
if (!_giftBox)
_giftBox = Instantiate(giftBoxAsset.transform, Vector3.up * 60f, Quaternion.Euler(0f, 30f, 0f));
_giftBox.transform.position = Vector3.up * 60f;
_giftBox.gameObject.SetActive(false);
}
/// <summary>
///
/// </summary>
private void InitPortal()
{
if (_curStageIndex == _maxStageIndex)
{
for (int i = 0; i < _portals.Length; i++)
{
CreatePortal(i, "");
}
}
else if (_curStageIndex < _maxStageIndex)
{
//var nextStageId = curStageItem.l
if (_curStageIndex == _maxStageIndex - 1 && curLevelItem.hasEnd)
{
for (int i = 0; i < _portals.Length; i++)
{
CreatePortal(i, "portal_boss");
}
}
else
{
for (int i = 0; i < _portals.Length; i++)
{
var nextIndex = GlobalUtils.GetRandom(curStageItem.nextStages);
CreatePortal(i, $"portal_{nextIndex}");
}
}
}
}
/// <summary>
///
/// </summary>
private void CreatePortal(int index, string doorName)
{
var doorRoot = _stageRoot.Find($"door{index + 1}");
if (doorRoot)
{
if (!_portals[index])
_portals[index] = SpawnPool.Spawn(portalAsset, doorRoot.position, doorRoot.rotation);
_portals[index].SetActive(false);
_portals[index].name = doorName;
}
}
/// <summary>
///
/// </summary>
/// <param name="position"></param>
public void OpenGiftBox(Vector3 position)
{
if (this.normalMode)
{
SaveNormalLevelState();
}
_giftBox.position = position;
_giftBox.gameObject.SetActive(true);
}
/// <summary>
/// 打开传送门
/// </summary>
public void OpenPortal(float delay = 3.6f)
{
if (_curStageIndex < _maxStageIndex)
{
StartCoroutine(OpenPortalCO(delay));
}
else
{
FinishLevel(true, "");
}
}
/// <summary>
///
/// </summary>
/// <param name="delay"></param>
/// <returns></returns>
private IEnumerator OpenPortalCO(float delay)
{
yield return new WaitForSeconds(delay);
for (int i = 0; i < _portals.Length; i++)
{
_portals[i].SetActive(true);
}
}
public void SetGroundText(string text, float duration, float delay)
{
//if (_textMesh)
StartCoroutine(SetTextCO(text, delay));
}
private IEnumerator SetTextCO(string text, float delay)
{
yield return new WaitForSeconds(delay);
//_textMesh.text = text;
}
private void UpdateTimeScale()
{
if (!_stageFinish)
{
if (Time.timeScale >= 1f)
{
Time.timeScale = gameSpeed;
}
}
else
{
if (Time.timeScale > 1f)
{
Time.timeScale = 1f;
}
}
}
#endregion
#region Diffcult
private float _dynamicDifficult;
public void AddDifficult()
{
_dynamicDifficult = Mathf.Clamp(_dynamicDifficult + 0.025f, 0.9f, 1.1f);
ArchiveProxy.Instance.GetInt("difficult", Mathf.FloorToInt(_dynamicDifficult * 100));
}
public void ReduceDifficult()
{
_dynamicDifficult = Mathf.Clamp(_dynamicDifficult - 0.1f, 0.9f, 1.1f);
ArchiveProxy.Instance.GetInt("difficult", Mathf.FloorToInt(_dynamicDifficult * 100));
}
#endregion
#region Setting
private bool _trackEnemy = true;
public bool autoTrackEnemy
{
get => _trackEnemy;
set
{
if (_trackEnemy != value)
{
_trackEnemy = value;
PlayerPrefs.SetInt("track_enemy", value ? 1 : 0);
PlayerPrefs.Save();
}
}
}
private bool _vibrateSwitch = false;
public bool vibrateSwitch
{
get => _vibrateSwitch;
set
{
if (_vibrateSwitch != value)
{
_vibrateSwitch = value;
PlayerPrefs.SetInt("vibrate_switch", value ? 1 : 0);
PlayerPrefs.Save();
}
}
}
private void InitSetting()
{
_trackEnemy = PlayerPrefs.GetInt("track_enemy", 1) != 0;
_vibrateSwitch = PlayerPrefs.GetInt("vibrate_switch", 0) != 0;
}
#endregion
#region Unity
public static GameLevel Instance;
private void Awake()
{
Instance = this;
_dynamicDifficult = Mathf.Clamp(ArchiveProxy.Instance.GetInt("difficult", 100) * 0.01f, 0.8f, 1.2f);
OnEnterScene();
InitSetting();
}
private void OnDestroy()
{
OnExitScene();
PlayerProxy.Instance.TryoutFinish();
}
private void Update()
{
if (!_stageFinish)
{
UpdateMode();
UpdateSpawn();
}
#if UNITY_EDITOR
if (Input.GetKeyUp(KeyCode.LeftArrow))
{
gameSpeed -= 0.5f;
}
else if (Input.GetKeyUp(KeyCode.RightArrow))
{
gameSpeed += 0.5f;
}
else if (Input.GetKeyUp(KeyCode.Space))
{
gameSpeed = 1f;
}
else if (Input.GetKeyUp(KeyCode.UpArrow))
{
gameSpeed = 0f;
MovesShop.Instance.AddMovesPoint(curStageItem.skillCardPoint);
MovesShop.Instance.SetMovesPackage(curStageItem.skillCardPackage, false,
(error, message) =>
{
gameSpeed = 1f;
});
}
#endif
}
private void LateUpdate()
{
UpdateTimeScale();
}
#endregion
}
}