bool CanChangeState(StatesEnum current, StatesEnum @new)
{
switch (current)
{
case StatesEnum.NONE:
return(@new == StatesEnum.Initialization);
case StatesEnum.Initialization:
return(@new == StatesEnum.WaitUserInput);
case StatesEnum.WaitUserInput:
return(@new == StatesEnum.EnterUserInput ||
@new == StatesEnum.WaitUserInput);
case StatesEnum.EnterUserInput:
return(@new == StatesEnum.EnterUserInput ||
@new == StatesEnum.FindMatches ||
@new == StatesEnum.WaitUserInput);
case StatesEnum.FindMatches:
return(@new == StatesEnum.WaitUserInput ||
@new == StatesEnum.HaveNoOneTurn ||
@new == StatesEnum.FindMatches);
case StatesEnum.HaveNoOneTurn:
return(@new == StatesEnum.WaitUserInput ||
@new == StatesEnum.FindMatches);
default:
this.LogError("Try to move to Unregistered state");
return(false);
}
}
public bool Reason()
{
attacked++;
if (!attacking)
{
if (anim)
{
if (!anim.IsPlaying(animString))
{
attacking = true;
}
}
else
{
attacking = true;
}
return(true);
}
else
{
returnState = StatesEnum.retreat;
return(false);
}
}
public bool SetState(StatesEnum state)
{
if (!CanChangeState(CurrentState, state))
{
this.LogError($"Cant move from [{CurrentState}] => [{state}]. If isn't error need register this translation.");
return(false);
}
this.LogWarning($"Change state [{CurrentState}] => [{state}].");
if (states.ContainsKey(CurrentState))
{
states[CurrentState]?.Exit();
}
CurrentState = state;
if (states.ContainsKey(CurrentState))
{
states[CurrentState]?.Enter();
}
else
{
this.LogError($"Move to Unregistered state [{CurrentState}]. State wasn't call. State has to was registered.");
}
return(true);
}
public void SetState(StatesEnum state) // Use the method to set the player state based on the input
{
switch (state)
{
case StatesEnum.Dashing:
isDashing = true;
isAttacking = false;
isBoomeranging = false;
break;
case StatesEnum.Attacking:
isAttacking = true;
break;
case StatesEnum.Boomeranging:
isBoomeranging = true;
break;
case StatesEnum.Swapping:
isSwapping = true;
break;
default:
break;
}
}
/// <summary>
/// Handle the message display after service added
/// </summary>
/// <param name="message"></param>
public void OnServiceAdded(string message, StatesEnum state)
{
switch (state)
{
case StatesEnum.ServiceInvalid:
MessagesList.Add(new MessageItem {
Message = Messages.msgServiceAddedFailed, FileName = string.Empty
});
break;
case StatesEnum.ConnectionAlreadyExist:
MessagesList.Add(new MessageItem {
Message = Messages.msgServiceAddedAlreadyExist, FileName = string.Empty
});
break;
case StatesEnum.ConnectionAddedAndActivated:
MessagesList.Add(new MessageItem {
Message = Messages.msgServiceActivatedAddedOK, FileName = string.Empty
});
break;
default:
MessagesList.Add(new MessageItem {
Message = Messages.msgServiceAddedOK, FileName = string.Empty
});
break;
}
}
public void ConsumeBuffer()
{
if (!bufferSystem.IsEmpty() && _player.IsIdleOrMoving()())
{
StatesEnum nextInput = bufferSystem.Dequeue();
_player.SetState(nextInput);
}
}
public Car(int x, int y)
{
this.x = x;
this.y = y;
state = StatesEnum.BEGIN;
rides_dones = new List <Rides>();
ride_todo = null;
}
public void Enqueue(StatesEnum input, bool stackBuffer = false) // If this item is not already in the list, enqueue it. Or, we can choose to stack the buffers.
{
BufferItem bufferItem = new BufferItem(input);
if (!bufferList.Contains(bufferItem) || stackBuffer)
{
bufferList.Add(bufferItem);
}
}
void UpdateState()
{
if (Health > 0.0F)
{
state = StatesEnum.Walking;
AttackSoldierIfNearby();
}
else
{
state = StatesEnum.Dead;
}
}
public void ChangeState(StatesEnum state)
{
if (_currentState != null)
{
_currentState = null;
}
Debug.Log($"{name} новое состояние: {state}");
_currentState = _stateFactory.CreateState(state);
_currentState.OnStart();
}
private void UpdateStateConfigs()
{
this.Invalidate();
//update Default State Enum
//EnumManager.UpdateEnum(EnumName, stateList[0].Name, stateList.Select(x => x.Name).ToArray());
StateXML = State.DataSerializeState(stateList); //save config
//new enum technique
//EnumManager.UpdateEnum(myGUID + "_States", stateList[0].Name, stateList.Select(x => x.Name).ToArray());
StatesEnum.Clear();
stateList.ForEach(state => StatesEnum.AddEntry(state.Name));
//FLogger.Log(LogType.Debug, "update enums state");
}
// Update is called once per frame
void Update()
{
// check curent state from anim
SetState();
// check if state has been changed
if (currentState != lastState)
{
lastState = currentState;
// FIXME remove
Debug.Log("Enemy State Changed: " + currentState.ToString());
ReActToState();
}
}
public void SwitchState(StatesEnum state)
{
//Debug.Log(" "+ state.ToString());
Core.Instance.UnMute();
if (_currentState != null)
{
_currentState.Disable();
}
_currentState = _states[state];
_currentStateEnum = state;
_currentState.Enable();
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Setting AddConnection(WSConnection connection, bool isActive, out StatesEnum state)
{
using (ISettingRepository settingRepository = new SettingsRepository())
{
var setting = settingRepository.GetSeting();
if (!CommonBLL.CheckService(connection))
{
state = StatesEnum.ServiceInvalid;
return(setting);
}
if (!setting.WSConnections.Any(x => x.Equals(connection)))
{
setting.WSConnections.Add(connection);
}
else
{
WSConnection existing = setting.WSConnections?.Where(x => x.Equals(connection)).FirstOrDefault();
if (existing?.Login == connection.Login && existing?.Password == connection.Password && existing?.ApiKey == connection.ApiKey)
{
// ReSharper disable once RedundantAssignment
state = StatesEnum.ConnectionAlreadyExist;
}
else
{
setting.WSConnections.Remove(existing);
setting.WSConnections.Add(connection);
}
}
if (isActive)
{
setting.ChangeActiveConnection(connection.Uri.ToString());
state = StatesEnum.ConnectionAddedAndActivated;
}
else
{
state = StatesEnum.ConnectionAddedSuccessfully;
}
settingRepository.SaveSetting(setting);
return(setting);
}
}
private IEnumerator SetStateOrEnqueueWithDelay(StatesEnum state)
// If this is the shadow, wait for a delay before processing the input. Then, either change the state immediately or enqueue it.
{
if (!_player.isShadow)
{
yield return(null);
}
else
{
yield return(new WaitForSeconds(Player.ShadowDelay));
}
switch (state)
{
case StatesEnum.Dashing:
if (_player.IsIdleOrMoving()() || _player.IsAttacking()())
{
_player.SetState(StatesEnum.Dashing);
}
else
{
bufferSystem.Enqueue(StatesEnum.Dashing);
}
break;
case StatesEnum.Attacking:
// Enqueue Attacking state if we're in another action state. If we're idle/running, to the attack immediately
if (_player.IsIdleOrMoving()())
{
_player.SetState(StatesEnum.Attacking);
}
else
{
bufferSystem.Enqueue(StatesEnum.Attacking, true);
}
break;
//case StatesEnum.Boomeranging:
// if (_player.IsIdleOrMoving()()) { _player.SetState(StatesEnum.Boomeranging); }
// else { bufferSystem.Enqueue(StatesEnum.Boomeranging); }
// break;
default:
break;
}
}
public bool Reason()
{
Collider[] objectsInRange = Physics.OverlapSphere(obj.transform.position, alertRange);
if (timeLeft < 0 && wanderTime > 0)
{
returnState = StatesEnum.idle;
return(false);
}
for (int i = 0; i < objectsInRange.Length; i++)
{
if (objectsInRange[i].tag == alertTag)
{
returnState = StatesEnum.alert;
return(false);
}
}
return(true);
}
public bool RegisterNewState(StatesEnum @enum, AbsStateFSM state, bool replaceExist = false)
{
if (states.ContainsKey(@enum))
{
if (!replaceExist)
{
return(false);
}
else
{
states[@enum] = state;
}
}
else
{
states.Add(@enum, state);
}
return(true);
}
void AttackSoldierIfNearby()
{
hitTime += Time.deltaTime;
var soldiers = GameObject.FindGameObjectsWithTag("Soldier");
foreach (var soldier in soldiers)
{
var soldierScript = soldier.GetComponent <SoldierScript>();
var distance = Vector3.Distance(soldier.transform.position, transform.position);
if (distance < ATTACK_THRESHOLD)
{
if (hitTime > 1F)
{
soldierScript.InflictDamage(HitRate);
hitTime = 0F;
}
state = StatesEnum.Attacking;
}
}
}
public bool Reason()
{
if (target == null)
{
return(false);
}
float distance = Vector3.Distance(target.transform.position, obj.transform.position);
if (distance < chargeRange)
{
if (distance > attackRange)
{
return(true);
}
returnState = StatesEnum.intaract;
return(false);
}
returnState = StatesEnum.wander;
return(false);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Setting AddConnection(WSConnection connection, bool isActive, out StatesEnum state)
{
using (ISettingRepository settingRepository = new SettingsRepository())
{
var setting = settingRepository.GetSeting();
if (!CommonBLL.CheckService(connection))
{
state = StatesEnum.ServiceInvalid;
return(setting);
}
if (!setting.WSConnections.Any(x => x.Equals(connection)))
{
setting.WSConnections.Add(connection);
}
else
{
// ReSharper disable once RedundantAssignment
state = StatesEnum.ConnectionAlreadyExist;
}
if (isActive)
{
setting.ChangeActiveConnection(connection.Uri.ToString());
state = StatesEnum.ConnectionAddedAndActivated;
}
else
{
state = StatesEnum.ConnectionAddedSuccessfully;
}
settingRepository.SaveSetting(setting);
return(setting);
}
}
public IState CreateState(StatesEnum state)
{
switch (state)
{
case StatesEnum.Idle:
{
return(_idleFactory.Create());
}
case StatesEnum.Attack:
{
return(_attackFactory.Create());
}
case StatesEnum.Dead:
{
return(_deadFactory.Create());
}
default:
throw new Exception("Неизвестное состояние");
}
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static Setting AddConnection(WSConnection connection, bool isActive, out StatesEnum state)
{
using (ISettingRepository settingRepository = new SettingsRepository())
{
var setting = settingRepository.GetSeting();
if (!CommonBLL.CheckService(connection))
{
state = StatesEnum.ServiceInvalid;
return setting;
}
if (!setting.WSConnections.Any(x => x.Equals(connection)))
{
setting.WSConnections.Add(connection);
}
else
{
state = StatesEnum.ConnectionAlreadyExist;
}
if (isActive)
{
setting.ChangeActiveConnection(connection.Uri.ToString());
state = StatesEnum.ConnectionAddedAndActivated;
}
else
{
state = StatesEnum.ConnectionAddedSuccessfully;
}
settingRepository.SaveSetting(setting);
return setting;
}
}
// find current state
void SetState()
{
// get current state
AnimatorStateInfo stateInfo = anim.GetCurrentAnimatorStateInfo(0);
// int stateInfo = anim.GetCurrentAnimatorStateInfo(0).
// tagHash 0
// nameHash changes for different states
// idlehash = 2081823275
// shortNameHash = 2081823275
// debug
//Debug.Log(stateInfo.shortNameHash);
// handle chase state, wish I could use a switch statement
if (stateInfo.shortNameHash == idleHash)
{
currentState = StatesEnum.IDLE;
}
else if (stateInfo.shortNameHash == chaseHash)
{
currentState = StatesEnum.CHASE;
}
else if (stateInfo.shortNameHash == evadeHash)
{
currentState = StatesEnum.EVADE;
}
else if (stateInfo.shortNameHash == attackHash)
{
currentState = StatesEnum.ATTACK;
}
else if (stateInfo.shortNameHash == deadHash)
{
currentState = StatesEnum.DEAD;
}
}
static IStatePlateGenerator GetStatePlateGenerator(StatesEnum stateSelection)
{
switch (stateSelection)
{
case StatesEnum.Alabama: return(new AlabamaPlateGenerator()); break;
case StatesEnum.Alaska: return(new AlaskaPlateGenerator()); break;
case StatesEnum.Arizona: return(new ArizonaPlateGenerator()); break;
case StatesEnum.Arkansas: return(new ArkansasPlateGenerator()); break;
case StatesEnum.California: return(new CaliforniaPlateGenerator()); break;
case StatesEnum.Colorado: return(new ColoradoPlateGenerator()); break;
case StatesEnum.Connecticut: return(new ConnecticutPlateGenerator()); break;
case StatesEnum.Delaware: return(new DelawarePlateGenerator()); break;
case StatesEnum.Florida: return(new FloridaPlateGenerator()); break;
case StatesEnum.Georgia: return(new GeorgiaPlateGenerator()); break;
case StatesEnum.Hawaii: return(new HawaiiPlateGenerator()); break;
case StatesEnum.Idaho: return(new IdahoPlateGenerator()); break;
case StatesEnum.Illinois: return(new IllinoisPlateGenerator()); break;
case StatesEnum.Indiana: return(new IndianaPlateGenerator()); break;
case StatesEnum.Iowa: return(new IowaPlateGenerator()); break;
case StatesEnum.Kansas: return(new KansasPlateGenerator()); break;
case StatesEnum.Kentucky: return(new KentuckyPlateGenerator()); break;
case StatesEnum.Louisiana: return(new LouisianaPlateGenerator()); break;
case StatesEnum.Maine: return(new MainePlateGenerator()); break;
case StatesEnum.Maryland: return(new MarylandPlateGenerator()); break;
case StatesEnum.Massachusetts: return(new MassachusettsPlateGenerator()); break;
case StatesEnum.Michigan: return(new MichiganPlateGenerator()); break;
case StatesEnum.Minnesota: return(new MinnesotaPlateGenerator()); break;
case StatesEnum.Mississippi: return(new MississippiPlateGenerator()); break;
case StatesEnum.Missouri: return(new MissouriPlateGenerator()); break;
case StatesEnum.Montana: return(new MontanaPlateGenerator()); break;
case StatesEnum.Nebraska: return(new NebraskaPlateGenerator()); break;
case StatesEnum.Nevada: return(new NevadaPlateGenerator()); break;
case StatesEnum.New_Hampshire: return(new NewHampshirePlateGenerator()); break;
case StatesEnum.New_Jersey: return(new NewJerseyPlateGenerator()); break;
case StatesEnum.New_Mexico: return(new NewMexicoPlateGenerator()); break;
case StatesEnum.New_York: return(new NewYorkPlateGenerator()); break;
case StatesEnum.North_Carolina: return(new NorthCarolinaPlateGenerator()); break;
case StatesEnum.North_Dakota: return(new NorthDakotaPlateGenerator()); break;
case StatesEnum.Ohio: return(new OhioPlateGenerator()); break;
case StatesEnum.Oklahoma: return(new OklahomaPlateGenerator()); break;
case StatesEnum.Oregon: return(new OregonPlateGenerator()); break;
case StatesEnum.Pennsylvania: return(new PennsylvaniaPlateGenerator()); break;
case StatesEnum.Rhode_Island: return(new RhodeIslandPlateGenerator()); break;
case StatesEnum.South_Carolina: return(new SouthCarolinaPlateGenerator()); break;
case StatesEnum.South_Dakota: return(new SouthDakotaPlateGenerator()); break;
case StatesEnum.Tennessee: return(new TennesseePlateGenerator()); break;
case StatesEnum.Texas: return(new TexasPlateGenerator()); break;
case StatesEnum.Utah: return(new UtahPlateGenerator()); break;
case StatesEnum.Vermont: return(new VermontPlateGenerator()); break;
case StatesEnum.Virginia: return(new VirginiaPlateGenerator()); break;
case StatesEnum.Washington: return(new WashingtonPlateGenerator()); break;
case StatesEnum.West_Virginia: return(new WestVirginiaPlateGenerator()); break;
case StatesEnum.Wisconsin: return(new WisconsinPlateGenerator()); break;
case StatesEnum.Wyoming: return(new WyomingPlateGenerator()); break;
default:
throw new ArgumentException($"{stateSelection} could not be parsed into a valid value.");
break;
}
}
void SetStartingState()
{
currentState = StatesEnum.IDLE;
lastState = currentState;
}
/// <summary>
/// Handle the message display after service added
/// </summary>
/// <param name="message"></param>
public void OnServiceAdded(string message, StatesEnum state)
{
switch (state)
{
case StatesEnum.ServiceInvalid:
MessagesList.Add(new MessageItem { Message = Messages.msgServiceAddedFailed, FileName = string.Empty });
break;
case StatesEnum.ConnectionAlreadyExist:
MessagesList.Add(new MessageItem { Message = Messages.msgServiceAddedAlreadyExist, FileName = string.Empty });
break;
case StatesEnum.ConnectionAddedAndActivated:
MessagesList.Add(new MessageItem { Message = Messages.msgServiceActivatedAddedOK, FileName = string.Empty });
break;
default:
MessagesList.Add(new MessageItem { Message = Messages.msgServiceAddedOK, FileName = string.Empty });
break;
}
}
public void ChangeState(StatesEnum state)
{
}
public IState ChangeState(StatesEnum state)
{
State = states_dict[state];
return(State);
}
public void AddState(StatesEnum enumPos, State theState)
{
States.Add(enumPos, theState);
}
public StateMachine(GameObject _obj, StatesEnum _defautState, Animation _anim = null)
{
obj = _obj;
defaultState = _defautState;
anim = _anim;
}
private StatesEnum _input; // String representing player input
public BufferItem(StatesEnum state)
{
_input = state;
}
private void InitSettings()
{
//load settings
if (stateList.Count < 2 && StateXML.Length > 3 && Initialize)
{
try
{
stateList = State.DataDeserializeState(StateXML);
transitionList = Transition.DataDeserializeTransition(TransitionXML);
if (RegionXML.Length > 3)
{
regionList = AutomataRegion.DataDeserializeRegion(RegionXML);
}
}
catch { debug = "Loading XML Graph failed!"; }
//new enum technique
//EnumManager.UpdateEnum(myGUID + "_States", stateList[0].Name, stateList.Select(x => x.Name).ToArray());
stateList.ForEach(state => StatesEnum.AddEntry(state.Name));
//EnumManager.UpdateEnum(myGUID + "_Transitions", transitionList[0].Name, transitionList.Select(x => x.Name).Distinct().ToArray());
transitionList.ForEach(transition => TransitionsEnum.AddEntry(transition.Name));
//EnumManager.UpdateEnum(myGUID + "_Regions", regionList[0].Name, regionList.Select(x => x.Name).ToArray());
regionList.ForEach(region => RegionsEnum.AddEntry(region.Name));
//EnumManager.UpdateEnum(myGUID + "_AllTransitions", transitionList[0].Name, transitionList.Select(x => x.Name).ToArray());
//repair relation
foreach (Transition transition in transitionList)
{
transition.startState = stateList.First(x => x.ID.Contains(transition.startState.ID));
transition.endState = stateList.First(x => x.ID.Contains(transition.endState.ID));
}
this.Invalidate();
previousPosition = MousePosition;
p.StagePos.X = 0;
p.StagePos.Y = 0;
Initialize = false;
}
else if (stateList.Count < 2 && Initialize)
{
//add state to state list
stateList.Add(new State()
{
ID = "Init",
Name = "Init",
Bounds = new Rectangle(new Point(0, 0), new Size(p.StateSize, p.StateSize))
});
UpdateStateConfigs(); // update JSON,Enums and Redraw
this.Invalidate();
previousPosition = MousePosition;
p.StagePos.X = 0;
p.StagePos.Y = 0;
Initialize = false;
}
}
