public void Load(IUnityAssetManager assetManager)
{
foreach (var assetInfo in _assetInfos)
{
assetManager.LoadAssetAsync("BatchLoadHandler", assetInfo, OnLoadSucc, new AssetLoadOption(dontAutoActive: true));
}
}
public LocalizeSessionSystem(ISessionState sessionState, IUnityAssetManager assetManager)
{
_sessionState = sessionState;
_assetManager = assetManager;
sessionState.CreateExitCondition(typeof(LocalizeSessionSystem));
assetManager.LoadAssetAsync("", new AssetInfo(ASSETBUNDLENAME, ASSETNAME), OnLoadSucc);
}
public void OnInitModule(IUnityAssetManager assetManager)
{
var cmdGenerator = _contexts.session.clientSessionObjects.UserCmdGenerator as UnityUserCmdGenerator;
if (null != cmdGenerator)
{
var mode = _contexts.session.commonSession.RoomInfo.ModeId;
#if UNITY_EDITOR
if (mode == 0)
{
mode = SharedConfig.ModeId;
}
#endif
var bagType = SingletonManager.Get <GameModeConfigManager>().GetBagTypeById(mode);
IGlobalKeyInputMapper inputMapper = null;
switch (bagType)
{
case XmlConfig.EBagType.Group:
inputMapper = new GroupModeInputMapper(_contexts);
break;
default:
inputMapper = new DefaultModeInputMapper();
break;
}
cmdGenerator.RegisterGlobalKeyhandler(inputMapper);
cmdGenerator.BeginReceiveUserInput(_contexts.userInput.userInputManager.Instance);
}
}
public override void OnLoadResources(IUnityAssetManager assetManager)
{
base.OnLoadResources(assetManager);
foreach (var entity in _player.GetEntities())
{
if (!entity.hasAppearanceInterface)
{
continue;
}
var loadRequests = entity.appearanceInterface.Appearance.GetLoadRequests();
if (loadRequests.Count > 0)
{
var call = _assetsAsyncCallPool.Get();
call.CreateCallFuncMapping(entity, loadRequests);
CreateAssetInfos(loadRequests);
assetManager.LoadAssetsAsync(entity, _assetInfos,
call.CallFunc);
}
var recycleRequests = entity.appearanceInterface.Appearance.GetRecycleRequests();
foreach (var request in recycleRequests)
{
entity.RemoveAsset(request);
assetManager.Recycle(request);
}
entity.appearanceInterface.Appearance.ClearRequests();
}
}
public OptionConfigurationInitModule(ISessionCondition sessionState, IUnityAssetManager assetManager)
{
_assetManager = assetManager;
var allMaps = SingletonManager.Get <MapsDescription>();
if (allMaps.CurrentLevelType != LevelType.BigMap)
{
return;
}
SceneConfig config = allMaps.BigMapParameters;
string preStr = config.PreMapName;
int gridNum = config.TerrainDimension;
StreamingLevelStructure streamingLevel = SingletonManager.Get <StreamingLevelStructure>();
ScenesLightmapStructure lightmap = SingletonManager.Get <ScenesLightmapStructure>();
ScenesIndoorCullStructure indoor = SingletonManager.Get <ScenesIndoorCullStructure>();
streamingLevel.Clear();
lightmap.Clear();
indoor.Clear();
for (int i = 0; i < gridNum; i++)
{
for (int j = 0; j < gridNum; j++)
{
string preName = preStr + "_" + preStr + " " + i + "x" + j;
AddConfigSystem <StreamingLevelStructure>(sessionState, preName + StreamingConfig.DataXMLName, StreamingConfig.StreamingABPath + preStr + StreamingConfig.StreamingDataABName, streamingLevel);
AddConfigSystem <ScenesLightmapStructure>(sessionState, preName + StreamingConfig.LightXMLName, StreamingConfig.StreamingABPath + preStr + StreamingConfig.StreamingLightDataABName, lightmap);
AddConfigSystem <ScenesIndoorCullStructure>(sessionState, preName + StreamingConfig.InDoorXMLName, StreamingConfig.StreamingABPath + preStr + StreamingConfig.StreamingInDoorABName, indoor);
}
}
_sessionState = sessionState;
}
public override void OnLoadResources(IUnityAssetManager assetManager)
{
base.OnLoadResources(assetManager);
foreach (var entity in _player.GetEntities())
{
ChangeRoleByGamePlayData(entity);
ChangeRoleByCmd(entity);
AssetLoadSuccess(entity);
// 狂暴技能 临时代码
if (!entity.isFlagSelf || !entity.hasPlayerInfo || entity.playerInfo.RoleModelId != 100)
{
continue;
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
entity.stateInterface.State.RageStart();
entity.appearanceInterface.Appearance.ChangeAvatar(390);
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
entity.stateInterface.State.RageEnd();
entity.appearanceInterface.Appearance.ChangeAvatar(389);
}
//////////////////////
}
}
public virtual void Recycle(IUnityAssetManager assetManager)
{
if (UnityObject != null)
{
assetManager.Recycle(UnityObject);
}
}
public ServerRoomFactory(RoomEventDispatcher dispatcher, ICoRoutineManager coRoutineManager, IUnityAssetManager assetMananger)
{
_dispatcher = dispatcher;
_coRouitneManager = coRoutineManager;
_assetMananger = assetMananger;
_contexts = new Contexts();
}
public ContextsServerWrapper(Contexts contexts, IUnityAssetManager assetManager, ICoRoutineManager coRoutineManager)
{
var ruleId = RuleMap.GetRuleId(SingletonManager.Get <ServerFileSystemConfigManager>().BootConfig.Rule);
this.contexts = contexts;
#if (!ENTITASDISABLEVISUALDEBUGGING && UNITYEDITOR)
this.contexts.InitializeContexObservers();
#endif
SingletonManager.Get <MyProfilerManager>().Contexts = contexts;
IBin2DManager bin2DManager = CreateBin2DManager();
IniCurrentTimeSession();
var entityIdGenerator = new EntityIdGenerator(EntityIdGenerator.GlobalBaseId);
var equipmentEntityIdGenerator = new EntityIdGenerator(EntityIdGenerator.EquipmentBaseId);
InitEntityFactorySession(entityIdGenerator, equipmentEntityIdGenerator);
InitCommonSession(bin2DManager, entityIdGenerator, equipmentEntityIdGenerator, ruleId, assetManager,
coRoutineManager);
InitServerSession(bin2DManager, ruleId);
contexts.vehicle.SetSimulationTime(0);
InitialWeaponSkill();
}
public override void OnLoadResources(IUnityAssetManager assetManager)
{
base.OnLoadResources(assetManager);
foreach (var entity in _player.GetEntities())
{
if (entity.hasAppearanceInterface)
{
var loadRequests = entity.appearanceInterface.Appearance.GetLoadRequests();
foreach (var request in loadRequests)
{
var intercept = _interceptPool.Get();
intercept.SetParam(entity, request.GetHandler <PlayerEntity>());
assetManager.LoadAssetAsync(entity, request.AssetInfo, intercept.Call);
}
var recycleRequests = entity.appearanceInterface.Appearance.GetRecycleRequests();
foreach (var request in recycleRequests)
{
entity.RemoveAsset(request);
assetManager.Recycle(request);
}
entity.appearanceInterface.Appearance.ClearRequests();
}
}
}
private void RequestForResource(IUnityAssetManager assetManager)
{
_levelManager.GetRequests(_sceneRequests, _goRequests, _lightmapsRequests);
foreach (var request in _sceneRequests)
{
assetManager.LoadSceneAsync(request, true);
}
foreach (var request in _goRequests)
{
_levelManager.LoadResource("InitialSceneLoadingSystem", assetManager, request);
}
foreach (var request in _lightmapsRequests)
{
MeshRenderer mr = null;
List <AssetInfo> infos = new List <AssetInfo>();
foreach (var ex in request)
{
infos.Add(ex.asset);
if (mr == null)
{
mr = ex.data;
}
}
assetManager.LoadAssetsAsync(mr, infos, _levelManager.LightmapsLoadedWrapper);
}
_sceneRequests.Clear();
_goRequests.Clear();
_lightmapsRequests.Clear();
}
public LevelManager(IUnityAssetManager assetManager)
{
_assetManager = assetManager;
SceneManager.sceneLoaded += SceneLoadedWrapper;
SceneManager.sceneUnloaded += SceneUnloadedWrapper;
}
// private static readonly AssetInfo GroundProbFlashAsset = new AssetInfo("effect/common", "GroundPropFlash");
public SceneObjectLoadSystem(Contexts contexts, ICommonSessionObjects sessionObjects) : base(
contexts.sceneObject)
{
_assetManager = sessionObjects.AssetManager;
_playerContext = contexts.player;
_simpleLoadHandler = new SimpleLoadRespondHander(contexts);
_weaponLoadHandler = new LoadWeaponRespondHandler(contexts);
}
public ServerMain(ICoRoutineManager coRoutineManager, IUnityAssetManager assetManager,
IRoomListener roomListener)
{
_coRoutineManager = coRoutineManager;
_assetManager = assetManager;
_roomListener = roomListener;
_baseConfigInitModule = new BaseConfigurationInitModule(_initState, _assetManager);
}
public void OnInitModule(IUnityAssetManager assetManager)
{
if (_renderer.IsReady)
{
_commonSession.LevelManager.SceneLoaded += _clientSession.TerrainRenderer.SceneLoaded;
_commonSession.LevelManager.SceneUnloaded += _clientSession.TerrainRenderer.SceneUnloaded;
}
}
public void Update(IUnityAssetManager assetManager)
{
_loadRequestManager = assetManager;
ProcessInitializedEntitys(assetManager);
ProcessUnInitializedEntitys(assetManager);
ProcessOldResources(_oldResource, assetManager);
}
public void LoadSubResources(IUnityAssetManager assetManager, OnSubResourcesHandled handledCallback)
{
_assetManager = assetManager;
_handledCallback = handledCallback;
if (!LoadSubResourcesImpl())
{
_handledCallback();
}
}
public void OnInitModule(IUnityAssetManager assetManager)
{
var player = _contexts.player.flagSelfEntity;
_contexts.session.clientSessionObjects.UserPredictionInitManager.RewindFirstSnapshot(player.entityKey.Value);
_logger.InfoFormat("RewindFirstSnapshotInitSystem:{0}", player.position.Value);
player.RootGo().transform.SetPositionAndRotation(player.position.Value, player.orientation.ModelView);
}
public void LoadAllGlobalEffect(IUnityAssetManager assetManager, Action allLoadSucc)
{
foreach (var kv in _assetBundles)
{
assetManager.LoadAssetAsync(kv.Key, kv.Value, OnLoadSucc);
}
_allLoadSucc = allLoadSucc;
}
public ServerPrepareFeature(string name,
IGameModule topLevelGameModule, IUnityAssetManager assetManager) : base(name)
{
topLevelGameModule.Init();
Add(new ModuleInitSystem(topLevelGameModule, assetManager));
Add(new EntityCreateSystem(topLevelGameModule));
Add(new ResourceLoadSystem(topLevelGameModule, assetManager));
}
public override void Recycle(IUnityAssetManager assetManager)
{
if (Controller != null)
{
Controller.ResetGameObject(typeof(VehicleMaterialLoader), false);
}
base.Recycle(assetManager);
}
public void LoadTerrain(IUnityAssetManager assetManager, AbstractMapConfig sceneConfig)
{
if (!_dictTerrains.ContainsKey(sceneConfig.Id))
{
MyTerrain terrain = new MyTerrain(assetManager, sceneConfig);
terrain.LoadAll();
AddTerrain(terrain);
}
SetTerrainData();
}
private void ProcessUnInitializedEntitys(IUnityAssetManager assetManager)
{
var entities = _initializedGroup.GetEntities();
for (var i = 0; i < entities.Length; i++)
{
var entity = entities[i];
InitComponent(entity, _contexts);
}
}
public virtual void Recycle(IUnityAssetManager assetManager)
{
foreach (var asset in LoadedAssets)
{
if (asset.Value != null)
{
assetManager.Recycle(asset.Value);
}
}
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
RequestForResource(assetManager);
if (_levelManager.NotFinishedRequests <= 0)
{
_levelManager.SetAsapMode(AsapMode);
_sessionState.FullfillExitCondition(typeof(InitialSceneLoadingSystem));
}
}
public ClientSessionStateProgress(IContexts contexts)
{
_contexts = contexts as Contexts;
UiCommon.InitUI(UiRootName);
_assetManager = _contexts.session.commonSession.AssetManager;
_assetManager.LoadAssetAsync(GetType().ToString(), new AssetInfo(LoadingUiBundleName, LoadingUiAssetName), OnLoadSucc);
}
public ClientContextInitilizer(IUserCmdGenerator userCmdGenerator,
ICoRoutineManager coRoutineManager,
IUnityAssetManager assetManager,
string loginToken)
{
_userCmdGenerator = userCmdGenerator;
_coRoutineManager = coRoutineManager;
_loginToken = loginToken;
_assetManager = assetManager;
}
public void Recycle(IUnityAssetManager assetManager)
{
foreach (var unityObject in _unityObjects.Values)
{
assetManager.Recycle(unityObject);
}
_unityObjects.Clear();
_effects.Clear();
_globalEffects.Clear();
}
public void OnLoadResources(IUnityAssetManager assetManager)
{
if (Reload)
{
foreach (var cfg in _configs)
{
assetManager.LoadAssetAsync("ConfigReloadSystem", new AssetInfo("tables", cfg.Asset), OnLoadSucc);
}
Reload = false;
}
}
public override void OnLoadResources(IUnityAssetManager assetManager)
{
base.OnLoadResources(assetManager);
foreach (var entity in _player.GetEntities())
{
ChangeRoleByGamePlayData(entity);
ChangeRoleByCmd(entity);
AssetLoadSuccess(entity);
}
}
