public static void Start(GUnit unit, int id, Vector3 param, bool sync = true) { var stateProcessData = unit.GetData <ObjectStateProcessData>(); var stateData = ObjectStateDataDict.Get(unit, id); if (!stateData.objectState.CanStart(unit, stateProcessData, stateData, param)) { return; } if (sync && unit.GetData <ObjectSyncData>() == null) { sync = false; } if (sync) { ObjectSyncServer.AddState(unit, id, param, ObjectStateType.Start); } else { stateData.param = param; Start(stateProcessData, stateData); } }
protected override void OnAdd(GUnit unit) { var unitData = unit.GetData <UnitData>(); var paramData = unit.GetData <PanelParamData>(); var panelData = unit.GetData <PanelData>(); paramData.stateTypeProperty.Subscribe(state => { if (state == PanelStateType.Preload) { var taskData = DataPool.Get <TaskData>(); OnPreload(unit, taskData.taskList); TaskModule.Start(taskData, () => { DataPool.Release(taskData); UIProcess.ShowImmediate(paramData.assetPath); }); } else if (state == PanelStateType.Show) { Show(unit, panelData, paramData); } else if (state == PanelStateType.Hide) { Hide(unit, panelData); } }).AddTo(unitData.disposable); Init(unit, panelData); }
protected override void OnStop(GUnit unit, ObjectStateData stateData) { var moveParamData = unit.GetData <ObjectMoveParamData>(); moveParamData.moveDispose?.Dispose(); moveParamData.moveDispose = null; var assetData = unit.GetData <AssetData>(); var animator = assetData.GetComponent <Animator>(); animator.SetBool(ObjectTestConstant.ANIMATOR_PARAM_MOVE, false); }
protected override void OnAdd(GUnit unit) { var unitData = unit.GetData <UnitData>(); var objectSyncData = unit.GetData <ObjectSyncData>(); objectSyncData.stateSyncInfoList.ObserveAdd().Subscribe(_ => { if (objectSyncData.checkSyncDispose != null) { return; } objectSyncData.checkSyncDispose = ObjectSyncServer.EverySyncUpdate().Subscribe(frameInfo => { if (objectSyncData.stateSyncInfoList.Count == 0) { objectSyncData.checkSyncDispose.Dispose(); objectSyncData.checkSyncDispose = null; return; } var stateSyncInfoList = objectSyncData.stateSyncInfoList; for (var i = 0; i < stateSyncInfoList.Count;) { var syncInfo = objectSyncData.stateSyncInfoList[i]; #if DEBUG if (syncInfo.serverKeyFrame < frameInfo.Item1 || (syncInfo.serverKeyFrame == frameInfo.Item1 && syncInfo.internalFrame < frameInfo.Item2)) { Log.W("Sync {0} state {1} {2} failed!", syncInfo.stateType, syncInfo.stateId, syncInfo.stateParam); objectSyncData.stateSyncInfoList.RemoveAt(i); return; } #endif if (syncInfo.serverKeyFrame == frameInfo.Item1 && syncInfo.internalFrame == frameInfo.Item2) { DoState(unit, syncInfo); objectSyncData.stateSyncInfoList.RemoveAt(i); } else { i++; } } }); }).AddTo(unitData.disposable); }
public void Init(GUnit unit, ObjectStateData stateData) { var unitData = unit.GetData <UnitData>(); stateData.stateTypeProperty.Subscribe(_ => { if (_ == ObjectStateType.Start) { OnStart(unit, stateData); } else if (_ == ObjectStateType.Stop) { OnStop(unit, stateData); } else if (_ == ObjectStateType.Finish) { OnFinish(unit, stateData); stateData.stateTypeProperty.Value = ObjectStateType.None; } }).AddTo(unitData.disposable); OnInit(unit, stateData); var independentStateData = stateData as IndependentObjectStateData; if (independentStateData != null && independentStateData.isDefault) { ObjectStateProcess.Start(unit, independentStateData.id, independentStateData.param, false); } }
protected override bool OnFinish(GUnit unit, ObjectSlowDownBuffData buffData) { var moveSpeedData = unit.GetData <ObjectMoveSpeedData>(); moveSpeedData.basePercent += buffData.value; return(true); }
protected override void OnStop(GUnit unit, ObjectStateData stateData) { var assetData = unit.GetData <AssetData>(); var animator = assetData.GetComponent <Animator>(); animator.SetBool(ObjectTestConstant.ANIMATOR_PARAM_IDLE, false); }
protected override void OnInit(GUnit unit) { var uiTestPanelData = unit.GetData <PanelData>() as UITestPanelData; uiTestPanelData.showSimpleTipsPanelButton.onClick.RemoveAllListeners(); uiTestPanelData.showSimpleTipsPanelButton.onClick.AddListener(ShowSimpleTipsPanel); }
protected override void OnAdd(GUnit unit) { _syncData = unit.GetData <ObjectSyncServerData>(); var systemData = unit.GetData <SystemData>(); var unitData = unit.GetData <UnitData>(); IDisposable preparedDispose = null; IDisposable updateDispose = null; _syncData.enable.Subscribe(_ => { if (_) { updateDispose = GameSystem.ObserveEveryUpdate().Subscribe(time => { var currentInternalFrame = _syncData.internalFrame + 1; if (currentInternalFrame >= _syncData.internalFrameSize) { currentInternalFrame = 0; _syncData.currentKeyFrame += _syncData.currentKeyFrame > _syncData.serverKeyFrame ? 0 : 1; } var currentFrame = _syncData.currentKeyFrame * _syncData.internalFrameSize + currentInternalFrame; if (currentFrame > systemData.serverFrame) { systemData.serverFrame = currentFrame; _syncData.syncSubject.OnNext(ValueTuple.Create(_syncData.currentKeyFrame, currentInternalFrame)); _syncData.internalFrame = currentInternalFrame; } }); preparedDispose = _syncData.preparedSyncInfoList.ObserveAdd().Subscribe(stateInfo => { SyncObjectState(); }); } else { updateDispose?.Dispose(); updateDispose = null; preparedDispose?.Dispose(); preparedDispose = null; } }).AddTo(unitData.disposable); }
protected override void OnShow(GUnit unit, PanelData panel, params object[] args) { base.OnShow(unit, panel, args); var simpleTipsPanelData = unit.GetData <PanelData>() as SimpleTipsPanelData; simpleTipsPanelData.message.text = (string)args[0] ?? string.Empty; }
protected override void OnAdd(GUnit unit) { _attackServerData = unit.GetData <ObjectAttackServerData>(); _attackServerData.onAttack = new Subject <AttackInfo>(); _attackServerData.onBeforeDamage = new Subject <DamageInfo>(); _attackServerData.onDamage = new Subject <DamageInfo>(); _attackServerData.onAfterDamage = new Subject <DamageInfo>(); }
protected override void OnAdd(GUnit unit) { var assetData = unit.GetData <AssetData>(); var unitData = unit.GetData <UnitData>(); assetData.gameObject.OnTriggerEnter2DAsObservable().Subscribe(collider => { var colliderAssetData = collider.GetComponent <AssetData>(); if (colliderAssetData != null && colliderAssetData.unitId != 0) { var colliderUnit = WorldManager.Instance.Unit.GetUnit(colliderAssetData.unitId); var slowDownBuffData = Pool.Get <ObjectSlowDownBuffData>(); slowDownBuffData.value = 0.5f; slowDownBuffData.duration = 2f; ObjectBuffProcess.AddBuff(colliderUnit, slowDownBuffData); } }).AddTo(unitData.disposable); }
protected override void OnRemove(GUnit unit) { var processData = unit.GetData <ObjectBuffProcessData>(); foreach (var buffData in processData.currentBuffDataList) { RemoveBuff(unit, buffData, false); } processData.currentBuffDataList.Clear(); }
protected override void OnStart(GUnit unit, ObjectStateData stateData) { var moveSpeedData = unit.GetData <ObjectMoveSpeedData>(); var assetData = unit.GetData <AssetData>(); var animator = assetData.GetComponent <Animator>(); var rigidbody = assetData.GetComponent <Rigidbody2D>(); animator.SetBool(ObjectTestConstant.ANIMATOR_PARAM_MOVE, true); var moveParamData = unit.GetData <ObjectMoveParamData>(); moveParamData.moveDispose = ObjectSyncServer.EverySyncUpdate().Subscribe(_ => { var deltaX = stateData.param.x * moveSpeedData.allValue * ObjectTestConstant.OBJECTTEST_FIXED_MSECOND; deltaX /= ObjectTestConstant.MSECOND_TO_SECOND * ObjectTestConstant.MSECOND_TO_SECOND; _movePosition.x = deltaX; rigidbody.MovePosition(rigidbody.position + _movePosition); }); }
protected override void OnAdd(GUnit unit) { var unitData = unit.GetData <UnitData>(); _syncData = unit.GetData <ObjectSyncServerData>(); IDisposable updateServerKeyFrameDispose = null; _syncData.enable.Subscribe(_ => { if (_) { updateServerKeyFrameDispose = Observable.Interval(TimeSpan.FromMilliseconds(100)).Subscribe(time => { _syncData.serverKeyFrame++; }); } else { updateServerKeyFrameDispose?.Dispose(); updateServerKeyFrameDispose = null; } }).AddTo(unitData.disposable); }
public void Start(GUnit unit, IBuffData buffData, bool removeWhenFinish) { var processData = unit.GetData <ObjectBuffProcessData>(); if (!IsAddedBuff(processData, buffData)) { processData.currentBuffDataList.Add(buffData); OnStart(unit, buffData as T, removeWhenFinish); } else { OnUpdate(unit, buffData as T); } }
protected override void OnAdd(GUnit unit) { _systemData = unit.GetData <SystemData>(); var unitData = unit.GetData <UnitData>(); _updateData = unit.GetData <UpdateData>(); _updateData.updateSubject = new Subject <int>(); Observable.EveryUpdate().Subscribe(_ => { var deltaTime = (int)(Time.deltaTime * Constant.SECOND_TO_MILLISECOND); _updateData.deltaTime = deltaTime; _systemData.time += deltaTime; _systemData.clientFrame++; _updateData.updateSubject.OnNext(deltaTime); }).AddTo(unitData.disposable); _lateUpdateData = unit.GetData <LateUpdateData>(); _lateUpdateData.updateSubject = new Subject <int>(); Observable.EveryLateUpdate().Subscribe(_ => { _lateUpdateData.updateSubject.OnNext(_updateData.deltaTime); }).AddTo(unitData.disposable); _fixedUpdateData = unit.GetData <FixedUpdateData>(); _fixedUpdateData.updateSubject = new Subject <int>(); Observable.EveryFixedUpdate().Subscribe(_ => { var deltaTime = (int)(Time.fixedDeltaTime * Constant.SECOND_TO_MILLISECOND); _fixedUpdateData.deltaTime = deltaTime; _fixedUpdateData.updateSubject.OnNext(_fixedUpdateData.deltaTime); }).AddTo(unitData.disposable); }
protected override void OnAdd(GUnit unit) { var unitData = unit.GetData <UnitData>(); var controlStateData = unit.GetData <ObjectControlStateData>(); var controlProcessData = unit.GetData <ObjectKeyboardControlProcessData>(); var stateProcessData = unit.GetData <ObjectStateProcessData>(); controlStateData.stateType.Subscribe(controlStateType => { if (controlStateType == ObjectControlStateType.Start) { controlProcessData.checkDispose = GameSystem.ObserveEveryUpdate().Subscribe(_ => { foreach (var controlData in controlProcessData.controlDataList) { if (Input.GetKeyDown(controlData.key)) { ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.Down); ObjectControlState.CheckAllControl(unit, controlData.controlType, controlStateData, stateProcessData); } else if (Input.GetKeyUp(controlData.key)) { ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.Up); ObjectControlState.CheckAllControl(unit, controlData.controlType, controlStateData, stateProcessData); ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.None); } } }); } else if (controlStateType == ObjectControlStateType.Finish) { controlProcessData.checkDispose?.Dispose(); } }).AddTo(unitData.disposable); }
protected override void OnRemove(GUnit unit) { var controlStateData = unit.GetData <ObjectControlStateData>(); controlStateData.stateType.Value = ObjectControlStateType.Finish; var controlDataList = ObjectControlDataDict.Get(unit); foreach (var controlData in controlDataList) { Pool.Release(controlData); } ObjectControlDataDict.Clear(unit); ObjectControlStateTypeDict.Clear(unit); }
public static void Finish(GUnit unit, int id, bool sync = true) { var stateProcessData = unit.GetData <ObjectStateProcessData>(); var stateData = ObjectStateDataDict.Get(unit, id); if (!stateData.objectState.CanFinish(unit, stateProcessData, stateData)) { return; } if (sync && unit.GetData <ObjectSyncData>() == null) { sync = false; } if (sync) { ObjectSyncServer.AddState(unit, id, Vector3.zero, ObjectStateType.Finish); } else { Finish(unit, stateProcessData, stateData); } }
protected override void OnAdd(GUnit unit) { var unitData = unit.GetData <UnitData>(); var controlStateData = unit.GetData <ObjectControlStateData>(); var controlProcessData = unit.GetData <ObjectUIControlProcessData>(); var stateProcessData = unit.GetData <ObjectStateProcessData>(); controlStateData.stateType.Subscribe(controlStateType => { if (controlStateType == ObjectControlStateType.Start) { controlProcessData.checkDispose = new CompositeDisposable(); foreach (var controlData in controlProcessData.controlDataList) { controlData.controlHelper.ObservePointerDown().Subscribe(_ => { ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.Down); ObjectControlState.CheckAllControl(unit, controlData.controlType, controlStateData, stateProcessData); }).AddTo(controlProcessData.checkDispose); controlData.controlHelper.ObservePointerUp().Subscribe(_ => { ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.Up); ObjectControlState.CheckAllControl(unit, controlData.controlType, controlStateData, stateProcessData); ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.None); }).AddTo(controlProcessData.checkDispose); } } else if (controlStateType == ObjectControlStateType.Finish) { controlProcessData.checkDispose?.Dispose(); } }).AddTo(unitData.disposable); }
protected override void OnStart(GUnit unit, ObjectSlowDownBuffData buffData, bool removeWhenFinish) { var moveSpeedData = unit.GetData <ObjectMoveSpeedData>(); moveSpeedData.basePercent -= buffData.value; if (buffData.duration > 0) { IDisposable delayDispose = null; delayDispose = Observable.Timer(TimeSpan.FromSeconds(buffData.duration)).Subscribe(_ => { delayDispose?.Dispose(); Finish(unit, buffData); }); } }
public void Finish(GUnit unit, IBuffData buffData, bool removeFromBuffDataList = true) { var finishResult = OnFinish(unit, buffData as T); if (finishResult && removeFromBuffDataList) { var processData = unit.GetData <ObjectBuffProcessData>(); for (var i = 0; i < processData.currentBuffDataList.Count; i++) { var addedBuffData = processData.currentBuffDataList[i]; if (addedBuffData.GetType() == buffData.GetType()) { processData.currentBuffDataList.Remove(addedBuffData); break; } } } }
void Hide(GUnit unit, PanelData panel) { Action hideAction = () => { OnHide(unit, panel); if (panel.DestroyWhenHide) { var unitData = unit.GetData <UnitData>(); unitData.stateTypeProperty.Value = UnitStateType.Destroy; } else { panel.gameObject.SetActive(false); } }; var uiCore = WorldManager.Instance.Unit.GetUnit(UIConstant.UI_CORE_UNIT_NAME); var taskData = uiCore.GetData <TaskData>(); if (panel.AnimationType == UIAnimationType.Animation && panel.AnimationProcessor != null) { taskData.taskList.Add(panel.AnimationProcessor.PlayAsObserable(UIConstant.CLOSE_TWEEN_NAME).Do(_ => { hideAction.Invoke(); })); } else if (panel.AnimationType == UIAnimationType.Tween && panel.TweenProcessor != null) { taskData.taskList.Add(panel.TweenProcessor.PlayAsObserable(UIConstant.CLOSE_TWEEN_NAME).Do(_ => { hideAction.Invoke(); })); } else { hideAction.Invoke(); } }
protected override void OnAdd(GUnit unit) { _uiData = unit.GetData <UIProcessData>(); _taskData = unit.GetData <TaskData>(); }
public static void AddState(GUnit unit, SyncStateInfo syncInfo) { var objectSyncData = unit.GetData <ObjectSyncData>(); objectSyncData.stateSyncInfoList.Add(syncInfo); }
protected override void OnRemove(GUnit unit) { var objectSyncData = unit.GetData <ObjectSyncData>(); objectSyncData.checkSyncDispose?.Dispose(); }
protected override void OnAdd(GUnit unit) { _processData = unit.GetData <AssetProcessData>(); }
protected override void OnAdd(GUnit unit) { _stateData = unit.GetData <GameStateData>(); _stateData.currentState = new ReactiveProperty <int>(); }