823 lines
29 KiB
C#
823 lines
29 KiB
C#
using cfg.LevelCfg;
|
|
using System.Collections.Generic;
|
|
using AOT.PostProcess.BlackArea;
|
|
using Code.Scripts.Gameplay.Enviorment;
|
|
using Code.Scripts.Gameplay.Fight.Evacuate;
|
|
using Code.Scripts.Gameplay.PlaneShadow;
|
|
using Code.Scripts.Gameplay.Utils;
|
|
using CriWare;
|
|
using Cysharp.Threading.Tasks;
|
|
using Framework;
|
|
using Gameplay.AI;
|
|
using Gameplay.Area;
|
|
using Gameplay.Area.Around;
|
|
using Gameplay.BT.Variables;
|
|
using Gameplay.Buff;
|
|
using Gameplay.Bullet;
|
|
using Gameplay.Character;
|
|
using Gameplay.Common;
|
|
using Gameplay.Effect;
|
|
using Gameplay.Emoji;
|
|
using Gameplay.Fight.Capture;
|
|
using Gameplay.Fight.FightStory;
|
|
using Gameplay.Fight.Flag;
|
|
using Gameplay.Level.FightInfo;
|
|
using Gameplay.Level.Select;
|
|
using Gameplay.Pause;
|
|
using Gameplay.Performance;
|
|
using Gameplay.Pool;
|
|
using Gameplay.PostProcess.BlackArea;
|
|
using Gameplay.Skill;
|
|
using Gameplay.SubSystems;
|
|
using Gameplay.Unit;
|
|
using Gameplay.Utils;
|
|
using Gameplay.Vehicle.Impl;
|
|
using LTGame;
|
|
using PhxhSDK;
|
|
using SRF;
|
|
using UnityEngine;
|
|
using Utils.Bounds;
|
|
|
|
namespace Gameplay.Level
|
|
{
|
|
public partial class Level : IUpdatable, ILoadable
|
|
{
|
|
private const string AIBehavior = "AIBehavior";
|
|
|
|
private int _id;
|
|
|
|
private LevelData _levelData;
|
|
private LevelInfo _currLevelInfo;
|
|
private Map _map;
|
|
|
|
private NStateMachine<BaseLevelState> _fsm = new NStateMachine<BaseLevelState>();
|
|
public bool isInBattle = false;
|
|
private object _param;
|
|
|
|
public int ID => _id;
|
|
public Map Map => _map;
|
|
|
|
public FightStoryManager fightStoryManager = new FightStoryManager();
|
|
public FightInfoManager fightInfoManager = new FightInfoManager();
|
|
|
|
public float LevelTime { set; get; }
|
|
|
|
public bool IsPvPLevel => _id == TableManager.Instance.Tables.GlobalConfig.PVPLevelID;
|
|
|
|
public bool IsWar => _currLevelInfo.ChapterInfo.Cfg.Type == E_ChapterType.War;
|
|
|
|
private List<string> _cacheLoadUrls = new List<string>();
|
|
|
|
/// <summary>
|
|
/// 上缴旗子数量
|
|
/// </summary>
|
|
public int FlagSubmit;
|
|
/// <summary>
|
|
/// 撤离数量
|
|
/// </summary>
|
|
public int RetreatCount;
|
|
/// <summary>
|
|
/// 己方Npc的LocalID
|
|
/// </summary>
|
|
public List<int> SelfNpcLocalID;
|
|
|
|
public Level(int leveId,
|
|
object param = null)
|
|
{
|
|
_id = leveId;
|
|
_param = param;
|
|
_Init();
|
|
}
|
|
|
|
private Dictionary<string, DataLevel> _configLevelDic = new Dictionary<string, DataLevel>();
|
|
public Dictionary<string, DataLevel> ConfigLevelDic => _configLevelDic;
|
|
|
|
private void LoadConfigLevel()
|
|
{
|
|
LevelManager.Instance.TryGetLevelInfoByID(_id, out _currLevelInfo);
|
|
}
|
|
|
|
private async UniTask LoadScene()
|
|
{
|
|
await GameSceneManager.Instance.LoadSceneAsync(_currLevelInfo.Cfg.LevelScene);
|
|
await AssetManager.Instance.LoadAndInstAsync(CmpAreaColorSettings.ASSET_PATH);
|
|
}
|
|
|
|
private async UniTask UnLoadScene()
|
|
{
|
|
await GameSceneManager.Instance.UnLoadSceneAsync(_currLevelInfo.Cfg.LevelScene);
|
|
AssetManager.Instance.Unload(CmpAreaColorSettings.ASSET_PATH);
|
|
}
|
|
|
|
private void LoadData()
|
|
{
|
|
_levelData = _currLevelInfo.LevelData;
|
|
}
|
|
|
|
private async UniTask LoadMap()
|
|
{
|
|
_map = await MapUtils.LoadMap(_currLevelInfo.MapData);
|
|
AroundHelper.Init();
|
|
|
|
var sceneCamera = NLDSceneManager.Instance.SceneCamera;
|
|
CameraManager.Instance.SwitchMainCamera(sceneCamera);
|
|
MapUtils.BindCameraController(NLDSceneManager.Instance.SceneCamera, _map);
|
|
}
|
|
|
|
private async UniTask _LoadNpc()
|
|
{
|
|
if (!IsPvPLevel)
|
|
{
|
|
await _LoadEnemyFromLevelData();
|
|
await _LoadSelfNpcFromLevelData();
|
|
// 2024-11-14 不在需要护送对象
|
|
// await _LoadBeProtectFromLevelData();
|
|
}
|
|
else
|
|
{
|
|
await _LoadNPCFromPVPData();
|
|
// await _TempCreateBuild();
|
|
}
|
|
}
|
|
|
|
private async UniTask<GameUnit> _TempCreateBuild(uint id)
|
|
{
|
|
// DebugUtil.LogError("临时创建建筑");
|
|
// var tempCellIndex = (int)cellIndex;//37;
|
|
var tempBuildId = (int)id;//1005;
|
|
var teamId = ETroopsId.Enemy;
|
|
var createUnit = await GameUnitManager.instance.PrepareBuild(tempBuildId, teamId);
|
|
if (createUnit == null)
|
|
{
|
|
DebugUtil.LogError("创建建筑失败");
|
|
return null;
|
|
}
|
|
// GameUnitManager.instance.MoveUnitToFight(createUnit.GetID(), tempCellIndex, 0);
|
|
return createUnit;
|
|
}
|
|
|
|
|
|
private async UniTask _LoadSelfNpcFromLevelData()
|
|
{
|
|
if (_levelData == null) return;
|
|
if (_map == null) return;
|
|
|
|
for (int i = 0; i < _levelData.selfNpcInfos.Count; i++)
|
|
{
|
|
var npcInfo = _levelData.selfNpcInfos[i];
|
|
|
|
var cellIndex = _map.BlockPosition2TGSCellIndex(npcInfo.position);
|
|
var yaw = LevelUtils.SetCharaterToward(npcInfo.npcToward);
|
|
var createUnit = await GameUnitManager.instance.PrepareSelfNpc(npcInfo);
|
|
if (createUnit == null)
|
|
{
|
|
DebugUtil.LogError("创建己方npc失败:" + npcInfo.id);
|
|
continue;
|
|
}
|
|
|
|
createUnit.unitLevelData = new UnitLevelData()
|
|
{
|
|
LocalId = npcInfo.index,
|
|
AttachAIName = npcInfo.attachAIType,
|
|
AIName = npcInfo.aIType,
|
|
BornPosition = cellIndex,
|
|
NpcToward = npcInfo.npcToward,
|
|
PatrolInfos = npcInfo.patrolInfos,
|
|
GroupInfos = npcInfo.groups,
|
|
DefensiveDistance = npcInfo.defensiveDistance,
|
|
monsterId = npcInfo.id,
|
|
};
|
|
|
|
createUnit.transData.bornCellIndex = cellIndex;
|
|
GameUnitManager.instance.MoveUnitToFight(createUnit.GetID(), cellIndex, yaw);
|
|
}
|
|
}
|
|
|
|
private async UniTask _LoadEnemyFromLevelData()
|
|
{
|
|
if (_levelData == null) return;
|
|
if (_map == null) return;
|
|
for (var i = 0; i < _levelData.npcInfos.Count; i++)
|
|
{
|
|
var npcInfo = _levelData.npcInfos[i];
|
|
|
|
var cellIndex = _map.BlockPosition2TGSCellIndex(npcInfo.position);
|
|
var yaw = LevelUtils.SetCharaterToward(npcInfo.npcToward);
|
|
var createUnit =
|
|
await GameUnitManager.instance.PrepareEnemyNpc(npcInfo);
|
|
if (createUnit == null)
|
|
{
|
|
DebugUtil.LogError("创建敌人失败:" + npcInfo.id);
|
|
continue;
|
|
}
|
|
|
|
createUnit.unitLevelData = new UnitLevelData()
|
|
{
|
|
LocalId = npcInfo.index,
|
|
AttachAIName = npcInfo.attachAIType,
|
|
AIName = npcInfo.aIType,
|
|
BornPosition = cellIndex,
|
|
NpcToward = npcInfo.npcToward,
|
|
PatrolInfos = npcInfo.patrolInfos,
|
|
GroupInfos = npcInfo.groups,
|
|
DefensiveDistance = npcInfo.defensiveDistance,
|
|
monsterId = npcInfo.id,
|
|
};
|
|
|
|
createUnit.transData.bornCellIndex = cellIndex;
|
|
GameUnitManager.instance.MoveUnitToFight(createUnit.GetID(), cellIndex, yaw);
|
|
}
|
|
}
|
|
|
|
private async UniTask _LoadNPCFromPVPData()
|
|
{
|
|
var pvpDefenderData = _param as PVPDefenderData;
|
|
if (pvpDefenderData == null)
|
|
{
|
|
DebugUtil.LogError("pvp参数不合法!");
|
|
return;
|
|
}
|
|
|
|
for (var i = 0; i < pvpDefenderData.pvpRuntimeUnitInfos.Count; i++)
|
|
{
|
|
var pvpUnitData = pvpDefenderData.pvpRuntimeUnitInfos[i];
|
|
//var id = (uint)pvpUnitData.unitID;
|
|
|
|
var position = _map.TGSCellIndex2BlockPosition(pvpUnitData.cellIndex);
|
|
var teamId = ETroopsId.Enemy;
|
|
GameUnit unit = null;
|
|
switch (pvpUnitData.type)
|
|
{
|
|
case Framework.Wrapper.Unit.UnitType.Charactor:
|
|
var cInfo = new CharacterDataInfo();
|
|
cInfo.Refresh(pvpUnitData.characterInfo);
|
|
unit = await GameUnitManager.instance.PrepareCharacter(cInfo, teamId);
|
|
break;
|
|
case Framework.Wrapper.Unit.UnitType.Vehicle:
|
|
//todo VehicleCultivateData第二个参数
|
|
var vInfo = new VehicleCultivateData();
|
|
vInfo.Refresh(pvpUnitData.vehicleInfo);
|
|
unit = await GameUnitManager.instance.PrepareVehicle(vInfo, teamId);
|
|
break;
|
|
case Framework.Wrapper.Unit.UnitType.Building:
|
|
var bInfo = pvpUnitData.fightBuildingData;
|
|
unit = await _TempCreateBuild(bInfo.Uid);
|
|
break;
|
|
}
|
|
|
|
if (unit == null)
|
|
{
|
|
DebugUtil.LogError("创建pvp unit失败");
|
|
continue;
|
|
}
|
|
|
|
unit.unitLevelData = new UnitLevelData()
|
|
{
|
|
AttachAIName = pvpUnitData.attachAIType,
|
|
AIName = pvpUnitData.aiType,
|
|
BornPosition = pvpUnitData.cellIndex,
|
|
NpcToward = _levelData.pvpDefendToward,
|
|
PatrolInfos = new(),
|
|
GroupInfos = new (),
|
|
};
|
|
|
|
var yaw = LevelUtils.SetCharaterToward(_levelData.pvpDefendToward);
|
|
GameUnitManager.instance.MoveUnitToFight(unit.GetID(), pvpUnitData.cellIndex, yaw);
|
|
}
|
|
}
|
|
|
|
public void Update(float deltaTime)
|
|
{
|
|
_fsm.LogicUpdate(deltaTime * _speed);
|
|
selectView?.LogicUpdate();
|
|
PlaneShadowManager.instance.ViewUpdate();
|
|
|
|
if (!_isPause)
|
|
{
|
|
// AI驱动
|
|
AIManager.Instance.Update(deltaTime * _speed);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 这里是 level system的初始化,不是 level 场景的初始化
|
|
/// </summary>
|
|
private void _Init()
|
|
{
|
|
_InitFsm();
|
|
|
|
FlagSubmit = 0;
|
|
|
|
// 初始化速度
|
|
ELevelSpeed.Level_0 = TableManager.Instance.Tables.GlobalConfig.FightSpeedParams[0];
|
|
ELevelSpeed.Level_1 = TableManager.Instance.Tables.GlobalConfig.FightSpeedParams[1];
|
|
ELevelSpeed.Level_2 = TableManager.Instance.Tables.GlobalConfig.FightSpeedParams[2];
|
|
ELevelSpeed.Level_3 = TableManager.Instance.Tables.GlobalConfig.FightSpeedParams[3];
|
|
var defaultLevelSpeedIndex = TableManager.Instance.Tables.GlobalConfig.FightSpeedDefault;
|
|
ELevelSpeed.DEFAULT_SPEED = TableManager.Instance.Tables.GlobalConfig.FightSpeedParams[defaultLevelSpeedIndex];
|
|
|
|
AIManager.Instance.Init();
|
|
|
|
GameUnitManager.CreateInstance();
|
|
|
|
SkillManager.CreateInstance();
|
|
BuffManager.CreateInstance();
|
|
|
|
}
|
|
|
|
private void _InitFsm()
|
|
{
|
|
_fsm.Add(new LevelStatePreStory(this));
|
|
_fsm.Add(new LevelStatePrepare(this));
|
|
_fsm.Add(new LevelStateBattle(this));
|
|
_fsm.Add(new LevelStateBattleStory(this));
|
|
_fsm.Add(new LevelStateEnd(this));
|
|
_fsm.Add(new LevelStateEndStory(this));
|
|
}
|
|
|
|
public void Release()
|
|
{
|
|
_fsm.Exit();
|
|
|
|
fightInfoManager.Dispose();
|
|
|
|
BulletManager.instance.Dispose();
|
|
BoundsManager.instance.Dispose();
|
|
EnviormentManager.instance.Dispose();
|
|
|
|
AreaManager.instance.Dispose();
|
|
|
|
SkillManager.instance.Dispose();
|
|
BuffManager.instance.Dispose();
|
|
|
|
AIManager.Instance.Release();
|
|
|
|
CaptureManager.instance.Dispose();
|
|
FlagManager.instance.Dispose();
|
|
EvacuateManager.instance.Dispose();
|
|
|
|
// 在这里释放所有单位
|
|
GameUnitManager.instance.Dispose();
|
|
|
|
if (PauseManager.instance != null)
|
|
{
|
|
PauseManager.instance.Dispose();
|
|
}
|
|
|
|
EffectManager.instance.ClearPool();
|
|
ObjPoolManager.instance.Clear();
|
|
BlackAreaManager.instance.Dispose();
|
|
|
|
for (int i = 0; i < _cacheLoadUrls.Count; i++)
|
|
{
|
|
var url = _cacheLoadUrls[i];
|
|
AssetManager.Instance.Unload(url);
|
|
}
|
|
_cacheLoadUrls.Clear();
|
|
|
|
// 卸载关卡时强制隐藏技能相机
|
|
CameraManager.Instance.SkillCamera.gameObject.SetActive(false);
|
|
}
|
|
|
|
public async UniTask Load()
|
|
{
|
|
LoadConfigLevel();
|
|
|
|
// GameUnitManager.instance.PrepareUnits();
|
|
//UIManager.Instance.CloseAllNormalExcept(UINameConst.UI_Loading); // 打开加载界面时已经移除
|
|
|
|
await LoadScene();
|
|
LoadData();
|
|
await LoadMap();
|
|
await _LoadWeather();
|
|
|
|
await _InitAfterLoadMap();
|
|
|
|
await _LoadOthers();
|
|
|
|
selectView = new SelectView();
|
|
selectView.Init();
|
|
|
|
PlaneShadowManager.instance.Init();
|
|
|
|
await _LoadNpc();
|
|
_CreateCapturePoints();
|
|
_CreateFlags();
|
|
_CreateEvacuate();
|
|
|
|
RegisterAllEvent();
|
|
InitRules();
|
|
_InitAudioListener();
|
|
|
|
_UpdateAllUnits();
|
|
|
|
InitAIStart();
|
|
|
|
_AfterLoadInit();
|
|
|
|
}
|
|
|
|
public void EnterLevel()
|
|
{
|
|
_fsm.SetForceChangeState(ELevelState.PreStory);
|
|
}
|
|
|
|
private void _AfterLoadInit()
|
|
{
|
|
AreaManager.instance.Init();
|
|
|
|
BulletManager.CreateInstance();
|
|
BuffManager.instance.Init();
|
|
SkillManager.instance.Init();
|
|
BulletManager.instance.Init();
|
|
|
|
PauseManager.CreateInstance();
|
|
PauseManager.instance.Init();
|
|
|
|
EnviormentManager.CreateInstance();
|
|
EnviormentManager.instance.Init();
|
|
|
|
var enableBlackArea = _currLevelInfo.Cfg.LevelTime == DayNightType.Night;
|
|
BlackAreaManager.instance.Init(enableBlackArea);
|
|
|
|
fightInfoManager.Init();
|
|
|
|
// 这个参数需要关闭
|
|
_map.TerrainGridSystem.respectOtherUI = false;
|
|
}
|
|
|
|
private void _InitAudioListener()
|
|
{
|
|
var cameraRoot = CameraManager.Instance.MainCamera.gameObject;
|
|
cameraRoot.RemoveComponentIfExists<CriAtomListener>();
|
|
var rayHits = new RaycastHit[10];
|
|
var ray = CameraManager.Instance.MainCamera.ScreenPointToRay(new Vector3(Screen.width / 2f,
|
|
Screen.height / 2f, 0));
|
|
var layerMask = LayerMask.GetMask("Ground");
|
|
var rayHit = Physics.RaycastNonAlloc(ray, rayHits, 1000, layerMask);
|
|
if (rayHit <= 0) return;
|
|
var firstHit = rayHits[0];
|
|
var hitPoint = firstHit.point;
|
|
var listenerRoot = new GameObject("Listener");
|
|
listenerRoot.transform.SetParent(cameraRoot.transform);
|
|
listenerRoot.transform.position = hitPoint;
|
|
listenerRoot.AddComponent<CriAtomListener>();
|
|
}
|
|
|
|
private void _UpdateAllUnits()
|
|
{
|
|
var units = GameUnitManager.instance.infightUnits.unitList;
|
|
for (int i = 0; i < units.Count; i++)
|
|
{
|
|
var unit = units[i];
|
|
unit.ForceUpdateBlackArea();
|
|
}
|
|
}
|
|
|
|
private async void InitAIStart()
|
|
{
|
|
SelfNpcLocalID = new List<int>();
|
|
var units = GameUnitManager.instance.infightUnits.unitList;
|
|
foreach (var unit in units)
|
|
{
|
|
if (unit is Character.Character unitCharacter)
|
|
{
|
|
await _HandleForCharacter(unitCharacter);
|
|
}
|
|
else if (unit is NormalVehicle unitVehicle)
|
|
{
|
|
await _HandleForVehicle(unitVehicle);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
private async UniTask _HandleForVehicle(NormalVehicle vehicle)
|
|
{
|
|
if (vehicle == null) return;
|
|
|
|
if (vehicle.commonData.troopId == ETroopsId.Self)
|
|
{
|
|
if (vehicle.unitLevelData == null)
|
|
{
|
|
// 己方默认激活
|
|
vehicle.statusData.isAttackActive = true;
|
|
return;
|
|
}
|
|
|
|
SelfNpcLocalID.Add(vehicle.unitLevelData.LocalId);
|
|
}
|
|
else
|
|
{
|
|
// AI 默认非激活
|
|
vehicle.statusData.isAttackActive = false;
|
|
}
|
|
|
|
var bt = await AIManager.Instance.RegisterAI(vehicle.Node.GameObject, AIBehavior);
|
|
bt.SetVariable("battleInfo", new SharedBattleInfo()
|
|
{
|
|
Value = new BattleInfo()
|
|
{
|
|
ownerId = vehicle.GetID(),
|
|
AIName = vehicle.unitLevelData.AIName,
|
|
AttachAIName = vehicle.unitLevelData.AttachAIName,
|
|
PatrolInfos = vehicle.unitLevelData.PatrolInfos,
|
|
groupInfo = vehicle.unitLevelData.GroupInfos,
|
|
cannotReach = new List<int>(),
|
|
}
|
|
});
|
|
vehicle.statusData.isAIControll = true;
|
|
}
|
|
|
|
private async UniTask _HandleForCharacter(Character.Character character)
|
|
{
|
|
if (character == null) return;
|
|
|
|
if (character.troopId == ETroopsId.Self)
|
|
{
|
|
if (character.unitLevelData == null)
|
|
{
|
|
// 玩家默认激活
|
|
character.statusData.isAttackActive = true;
|
|
return;
|
|
}
|
|
|
|
SelfNpcLocalID.Add(character.unitLevelData.LocalId);
|
|
}
|
|
else
|
|
{
|
|
// AI 默认非激活
|
|
character.statusData.isAttackActive = false;
|
|
}
|
|
|
|
var bt = await AIManager.Instance.RegisterAI(character.Node.GameObject, AIBehavior);
|
|
bt.SetVariable("battleInfo", new SharedBattleInfo()
|
|
{
|
|
Value = new BattleInfo()
|
|
{
|
|
ownerId = character.GetID(),
|
|
AIName = character.unitLevelData.AIName,
|
|
AttachAIName = character.unitLevelData.AttachAIName,
|
|
PatrolInfos = character.unitLevelData.PatrolInfos,
|
|
groupInfo = character.unitLevelData.GroupInfos,
|
|
cannotReach = new List<int>(),
|
|
}
|
|
});
|
|
|
|
if(character.unitLevelData.AttachAIName == LevelData.AttachAIType.None)
|
|
character.statusData.isAttackActive = true;
|
|
character.statusData.isAIControll = true;
|
|
}
|
|
|
|
private void _CreateCapturePoints()
|
|
{
|
|
CaptureManager.CreateInstance();
|
|
CaptureManager.instance.Init();
|
|
}
|
|
|
|
private void _CreateFlags()
|
|
{
|
|
FlagManager.CreateInstance();
|
|
FlagManager.instance.Init();
|
|
}
|
|
|
|
private void _CreateEvacuate()
|
|
{
|
|
EvacuateManager.CreateInstance();
|
|
EvacuateManager.instance.Init();
|
|
}
|
|
|
|
private async UniTask _LoadWeather()
|
|
{
|
|
var weatherType = (int)_currLevelInfo.Cfg.LevelWeather;
|
|
var groundType = (int)_currLevelInfo.eLevelTerrain;
|
|
var weatherEffectConfig = TableManager.Instance.Tables.WeatherEffectConfig.Get(weatherType, groundType);
|
|
if (weatherEffectConfig == null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var cameraPrefab = weatherEffectConfig.CameraPrefab;
|
|
if (string.IsNullOrEmpty(cameraPrefab))
|
|
{
|
|
return;
|
|
}
|
|
|
|
var finalPath = PathEx.GetWeatherCameraEffectPath(cameraPrefab);
|
|
var loadObj = await AssetManager.Instance.LoadAssetAsync<GameObject>(finalPath);
|
|
if (loadObj == null)
|
|
{
|
|
DebugUtil.LogError("加载天气特效失败:{0}", finalPath);
|
|
return;
|
|
}
|
|
|
|
var cameraObj = CameraManager.Instance.MainCamera.gameObject;
|
|
var weatherCamera = Object.Instantiate(loadObj, cameraObj.transform);
|
|
weatherCamera.transform.localPosition = Vector3.zero;
|
|
weatherCamera.transform.localRotation = Quaternion.identity;
|
|
}
|
|
|
|
private void _SetShadowDistance()
|
|
{
|
|
var setDistance = _currLevelInfo.Cfg.ShadowDistance;
|
|
ShadowEx.SetShadowDistance(setDistance);
|
|
}
|
|
|
|
private void _PostPreload(string url)
|
|
{
|
|
AssetManager.Instance.PostPreload(url);
|
|
_cacheLoadUrls.Add(url);
|
|
}
|
|
|
|
private async UniTask _LoadOthers()
|
|
{
|
|
_PostPreload(PathDefine.TireMark.TIREMARK_UNIT_PATH);
|
|
_PostPreload(PathDefine.TireMark.TIREMARK_MAT_PATH);
|
|
_PostPreload(PathDefine.SelectView.CHARACTER_SELECT_GROUND_GFX);
|
|
_PostPreload(PathDefine.Summon.SELF);
|
|
_PostPreload(PathDefine.Summon.ENEMY);
|
|
_PostPreload(PathDefine.SkillArea.SKILL_GORUND_HIGH_LIGHT);
|
|
_PostPreload(PathDefine.SkillArea.HIGHLIGHT_POINT);
|
|
|
|
// 占领相关
|
|
_PostPreload(PathDefine.CapturePoint.CAPTURE_POINT_PROGRESS_PATH);
|
|
_PostPreload(PathDefine.CapturePoint.CAPTURE_POINT_GROUND_POINT_PATH);
|
|
|
|
// 扛旗相关
|
|
_PostPreload(PathDefine.HoldFlag.FLAG_RETURN_PATH);
|
|
_PostPreload(PathDefine.HoldFlag.FLAG_GROUND_POINT_PATH);
|
|
|
|
_PostPreload(PathDefine.ProtectUnit.TARGET_POINT_PATH);
|
|
_PostPreload(PathDefine.BlackArea.FIGHT_LIGHT_AREA_PATH);
|
|
_PostPreload(PathDefine.AttackArea.FIGHT_CELL_COLLIDER_PATH);
|
|
_PostPreload(SkillRotateCamera.PREFAB_PATH);
|
|
_PostPreload(BlackAreaManagerImpl.BLIT_MAT_PATH);
|
|
_PostPreload(PathDefine.MoveArea.MOVE_AREA_POINT_PATH);
|
|
|
|
for (int i = 0; i < PathDefine.RoadLine.END_NOTICES.Length; i++)
|
|
{
|
|
var path = PathDefine.RoadLine.END_NOTICES[i];
|
|
_PostPreload(path);
|
|
}
|
|
_PostPreload(PathDefine.RoadLine.ROAD_LINE);
|
|
_PostPreload(PathDefine.RoadLine.ROAD_LINE_STRAIGHT);
|
|
|
|
_PostPreload(PathDefine.ReadyArea.READY_AREA_POINT);
|
|
|
|
_PostPreload(PathDefine.SkillArea.SELECT_POINT);
|
|
|
|
// 撤离相关
|
|
_PostPreload(PathDefine.Evacuate.EVACUATE_LOOP_EFFECT_PATH);
|
|
_PostPreload(PathDefine.Evacuate.EVACUATE_GROUND_POINT_PATH);
|
|
|
|
// 面片阴影
|
|
_PostPreload(PathDefine.PlaneShadow.PLANE_SHADOW_VEHICLE_PATH);
|
|
_PostPreload(PathDefine.PlaneShadow.PLANE_SHADOW_CHARACTER_PATH);
|
|
|
|
await AssetManager.Instance.WaitAllPreloads();
|
|
}
|
|
|
|
private async UniTask _InitAfterLoadMap()
|
|
{
|
|
// 设置为手动更新
|
|
Physics.simulationMode = SimulationMode.Script;
|
|
Physics2D.simulationMode = SimulationMode2D.Script;
|
|
|
|
// 更新地面
|
|
Physics.SyncTransforms();
|
|
|
|
// 设置TGS为运行半透明地面
|
|
_map.TerrainGridSystem.transparentBackground = true;
|
|
|
|
var blackAreaInst = new BlackAreaManagerImpl();
|
|
BlackAreaManager.CreateInstance(blackAreaInst);
|
|
|
|
_InitCameraParams();
|
|
|
|
// 加载后处理
|
|
await _LoadOutlinePost();
|
|
|
|
AreaManager.CreateInstance();
|
|
|
|
_InitPerformanceSetting();
|
|
|
|
await AssetManager.Instance.WaitAllPreloads();
|
|
}
|
|
|
|
private void _InitCameraParams()
|
|
{
|
|
var camera = CameraManager.Instance.MainCamera;
|
|
var cullingMask = 1 << LayerDefine.Default
|
|
| 1 << LayerDefine.GROUND
|
|
| 1 << LayerDefine.UNIT
|
|
| 1 << LayerDefine.Skill
|
|
| 1 << LayerDefine.LightArea
|
|
| 1 << LayerDefine.TeamSelf
|
|
| 1 << LayerDefine.TeamEnemy;
|
|
camera.cullingMask = cullingMask;
|
|
}
|
|
|
|
private void _InitPerformanceSetting()
|
|
{
|
|
PerformanceManager.instance.AutoSetGlobalVolume();
|
|
_SetShadowDistance();
|
|
}
|
|
|
|
private async UniTask _LoadOutlinePost()
|
|
{
|
|
// todo: 因为逻辑上有使用outlinemanager.instance 所以这里需要先加载
|
|
// if (!PerformanceManager.instance.data.enablePostOutline) return;
|
|
// 加载shader
|
|
_PostPreload(PathDefine.Outline.MAT1);
|
|
_PostPreload(PathDefine.Outline.MAT1_1);
|
|
_PostPreload(PathDefine.Outline.MAT2);
|
|
_PostPreload(PathDefine.Outline.MAT3);
|
|
await AssetManager.Instance.WaitAllPreloads();
|
|
var loadObj =
|
|
await AssetManager.Instance.LoadAssetAsync<GameObject>(PathDefine.Outline.MANAGER_PATH);
|
|
if (loadObj != null)
|
|
{
|
|
Object.Instantiate(loadObj);
|
|
|
|
OutlineManager.instance.mat1 = AssetManager.Instance.GetPreLoadResult<Material>(PathDefine.Outline.MAT1);
|
|
OutlineManager.instance.mat1_1 = AssetManager.Instance.GetPreLoadResult<Material>(PathDefine.Outline.MAT1_1);
|
|
OutlineManager.instance.mat2 = AssetManager.Instance.GetPreLoadResult<Material>(PathDefine.Outline.MAT2);
|
|
OutlineManager.instance.mat3 = AssetManager.Instance.GetPreLoadResult<Material>(PathDefine.Outline.MAT3);
|
|
|
|
// 全部instance之后再设置
|
|
OutlineManager.instance.mat1 = new Material(OutlineManager.instance.mat1);
|
|
OutlineManager.instance.mat1_1 = new Material(OutlineManager.instance.mat1_1);
|
|
OutlineManager.instance.mat2 = new Material(OutlineManager.instance.mat2);
|
|
OutlineManager.instance.mat3 = new Material(OutlineManager.instance.mat3);
|
|
|
|
OutlineManager.instance.targetCamera = CameraManager.Instance.MainCamera;
|
|
|
|
var screenWidth = Screen.width;
|
|
var sampleDistance = OutlineManager.instance.m_SampleDistance;
|
|
var wrapDistance = sampleDistance / 1080 * screenWidth;
|
|
var scaleProgress = CameraManager.Instance.GetOutlineScale(wrapDistance);
|
|
OutlineManager.instance.scaleProgress = scaleProgress;
|
|
}
|
|
}
|
|
|
|
public async void BeginBattle()
|
|
{
|
|
_fsm.SetForceChangeState(ELevelState.Battle);
|
|
// 延迟激活AI
|
|
await UniTask.Delay(500);
|
|
AIManager.Instance.StartAI();
|
|
}
|
|
|
|
public bool IsPreparing()
|
|
{
|
|
if (_fsm.currentState == null)
|
|
{
|
|
return false;
|
|
}
|
|
return _fsm.currentState.id == ELevelState.Prepare;
|
|
}
|
|
|
|
public bool IsInBattle()
|
|
{
|
|
return isInBattle;
|
|
}
|
|
|
|
public bool IsEnd()
|
|
{
|
|
if (_fsm.currentState == null)
|
|
{
|
|
return false;
|
|
}
|
|
return _fsm.currentState.id == ELevelState.End;
|
|
}
|
|
|
|
public void ClickFromScreen(Vector2 screenPos)
|
|
{
|
|
var state = _fsm.currentState as BaseLevelState;
|
|
state?.ClickFromScreen(screenPos);
|
|
}
|
|
|
|
public async UniTask Unload()
|
|
{
|
|
CameraManager.Instance.RevertMainCamera();
|
|
MapUtils.UnLoadMap(_map);
|
|
UnRegisterAllEvent();
|
|
ReleaseRules();
|
|
selectView.Dispose();
|
|
PlaneShadowManager.instance.Dispose();
|
|
|
|
await UnLoadScene();
|
|
await UniTask.NextFrame();
|
|
}
|
|
|
|
public LevelData GetLevelData()
|
|
{
|
|
return _levelData;
|
|
}
|
|
|
|
public LevelInfo GetLevelInfo()
|
|
{
|
|
return _currLevelInfo;
|
|
}
|
|
}
|
|
} |