static IndependentObjectStateData GetHighestPriorityState(GUnit unit, ObjectStateProcessData stateProcessData)
{
var stateDataList = ObjectStateDataDict.Get(unit).Where(_ => _ is IndependentObjectStateData);
var minPriority = 0;
IndependentObjectStateData result = null;
foreach (var stateData in stateDataList)
{
if (stateData.stateTypeProperty.Value != ObjectStateType.Stop)
{
continue;
}
if (!stateData.objectState.CanStart(unit, stateProcessData, stateData, Vector3.zero))
{
continue;
}
var independentStateData = stateData as IndependentObjectStateData;
if (independentStateData.priority >= minPriority)
{
minPriority = independentStateData.priority;
result = independentStateData;
}
}
return(result);
}
static void Finish(GUnit unit, ObjectStateProcessData stateProcessData, ObjectStateData stateData = null)
{
var currentState = stateData == null ? stateProcessData.currentState : stateData;
if (currentState == null)
{
return;
}
if (currentState is IndependentObjectStateData)
{
if (currentState.stateTypeProperty.Value == ObjectStateType.Start)
{
currentState.stateTypeProperty.Value = ObjectStateType.Finish;
stateProcessData.currentState = null;
var newStateData = GetHighestPriorityState(unit, stateProcessData);
Start(stateProcessData, newStateData);
}
else if (currentState.stateTypeProperty.Value == ObjectStateType.Stop)
{
currentState.stateTypeProperty.Value = ObjectStateType.Finish;
}
}
else
{
currentState.stateTypeProperty.Value = ObjectStateType.Finish;
}
}
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);
}
static void AttachAttributeData(GUnit unit)
{
var moveSpeedData = unit.AddData <ObjectMoveSpeedData>();
moveSpeedData.baseValue = 2500;
moveSpeedData.basePercent = 1f;
}
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 OnPreload(GUnit unit, List <IObservable <Unit> > taskList)
{
taskList.Add(AssetProcess.Load <GameObject>("Prefabs/UI/PreloadItem").Do(asset =>
{
asset.Prespawn(10);
}).AsUnitObservable());
}
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);
}
void Init(GUnit unit, PanelData panel)
{
panel.transform.SetSiblingIndex(panel.Order);
panel.gameObject.SetActive(false);
OnInit(unit);
}
protected override void OnRemove(GUnit unit)
{
base.OnRemove(unit);
_stateData.currentState.Dispose();
_stateData = null;
}
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);
}
}
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 bool OnFinish(GUnit unit, ObjectSlowDownBuffData buffData)
{
var moveSpeedData = unit.GetData <ObjectMoveSpeedData>();
moveSpeedData.basePercent += buffData.value;
return(true);
}
protected override void OnRemove(GUnit unit)
{
_attackServerData.onAttack.OnCompleted();
_attackServerData.onBeforeDamage.OnCompleted();
_attackServerData.onDamage.OnCompleted();
_attackServerData.onAfterDamage.OnCompleted();
_attackServerData = null;
}
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 OnRemove(GUnit unit)
{
var processData = unit.GetData <ObjectBuffProcessData>();
foreach (var buffData in processData.currentBuffDataList)
{
RemoveBuff(unit, buffData, false);
}
processData.currentBuffDataList.Clear();
}
protected override void OnHide(GUnit unit, PanelData panel)
{
var preloadPanelData = panel as UIPreloadTestPanelData;
foreach (var preloadItem in preloadPanelData.preloadItemList)
{
preloadItem.Despawn();
}
preloadPanelData.preloadItemList.Clear();
}
protected override void OnShow(GUnit unit, PanelData panel, params object[] args)
{
var preloadPanelData = panel as UIPreloadTestPanelData;
var asset = AssetProcess.Get <GameObject>("Prefabs/UI/PreloadItem");
for (var i = 0; i < 10; i++)
{
var preloadItem = asset.Spawn();
preloadItem.transform.SetParent(preloadPanelData.grid.transform);
}
}
protected override void OnAdd(GUnit unit)
{
var stateDataList = ObjectStateDataDict.Get(unit);
foreach (var stateData in stateDataList)
{
var stateModule = ObjectStateModuleDict.Get(stateData.id);
stateData.objectState = stateModule;
stateModule.Init(unit, stateData);
}
}
protected override void OnAdd(GUnit unit)
{
var controlDataList = ObjectControlDataDict.Get(unit);
foreach (var controlData in controlDataList)
{
var controlModule = ObjectControlModuleDict.Get(controlData.controlType);
controlData.objectControl = controlModule;
ObjectControlStateTypeDict.Set(unit, controlData.controlType, KeyStateType.None);
}
}
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);
}
public void Release(GUnit unit, ObjectStateData stateData)
{
if (stateData.stateTypeProperty.Value == ObjectStateType.None ||
stateData.stateTypeProperty.Value == ObjectStateType.Finish)
{
return;
}
stateData.stateTypeProperty.Value = ObjectStateType.Finish;
OnRelease(unit, stateData);
}
void Show(GUnit unit, PanelData panelData, PanelParamData paramData)
{
panelData.gameObject.SetActive(true);
OnShow(unit, panelData, paramData.paramsList.ToArray());
if (panelData.AnimationType == UIAnimationType.Animation)
{
panelData.AnimationProcessor?.Play(UIConstant.OPEN_TWEEN_NAME);
}
else if (panelData.AnimationType == UIAnimationType.Tween)
{
panelData.TweenProcessor?.Play(UIConstant.OPEN_TWEEN_NAME);
}
}
public static DamageInfo Attack(GUnit source, AttackInfo attackInfo)
{
_attackServerData.onAttack.OnNext(attackInfo);
var damageInfo = Pool.Get <DamageInfo>();
damageInfo.sourceId = source.UnitId;
damageInfo.targetId = attackInfo.targetId;
damageInfo.attack = attackInfo.attack;
damageInfo.damage = attackInfo.attack;
return(damageInfo);
}
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 OnRemove(GUnit unit)
{
var stateDataList = ObjectStateDataDict.Get(unit);
foreach (var stateData in stateDataList)
{
stateData.objectState.Release(unit, stateData);
stateData.objectState = null;
Pool.Release(stateData);
}
ObjectStateDataDict.Clear(unit);
}
void DoState(GUnit unit, SyncStateInfo syncInfo)
{
if (syncInfo.stateType == ObjectStateType.Start)
{
ObjectStateProcess.Start(unit, syncInfo.stateId, syncInfo.stateParam, false);
}
else if (syncInfo.stateType == ObjectStateType.Update)
{
ObjectStateProcess.Update(unit, syncInfo.stateId, syncInfo.stateParam, false);
}
else if (syncInfo.stateType == ObjectStateType.Finish)
{
ObjectStateProcess.Finish(unit, syncInfo.stateId, false);
}
}
static void DoState(GUnit unit, ObjectControlData controlData, Vector3 param)
{
if (controlData.stateType == ObjectStateType.Start)
{
ObjectStateProcess.Start(unit, controlData.stateId, param);
}
else if (controlData.stateType == ObjectStateType.Update)
{
ObjectStateProcess.Update(unit, controlData.stateId, param);
}
else if (controlData.stateType == ObjectStateType.Finish)
{
ObjectStateProcess.Finish(unit, controlData.stateId);
}
}
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);
}
protected override void OnRemove(GUnit unit)
{
base.OnRemove(unit);
_systemData = null;
_updateData.updateSubject.OnCompleted();
_updateData = null;
_lateUpdateData.updateSubject.OnCompleted();
_lateUpdateData = null;
_fixedUpdateData.updateSubject.OnCompleted();
_fixedUpdateData = null;
}
