private void EvtGamePostSwitchState(EStateType newState, EStateType curState)
{
if (postSwitchStateFunc != null)
{
postSwitchStateFunc.call(newState, curState);
}
}
public void Init(Character OwnerToSet)
{
OwnerCharacter = OwnerToSet;
StateInstances = new Dictionary <EStateType, BaseState>();
foreach (GameObject StateTemplate in StatePrefabs)
{
BaseState InstanciatedState = Instantiate <GameObject>(StateTemplate).GetComponent <BaseState>();
InstanciatedState.transform.SetParent(transform);
InstanciatedState.name = "state_" + InstanciatedState.GetStateType().ToString();
InstanciatedState.gameObject.SetActive(false);
InstanciatedState.Init(this, OwnerToSet);
if (!StateInstances.ContainsKey(InstanciatedState.GetStateType()))
{
StateInstances.Add(InstanciatedState.GetStateType(), InstanciatedState);
}
else
{
Debug.LogError("State Type already instantiated.");
}
}
m_currState = EStateType.None;
ChangeState(EStateType.Idle);
}
public BaseState GetStateInstance(EStateType StateType)
{
if (StateInstances.ContainsKey(StateType))
{
return(StateInstances[StateType]);
}
return(null);
}
static public void SwitchToState(EStateType stateType)
{
if (stateType == EStateType.None)
{
return;
}
Instance._SwitchToState(stateType);
}
private void _SwitchToState(EStateType stateType)
{
switchQueue.Enqueue(stateType);
if (running == false)
{
StartCoroutine(HandleSwitchQueue());
}
}
private void _SwitchToState(EStateType newState)
{
switchQueue.Enqueue(newState);
if (!runing)
{
StartCoroutine(HandleSwitchQueue());
}
}
public IEnumerator LoadGameRes()
{
if (EnableInState != curResGameType)
{
curResGameType = EnableInState;
}
yield break;
}
public bool GetState(EStateType type, ref bool _state) // return is success
{
if (stateDic.TryGetValue(type, out bool s))
{
_state = s;
return(true);
}
return(false);
}
// public void OnCommand()
public BaseState()
{
m_type = EStateType.EStateType_Default;
percent = 0;
//默认循环
timeOutState = this;
m_curFsm = null;
m_links = new Dictionary <int, StateLink>();
m_propSys = new PropertySystem();
m_propSys.NewPropertySet("root", "");
}
private void _SwitchToState(EStateType newState)
{
switchQueue.Enqueue(newState);
//if (newState == EStateType.FightSelectMode)
//{
// Debug.LogError(newState);
//}
if (runing == false)
{
StartCoroutine(HandleSwitchQueue());
}
}
public bool RequestChangeState(EStateType StateType)
{
if (StateType != m_currState && StateInstances.ContainsKey(StateType))
{
if (GetStateInstance(StateType).CanEnter(m_prevState))
{
ChangeState(StateType);
return(true);
}
}
return(false);
}
public void SetComputerState(EStateType state)
{
switch (state)
{
case EStateType.Free:
this.computerState = new FreeState(this);
return;
case EStateType.Occupied:
this.computerState = new OccupiedState(this);
return;
}
}
private ICameraState CreateStateByType(EStateType in_state)
{
switch (in_state)
{
case EStateType.Idle: return(new CCameraState_Idle(this));
case EStateType.Accelerate: return(new CCameraState_Accelerate(this));
case EStateType.GetSlow: return(new CCameraState_GetSlow(this));
}
return(null);
}
private bool IsAllowed(EStateType StateType)
{
if (allowedStatesNames.Contains(StateType))
{
return(true);
}
if (allowedStatesNames.Contains(EStateType.ANY))
{
return(true);
}
return(false);
}
static public void SwitchToState(EStateType stateType)
{
if (stateType == EStateType.None)
{
return;
}
//if (stateType == EStateType.FightSelectMode)
//{
// Debug.LogError("不是错误，打的日志: Enter FightSelectMode");
//}
Instance._SwitchToState(stateType);
}
public void SetState(EStateType type, bool _state)
{
if (stateDic.ContainsKey(type))
{
if (stateDic[type] != _state)
{
stateDic[type] = _state;
UpdateState();
}
}
else
{
stateDic.Add(type, _state);
UpdateState();
}
}
public void ChangeState(EStateType StateType)
{
if (StateType != m_currState && StateInstances.ContainsKey(StateType))
{
if (m_currState != EStateType.None)
{
StateInstances[m_currState].OnExit(StateType);
StateInstances[m_currState].gameObject.SetActive(false);
}
m_prevState = m_currState;
m_currState = StateType;
StateInstances[m_currState].OnEnter();
StateInstances[m_currState].gameObject.SetActive(true);
}
}
//void Update() { }
public void CameraHandler(float in_time)
{
if (_player == null)
{
return;
}
_desired_camera_point.SetCurrentPosition(DesiredCameraPos(), in_time);
UpdateCameraVelocityAndPosition(in_time);
EStateType new_state = _current_state.Update(in_time);
if (new_state != _current_state.GetStateType())
{
ICameraState old_state = _current_state;
_current_state = CreateStateByType(new_state);
_current_state.Update(0f);
}
}
public CGameState(EStateType stateType, Type[] systems, CGameState[] childState)
{
mStateType = stateType;
mSystems = systems;
mChildState = childState;
}
public void setState(EStateType index)
{
this.CurrentState = (IStates)this.arrayList[(int)index];
}
////////////////////////////////
public S4JState()
{
ID = Guid.NewGuid();
AllowedStateTypes = new EStateType[0];
Gates = new List <S4JStateGate>();
}
private IEnumerator _SwitchToStateCo(EStateType newState)
{
mWillStateType = newState;
if (mOldState == newState)
{
//Debug.LogWarning("SwitchState oldState == newState: " + newState);
yield break;
}
CUility.Log("Begin: SwitchToStateCo " + newState);
try
{
if (OnPreStateChange != null)
{
OnPreStateChange(newState, mOldState);
}
}
catch (Exception ex)
{
CUility.LogError("Exception in OnPreStateChange: {0}", ex.ToString());
}
CGameState[] oldStates = mConfig.mStateMap[mOldState];
CGameState[] newStates = mConfig.mStateMap[newState];
int sameDepth = -1;
while (sameDepth + 1 < newStates.Length && sameDepth + 1 < oldStates.Length &&
newStates[sameDepth + 1] == oldStates[sameDepth + 1])
{
++sameDepth;
}
//Debug.Log(sameDepth);
//Debug.Log("Leave old system");
List <CGameSystem> leaveSystems = new List <CGameSystem>();
for (int i = oldStates.Length - 1; i > sameDepth; --i)
{
foreach (Type sysType in oldStates[i].mSystems)
{
leaveSystems.Add(mSystemMap[sysType]);
}
}
foreach (CGameSystem leaveSystem in leaveSystems)
{
CUility.Log("Leave System {0}", leaveSystem.Name);
try
{
leaveSystem._SysLeave();
}
catch (Exception ex)
{
Debug.LogError(string.Format("Exception in {1}'s SysLeave: {0}", ex.ToString(), leaveSystem.Name));
}
}
CUility.Log("Leave System Finish");
try
{
if (OnStateChange != null)
{
OnStateChange(newState, mOldState);
}
}
catch (Exception ex)
{
Debug.LogError(string.Format("Exception in OnStateChange: {0}", ex.ToString()));
}
CUility.Log("Start EnterSystem");
//Debug.Log("Enter new system");
List <CGameSystem> enterSystems = new List <CGameSystem>();
for (int i = sameDepth + 1; i < newStates.Length; ++i)
{
foreach (Type sysType in newStates[i].mSystems)
{
if (!mSystemMap.ContainsKey(sysType))
{
throw new Exception(string.Format("SystemMap.ContainsKey({0}) == false", sysType.Name));
}
mSystemMap[sysType].EnableInState = newStates[i].mStateType;
enterSystems.Add(mSystemMap[sysType]);
}
}
for (int i = 0; i < enterSystems.Count; ++i)
//foreach (CGameSystem enterSystem in enterSystems)
{
CGameSystem enterSystem = enterSystems[i];
CUility.Log("{0} SysEnter Start", enterSystem.Name);
bool haveEnterCo = false;
try
{
haveEnterCo = enterSystem._SysEnter();
}
catch (Exception ex)
{
Debug.LogError(string.Format("Exception in {1}'s SysEnter: {0}", ex.ToString(), enterSystem.Name));
}
if (haveEnterCo)
{
yield return(StartCoroutine(enterSystem.SysEnterCo()));
}
enterSystem._EnterFinish();
//CLogSys.Log(ELogLevel.Verbose, ELogTag.GameRoot, string.Format("{0} SysEnter Finish", enterSystem.Name));
}
//Debug.Log("Add new system...............Finish");
//Debug.Log("Remove old system once more");
//加入了新系统之后，再给旧系统一次清理的机会。
foreach (CGameSystem leaveSystem in leaveSystems)
{
leaveSystem.SysLastLeave();
}
//Debug.Log("Remove old system once more...............Finish");
foreach (CGameSystem enterSystem in enterSystems)
{
try
{
enterSystem.OnStateChangeFinish();
}
catch (Exception ex)
{
Debug.LogError("Exception in OnStateChangeFinish: +" + ex.ToString());
}
}
//Debug.Log(string.Format("Enter State {0} from {1}", newState, mOldState));
mPreState = mOldState;
mOldState = newState;
try
{
if (OnPostStateChange != null)
{
OnPostStateChange(newState, mPreState);
}
}
catch (Exception ex)
{
Debug.Log(string.Format("Exception in OnPostStateChange: " + ex.ToString()));
}
CUility.Log("End: SwitchToStateCo " + newState);
}
private IEnumerator _SwitchToStateCo(EStateType newState)
{
if (mOldState == newState)
{
Debug.Log("SwitchState oldState == newState: " + newState);
yield break;
}
if (OnPreStateChange != null)
{
OnPreStateChange(newState, mOldState);
}
CGameState[] oldStates = mConfig.mStateMap[mOldState];
CGameState[] newStates = mConfig.mStateMap[newState];
int sameDepth = -1;
while (sameDepth + 1 < newStates.Length && sameDepth + 1 < oldStates.Length &&
newStates[sameDepth + 1] == oldStates[sameDepth + 1])
{
++sameDepth;
}
List <CGameSystem> leaveSystems = new List <CGameSystem>();
for (int i = oldStates.Length - 1; i > sameDepth; --i)
{
foreach (Type sysType in oldStates[i].mSystems)
{
leaveSystems.Add(mSystemMap[sysType]);
}
}
foreach (CGameSystem leaveSystem in leaveSystems)
{
leaveSystem._SysLeave();
}
if (OnStateChange != null)
{
OnStateChange(newState, mOldState);
}
List <CGameSystem> enterSystems = new List <CGameSystem>();
for (int i = sameDepth + 1; i < newStates.Length; ++i)
{
foreach (Type sysType in newStates[i].mSystems)
{
if (!mSystemMap.ContainsKey(sysType))
{
throw new Exception(string.Format("SystemMap.ContainsKey({0}) == false", sysType.Name));
}
mSystemMap[sysType].EnableInState = newStates[i].mStateType;
enterSystems.Add(mSystemMap[sysType]);
}
}
//Debug.Log("555555555555555555555555....." + enterSystems.Count);
for (int i = 0; i < enterSystems.Count; ++i)
{
CGameSystem enterSystem = enterSystems[i];
bool haveEnterCo = enterSystem._SysEnter();
if (haveEnterCo)
{
yield return(StartCoroutine(enterSystem.SysEnterCo()));
}
enterSystem._EnterFinish();
}
//加入了新系统之后，再给旧系统一次清理的机会。
foreach (CGameSystem leaveSystem in leaveSystems)
{
leaveSystem.SysLastLeave();
}
foreach (CGameSystem enterSystem in enterSystems)
{
enterSystem.OnStateChangeFinish();
}
mPreState = mOldState;
mOldState = newState;
if (OnPostStateChange != null)
{
OnPostStateChange(newState, mPreState);
}
}
public bool RequestState(EStateType NewState)
{
return(_CharacterStateMachine.RequestChangeState(NewState));
}
public virtual void OnExit(EStateType NewState)
{
}
public void ChangeState(EStateType stateTypeToChange)
{
CurrentState.Exit();
CurrentState = states[stateTypeToChange];
CurrentState.Enter();
}
public void AddState(EStateType stateType, BaseState state)
{
states.Add(stateType, state);
}
private IEnumerator _SwitchToStateCo(EStateType newState)
{
mNewState = newState;
if (mCurState == newState)
{
yield break;
}
if (OnPreStateChange != null)
{
OnPreStateChange(newState, mCurState);
}
CGameState[] oldStates = mConfig.mStateMap[mCurState];
CGameState[] newStates = mConfig.mStateMap[newState];
int sameDepth = 0;
while (sameDepth < newStates.Length && sameDepth < oldStates.Length &&
newStates[sameDepth] == oldStates[sameDepth])
{
++sameDepth;
}
mLeaveSystems.Clear();
mEnterSystems.Clear();
for (int i = oldStates.Length - 1; i >= sameDepth; --i)
{
for (int j = 0; j < oldStates[i].mSystems.Length; ++j)
{
mLeaveSystems.Add(mSystemMap[oldStates[i].mSystems[j]]);
}
}
for (int i = 0; i < mLeaveSystems.Count; ++i)
{
mLeaveSystems[i]._SysLeave();
}
if (OnStateChange != null)
{
OnStateChange(newState, mCurState);
}
for (int i = sameDepth; i < newStates.Length; ++i)
{
for (int j = 0; j < newStates[i].mSystems.Length; ++j)
{
if (!mSystemMap.ContainsKey(newStates[i].mSystems[j]))
{
throw new Exception(string.Format("SystemMap.ContainKey({0})==false", newStates[i].mSystems[j].Name));
}
mSystemMap[newStates[i].mSystems[j]].EnableInState = newStates[i].mStateType;
mEnterSystems.Add(mSystemMap[newStates[i].mSystems[j]]);
}
}
for (int i = 0; i < mEnterSystems.Count; ++i)
{
bool haveEnterCo = mEnterSystems[i]._SysEnter();
if (haveEnterCo)
{
yield return(StartCoroutine(mEnterSystems[i].SysEnterCo()));
}
mEnterSystems[i]._EnterFinish();
}
//加入了新系统之后，再给旧系统一次清理的机会
for (int i = 0; i < mLeaveSystems.Count; ++i)
{
mLeaveSystems[i].SysLastLeave();
}
for (int i = 0; i < mEnterSystems.Count; ++i)
{
mEnterSystems[i].OnStateChangeFinish();
}
mPreState = mCurState;
mCurState = newState;
if (OnPostStateChange != null)
{
OnPostStateChange(newState, mPreState);
}
}
public virtual bool CanEnter(EStateType PreviousState)
{
return(true);
}
