protected AbstractCommonResourceLoadSystem(IContexts contexts, Queue <RemoveAssetStatus> oldResource)
 {
     _oldResource        = oldResource;
     _initializedGroup   = GetInitializedGroup(contexts);
     _uninitializedGroup = GetUninitializedGroup(contexts);
     _contexts           = contexts;
 }
        public ClientSessionStateMachine(IContexts contexts) :
            base(new ClientSessionStateMachineMonitor(contexts))
        {
            BackroundloadSettings defaultSettings = BackroundloadSettings.GetClientCurrentSettings();

            AddState(new LoadBaseConfigureState(contexts, EClientSessionStates.LoadConfig, EClientSessionStates.LoadSubResourceConfig)
                     .WithEnterAction(() => { BackroundloadSettings.SetCurrentSettings(BackroundloadSettings.LoadSettsings); })
                     );
            AddState(new LoadSubResourceConfigureState(contexts, EClientSessionStates.LoadSubResourceConfig, EClientSessionStates.RequestRoomInfo));
            AddState(new RequestRoomInfoState(contexts, EClientSessionStates.RequestRoomInfo, EClientSessionStates.PreloadResource));
            AddState(new ClientPreLoadState(contexts, EClientSessionStates.PreloadResource, EClientSessionStates.PreparingPlayer));
            AddState(new PreparingPlayerState(contexts, EClientSessionStates.PreparingPlayer, EClientSessionStates.LoadSceneMapConfig));
            AddState(new LoadSceneMapConfig(contexts, EClientSessionStates.LoadSceneMapConfig, EClientSessionStates.LoadOCConfig, false, false));
            AddState(new LoadOCConfigState(contexts, EClientSessionStates.LoadOCConfig, EClientSessionStates.InitUiModule));
            AddState(new InitUiModuleState(contexts, EClientSessionStates.InitUiModule, EClientSessionStates.RequestSnapshot));
            AddState(new WaitSnapshotState(contexts, EClientSessionStates.RequestSnapshot, EClientSessionStates.Running));
            AddState(new LoginSuccState(contexts, EClientSessionStates.Running, EClientSessionStates.Running)
                     .WithEnterAction(() =>
            {
                BackroundloadSettings.SetCurrentSettings(defaultSettings);
                if (SharedConfig.DisableGc)
                {
                    SingletonManager.Get <gc_manager>().disable_gc();
                    SingletonManager.Get <gc_manager>().gc_collect();
                }
            }).WithLevelAction(() =>
            {
                SingletonManager.Get <gc_manager>().enable_gc();
                SingletonManager.Get <gc_manager>().gc_collect();
            })
                     );

            Initialize((int)EClientSessionStates.LoadConfig);
        }
Example #3
0
        public ClientProfileSessionStateMachine(IContexts contexts) :
            base(new ClientSessionStateMachineMonitor(contexts))
        {
            AddState(new LoadBaseConfigureState(contexts, EClientSessionStates.LoadConfig, EClientSessionStates.RequestRoomInfo));

            if (SharedConfig.InSamplingMode)
            {
                AddState(new RequestRoomInfoState(contexts, EClientSessionStates.RequestRoomInfo, EClientSessionStates.ProfilePreparation));
                AddState(new ProfilePreparationState(contexts, EClientSessionStates.ProfilePreparation, EClientSessionStates.LoadOptionConfig));
                AddState(new ClientOptionLoadState(contexts, EClientSessionStates.LoadOptionConfig, EClientSessionStates.LoadSceneMapConfig));
                AddState(new LoadSceneMapConfig(contexts, EClientSessionStates.LoadSceneMapConfig, EClientSessionStates.Profile, true, false));
                AddState(new ProfileState(contexts, EClientSessionStates.Profile, EClientSessionStates.Profile));
            }
            else
            {
                AddState(new RequestRoomInfoState(contexts, EClientSessionStates.RequestRoomInfo, EClientSessionStates.PreparingPlayer));
                AddState(new PreparingPlayerState(contexts, EClientSessionStates.PreparingPlayer, EClientSessionStates.LoadSceneMapConfig));
                AddState(new LoadSceneMapConfig(contexts, EClientSessionStates.LoadSceneMapConfig, EClientSessionStates.InitUiModule, true, false));
                AddState(new InitUiModuleState(contexts, EClientSessionStates.InitUiModule, EClientSessionStates.RequestSnapshot));
                AddState(new WaitSnapshotState(contexts, EClientSessionStates.RequestSnapshot, EClientSessionStates.Running));
                AddState(new LoginSuccState(contexts, EClientSessionStates.Running, EClientSessionStates.Running));
            }

            Initialize((int)EClientSessionStates.LoadConfig);
        }
        public override Systems CreateUpdateSystems(IContexts contexts1)
        {
            var gameModule = new CompositeGameModule();
            var contexts   = contexts1 as Contexts;

            var loadSceneSystem = new InitialSceneLoadingSystem(this, contexts, null, true);

            loadSceneSystem.AsapMode = true;
            gameModule.AddSystem(loadSceneSystem);
            gameModule.AddSystem(new InitTriggerObjectManagerSystem(contexts));

            gameModule.AddSystem(new ServerScenePostprocessorSystem(contexts.session.commonSession));
            //gameModule.AddModule(new ResourcePreloadModule(this));

            var featrue = new ServerPrepareFeature("loadMapConfig", gameModule, contexts.session.commonSession.AssetManager);

            featrue.Add(new MapConfigInitModule(contexts, this));
            if (contexts.session.commonSession.RoomInfo.MapId == 2)
            {
                contexts.session.commonSession.InitPosition = new Vector3(1906, 20, -1964);
            }
            else
            {
                contexts.session.commonSession.InitPosition = Vector3.zero;
            }
            return(featrue);
        }
Example #5
0
        public override Systems CreateOnDrawGizmos(IContexts contexts)
        {
            Systems system = new Systems();

            system.Add(new GizmosRenderSystem(_gameModule));
            return(system);
        }
        public override Systems CreateOnGuiSystems(IContexts contexts)
        {
            Systems system = new Systems();

            system.Add(new OnGuiSystem(_gameModule));
            return(system);
        }
Example #7
0
        public override void DoEventClient(IContexts contexts, IEntity entity, IEvent e)
        {
            var          playerEntity       = entity as PlayerEntity;
            Contexts     c                  = contexts as Contexts;
            BeenHitEvent ev                 = e as BeenHitEvent;
            var          playerEntityTarget = c.player.GetEntityWithEntityKey(ev.Target);

            if (playerEntity != null)
            {
                //服务器下发的被击中者调用受击命令
                if (playerEntity.entityKey.Value == ev.Target && playerEntity.hasStateInterface)
                {
                    Logger.DebugFormat("self:{0}, invoke , CanBeenHit:{1}", ev.Target, playerEntity.stateInterface.State.CanBeenHit());

                    if (playerEntity.stateInterface.State.CanBeenHit())
                    {
                        playerEntity.stateInterface.State.BeenHit();
                    }
                }
                //自己预测击中的受击者命令,强制使受击者播放受击动画
                else
                {
                    if (playerEntityTarget != null && playerEntityTarget.hasOverrideNetworkAnimator)
                    {
                        Logger.DebugFormat("target:{0}, invoke , IsInjuryAnimatorActive", ev.Target, ev.TriggerTime);

                        playerEntityTarget.overrideNetworkAnimator.IsInjuryAnimatorActive = true;
                        playerEntityTarget.overrideNetworkAnimator.InjuryTriigerTime      = ev.TriggerTime;
                    }
                }
            }
        }
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;
            var      systems   = base.CreateUpdateSystems(contexts);

            systems.Add(new PreloadFeature("ServerPreLoadState", CreateSystems(_contexts), _contexts.session.commonSession));
            return(systems);
        }
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;
            var      systems   = new Feature("ClientOptionLoadState");

            systems.Add(new OptionConfigurationInitModule(this, _contexts.session.commonSession.AssetManager));
            return(systems);
        }
Example #10
0
 public HubController(ILogger <HubController> logger, IBackgroundJobClient backgroundJobClient, ISubscriptions subscriptions, INotifications <HttpResponseMessage> notifications, IContexts contexts)
 {
     this.backgroundJobClient = backgroundJobClient ?? throw new ArgumentNullException(nameof(backgroundJobClient));
     this.logger        = logger ?? throw new ArgumentNullException(nameof(logger));
     this.subscriptions = subscriptions ?? throw new ArgumentNullException(nameof(subscriptions));
     this.notifications = notifications ?? throw new ArgumentNullException(nameof(notifications));
     this.contexts      = contexts ?? throw new ArgumentNullException(nameof(contexts));
 }
Example #11
0
        public override Systems CreateUpdateSystems(IContexts contexts1)
        {
            var contexts          = contexts1 as Contexts;
            var sessionObjects    = contexts.session.commonSession;
            var entityIdGenerator = sessionObjects.EntityIdGenerator;


            _gameModule = new CompositeGameModule();

            _gameModule.AddModule(new ServerPlayerModule(contexts));
            _gameModule.AddModule(new ServerEntityInitModule(contexts));
            _gameModule.AddModule(new ServerBulletModule(contexts));

            IHitBoxEntityManager hitBoxEntityManager = new HitBoxEntityManager(contexts, true);
            var snapshotSelectorContainer            = contexts.session.serverSessionObjects.CompensationSnapshotSelector;
            ICompensationWorldFactory factory        =
                new ServerCompensationWorldFactory(snapshotSelectorContainer, hitBoxEntityManager);
            var serverDamageInfoCollector = new ServerDamageInfoCollector(contexts.player);

            _gameModule.AddModule(new UserCmdGameModule(contexts,
                                                        factory,
                                                        new BulletHitHandler(contexts,
                                                                             entityIdGenerator,
                                                                             room.PlayerDamager,
                                                                             serverDamageInfoCollector,
                                                                             contexts.session.entityFactoryObject.SoundEntityFactory,
                                                                             SingletonManager.Get <EnvironmentTypeConfigManager>()),
                                                        new MeleeHitHandler(contexts, room.PlayerDamager, entityIdGenerator,
                                                                            serverDamageInfoCollector, contexts.session.entityFactoryObject.SoundEntityFactory),
                                                        new ThrowingHitHandler(contexts, room.PlayerDamager),
                                                        sessionObjects,
                                                        MotorsFactory.CraeteMotors(contexts, SingletonManager.Get <CameraConfigManager>().Config)));
            _gameModule.AddModule(new ServerPostPredictionModule(contexts));
            _gameModule.AddModule(new ServerVehicleModule(contexts,
                                                          contexts.session.serverSessionObjects.VehicleTimer));
            _gameModule.AddModule(new ServerGamePlayModule(contexts, room));
            _gameModule.AddModule(
                new ServerSceneObjectModule(contexts, this, sessionObjects.EquipmentEntityIdGenerator));

            IUserCmdExecuteSystemHandler    userCmdExecuteSystemHandler    = new UserCmdExecuteSystemHandler(contexts);
            IVehicleCmdExecuteSystemHandler vehicleCmdExecuteSystemHandler =
                new ServerVehicleCmdExecuteSystemHandler(contexts);

            var systems = new Feature("GameSessionState");

            systems.Add(new PingSystem(contexts));
            systems.Add(new ServerMainFeature(
                            "ServerSystems",
                            _gameModule,
                            userCmdExecuteSystemHandler,
                            vehicleCmdExecuteSystemHandler,
                            contexts.session.serverSessionObjects.SimulationTimer,
                            new VehicleExecutionSelector(contexts),
                            sessionObjects,
                            room));

            return(systems);
        }
        public void Update(List <IGameEntity> preEntitys, IContexts _newContexts)
        {
            try
            {
                _contexts = _newContexts;

                _removeList.Clear();

                // _preEntitys_HashSet 进行填充,用于在 Add 函数中判断 是否加入的entity是 上次残留的对象
                _preEntitys_HashSet.Clear();
                foreach (var entity in preEntitys)
                {
                    _preEntitys_HashSet.Add(entity.EntityKey);
                }

                // 获取 _gameContexts
                if (_gameContexts == null)
                {
                    _gameContexts = (_newContexts as Contexts).session.commonSession.GameContexts;
                }

                // 遍历残留字典
                foreach (var keyValue in _dict)
                {
                    var entityKey = keyValue.Key;

                    IGameEntity entity = null;
                    //---------------------------------------------------
                    // 找不到entityKey对应的entity,就标记去除
                    if (!_gameContexts.TryGetGameEntity(entityKey, out entity))
                    {
                        _removeList.Add(entityKey);
                        continue;
                    }

                    //---------------------------------------------------
                    // 不符合条件的就标记去除
                    if (!keyValue.Value.CanStay(_contexts))
                    {
                        _removeList.Add(entityKey);
                        continue;
                    }
                    //---------------------------------------------------

                    preEntitys.Add(entity);
                }

                // -----清除被标记的key-------------------------------
                foreach (var entityKey in _removeList)
                {
                    _dict.Remove(entityKey);
                }
            }
            catch (Exception e)
            {
                _logger.ErrorFormat("当前线程为 {0},异常为:{1}", System.Threading.Thread.CurrentThread.Name, e.Message + "\n" + e.StackTrace);
            }
        }
Example #13
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            var systems       = new Feature("PreLoadingState");
            var contextsImpl  = contexts as Contexts;
            var commonSession = contextsImpl.session.commonSession;

            systems.Add(new ResourceLoadSystem(new PreLoadModule(this, contexts), commonSession.AssetManager));
            return(systems);
        }
Example #14
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;
            var      systems   = new Feature("ClientPreLoadState");

            systems.Add(new PreloadFeature("ClientPreLoadState", CreateSystems(_contexts, this), _contexts.session.commonSession));

            return(systems);
        }
        protected override void InitComponent(PlayerEntity player, IContexts contexts)
        {
            var character = DefaultGo.CreateGameObject(player.entityKey.ToString());

            character.layer = UnityLayerManager.GetLayerIndex(EUnityLayerName.Player);
            var cc  = PlayerEntityUtility.InitCharacterController(character);
            var kcc = PlayerEntityUtility.InitKinematicCharacterMotor(character);
            var characterControllerContext = new CharacterControllerContext(
                new UnityCharacterController(cc, ModelLoadHandler.InitActionWithOffset(), !player.isFlagSelf),
                new ProneCharacterController(kcc,
                                             new ProneController(), ModelLoadHandler.InitActionWithNoOffset()),
                new DiveCharacterController(kcc,
                                            new DiveController(), ModelLoadHandler.InitActionWithNoOffset()),
                new SwimCharacterController(kcc,
                                            new SwimController(), ModelLoadHandler.InitActionWithNoOffset())
                );


            var curver = character.AddComponent <AirMoveCurve>();

            curver.AireMoveCurve = SingletonManager.Get <CharacterStateConfigManager>().AirMoveCurve;

            character.AddComponent <EntityReference>();
            character.GetComponent <EntityReference>().Init(player.entityAdapter);
            var comp = character.AddComponent <PlayerVehicleCollision>();

            comp.AllContext = contexts as Contexts;

            var appearanceManager = new AppearanceManager();


            var characterControllerManager = new CharacterControllerManager();

            characterControllerManager.SetCharacterController(characterControllerContext);


            var characterBone = new CharacterBoneManager();

            characterBone.SetWardrobeController(appearanceManager.GetWardrobeController());
            characterBone.SetWeaponController(appearanceManager.GetController <NewWeaponController>());
            var weaponController = (NewWeaponController)appearanceManager.GetController <NewWeaponController>();

            if (null != weaponController)
            {
                weaponController.SetWeaponChangedCallBack(characterBone.CurrentP1WeaponChanged, characterBone.CurrentP3WeaponChanged);
                weaponController.SetWeaponOrAttachmentDeleteCallBack(characterBone.WeaponOrAttachmentDel);
                weaponController.SetWeaponOrAttachementAddCallBack(characterBone.WeaponOrAttachmentAdd);
                weaponController.SetCacheChangeAction(characterBone.CacheChangeCacheAction);
            }
            player.AddCharacterControllerInterface(characterControllerManager);
            player.AddAppearanceInterface(appearanceManager);
            player.AddCharacterContoller(characterControllerContext);
            player.AddCharacterBoneInterface(characterBone);
            player.AddPlayerGameState(PlayerLifeStateEnum.NullState);
            player.AddPlayerResource(character);
        }
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;

            var systems = new Entitas.Systems();

            systems.Add(new RequestSnapshotSystem(_contexts, this));

            return(systems);
        }
Example #17
0
        public ProfilePreparationState(IContexts contexts, EClientSessionStates state, EClientSessionStates next) : base(contexts, (int)state, (int)next)
        {
            Contexts ctx    = (Contexts)contexts;
            var      player = ctx.player.CreateEntity();

            player.isFlagSelf = true;
            player.AddPosition();
            player.AddOrientation(0, 0, 0, 0, 0);
            player.AddCameraObj();
        }
Example #18
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;

            var systems = new Feature("ProfilePreparationState");

            systems.Add(new ProfilePreparationFeature("ProfilePreparationState", CreateSystems(_contexts), _contexts.session.commonSession));

            return(systems);
        }
        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);
        }
Example #20
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            var systems       = new Feature("MapLoadState");
            var contextsImpl  = contexts as Contexts;
            var commonSession = contextsImpl.session.commonSession;

            systems.Add(new SceneResourceLoadingFeature("SceneResourceLoading", CreateSystems(contextsImpl),
                                                        commonSession));
            return(systems);
        }
Example #21
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;

            var systems = base.CreateUpdateSystems(contexts);

            systems.Add(new PreloadFeature("ClientPreLoadState", CreateSystems(_contexts, this), _contexts.session.commonSession));
            systems.Add(new BaseConfigurationInitModule(this, _contexts.session.commonSession.AssetManager));
            return(systems);
        }
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;

            var systems = new Entitas.Systems();

            systems.Add(new RequestSceneInfoSystem(_contexts, this));
            /*MakeWeaponLogicManager(_contexts);*/
            return(systems);
        }
Example #23
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;
            var      systems   = new Feature("PreparingPlayer");

            systems.Add(new RequestPlayerInfoSystem(_contexts, this));
            systems.Add(new ClientPreparePlayerMainFeature("MainFeature", GameModuleFactory.CreatePreparePlayerGameModule(_contexts), _contexts.session.commonSession));
            systems.Add(new CheckPreparingPlayerSystem(_contexts, this));
            systems.Add(new ResourceLoadSystem(new PreLoadModule(this, contexts), _contexts.session.commonSession.AssetManager));
            return(systems);
        }
 public override void DoEventServer(IContexts contexts, IEntity entity, IEvent e)
 {
     (entity as PlayerEntity).StatisticsController().HandleDispatchedEvt(e as StatisticsHitPlayerEvent, true);
     // var playerEntity = entity as PlayerEntity;
     // if (playerEntity != null)
     // {
     //     var v = EventInfos.Instance.Allocate(e.EventType, true);
     //     v.RewindTo(e);
     //     playerEntity.remoteEvents.Events.AddEvent(v);
     // }
 }
Example #25
0
        public override Systems CreateUpdateSystems(IContexts contexts1)
        {
            var gameModule = new CompositeGameModule();
            var contexts   = contexts1 as Contexts;

            gameModule.AddModule(new ServerInitModule(contexts, this));
            gameModule.AddModule(new SubResourceConfigurationInitModule(this));

            var featrue = new ServerPrepareFeature("loadSubResourceConfig", gameModule, contexts.session.commonSession.AssetManager);

            return(featrue);
        }
        public static void ObserveAll(IContexts contexts)
        {
            if (!Application.isPlaying || !Application.isEditor)
            {
                return;
            }

            foreach (var c in contexts.allContexts)
            {
                Observe(c);
            }
        }
Example #27
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            if (Camera.main == null)
            {
                throw new Exception("Camera.main is null");
            }
            Contexts _contexts = (Contexts)contexts;

            _gameModule = GameModuleFactory.CreateCompositeGameModule(_contexts);
            var sessionObjects = _contexts.session.clientSessionObjects;

            ISyncLatestManager     syncLatestManager     = sessionObjects.SyncLatestManager;
            IPlaybackManager       playbackManager       = sessionObjects.PlaybackManager;
            IPredictionInitManager predictionInitManager = sessionObjects.UserPredictionInitManager;

            IUserPredictionInfoProvider predicatoinInfoProvider = sessionObjects.UserPredictionInfoProvider;
            ISimulationTimer            simulationTimer         = sessionObjects.SimulationTimer;

            var systems = new Feature("LoginSuccState");

            systems.Add(new InputCollectSystem(_contexts).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            systems.Add(new MouseLockSystem(_contexts));
            systems.Add(new DriveTimeSystem(_contexts).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            systems.Add(new ClientFreeCmdGenerateSystem(_contexts).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            systems.Add(new UserCmdCollectSystem(_contexts).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            //  systems.Add(new ClientCameraPreUpdateSystem(_contexts.vehicle, _contexts.freeMove,_contexts.player, motors).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            systems.Add(new PlayerInterceptCmdSystem(_contexts).WithExecFrameStep(EEcecuteStep.NormalFrameStep));
            systems.Add(new UserCmdMergeSystem(_contexts).WithExecFrameStep(EEcecuteStep.CmdFrameStep));

            //Test
            systems.Add(new TerrainTestSystem(_contexts));
            //////
            systems.Add(new AutoTerrainNavigatorSystem(_contexts));
            systems.Add(new MinRendererSetSystem(_contexts));
            systems.Add(new WoodConflictSystem(_contexts));
            systems.Add(new ClientMainFeature(
                            "LoginSuccSystems",
                            _gameModule,
                            syncLatestManager,
                            playbackManager,
                            predictionInitManager,
                            predicatoinInfoProvider,
                            simulationTimer,
                            sessionObjects.VehicleCmdExecuteSystemHandler,
                            new ClientVehicleExecutionSelector(_contexts),
                            _contexts.session.commonSession));
            /*车辆命令走老流程*/
            systems.Add(new UserCmdSendSystem(_contexts).WithExecFrameStep(EEcecuteStep.CmdFrameStep));
            /*用户的命令*/
            systems.Add(new UserCmdUpdateSystem(_contexts).WithExecFrameStep(EEcecuteStep.CmdFrameStep));
            return(systems);
        }
        /// <summary>
        /// Setup contexts to use visual debugging.
        /// </summary>
        public static void EnableVisualDebugging(this IContexts contexts)
        {
            // This moves the registration of visual debugging outside the Context so that games
            // using both Unity projects and external systems at the same time (such as WPF)
            // can optionally exclude debugging support and operate on the same project.
            // (external projects need to exclude unity specific code because it throws exceptions
            // whenever it accesses the C++ side of unity engine).

            for (int i = 0; i < contexts.allContexts.Length; i++)
            {
                SetupVisualDebugging(contexts.allContexts[i]);
            }
        }
Example #29
0
        /// <summary>
        /// </summary>
        /// <param name="contexts"></param>
        /// <param name="entity"></param>
        /// <param name="e"></param>
        public override void DoEventClient(IContexts contexts, IEntity entity, IEvent e)
        {
            FireEvent evt = e as FireEvent;

            if (evt != null)
            {
                var effectCfg =
                    SingletonManager.Get <WeaponConfigManagement>().FindConfigById(evt.weaponId)
                    .S_EffectConfig as DefaultWeaponEffectConfig;
                if (effectCfg == null)
                {
                    return;
                }
                Contexts     ctx    = contexts as Contexts;
                PlayerEntity player = ctx.player.GetEntityWithEntityKey(evt.owner);
                if (evt.fireEffectType != FireEvent.FireEffectType.EnjectOnly)
                {
                    var muzzleTrans = player.characterBoneInterface.CharacterBone.GetLocation(SpecialLocation.MuzzleEffectPosition, CharacterView.ThirdPerson);
                    if (muzzleTrans)
                    {
                        ClientEffectFactory.CreateMuzzleSparkEffct(muzzleTrans.position,
                                                                   evt.pitch, evt.yaw, effectCfg.Spark, muzzleTrans);
                    }
                }

                if (evt.fireEffectType != FireEvent.FireEffectType.MuzzleOnly)
                {
                    var ejectTrans = player.characterBoneInterface.CharacterBone.GetLocation(SpecialLocation.EjectionLocation, CharacterView.ThirdPerson);
                    if (ejectTrans)
                    {
                        ClientEffectFactory.CreateBulletDrop(ejectTrans.position,
                                                             evt.yaw, evt.pitch, effectCfg.BulletDrop, evt.weaponId, AudioGrp_FootMatType.Concrete);
                    }
                }



                // var weaponGo = (entity as PlayerEntity).appearanceInterface.Appearance.GetWeaponP1InHand();
                //        GameAudioMedia.PlayWeaponFireAudio(evt.fireWeaponId, evt.audioFirePos, (AudioGrp_ShotMode)evt.audioFireMode);
            }

            // GameAudioMedium.ProcessWeaponAudio(playerEntity,allContexts,(item)=>item.Fire);
            // if (playerEntity.appearanceInterface.Appearance.IsFirstPerson)
            // {

            // }
            // else
            // {
            ////     GameAudioMedium.PerformOnGunFire();
            // }
        }
Example #30
0
        public override Systems CreateUpdateSystems(IContexts contexts)
        {
            Contexts _contexts = (Contexts)contexts;

            //SingletonManager.Get<MapConfigManager>().SetCurrentMap(_contexts.session.clientSessionObjects.MapId);

            _gameModule = CreateCompositeGameModule(_contexts);
            var systems = new Entitas.Systems();

            systems.Add(new ClientPreLoginFeature(
                            "PreLoginState",
                            _gameModule,
                            _contexts.session.commonSession
                            ));
            return(systems);
        }