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>();
}
