protected override void Working(StateStatus stateStatus)
{
if (stateStatus == StateStatus.Execute)
{
//Go through the locators and store them in the overseer
foreach (var locator in Addressables.ResourceLocators)
{
foreach (var key in locator.Keys)
{
//The null check can NullRef if called from the foreach
var location = key as string;
if (location == null)
{
continue;
}
ValidatePath(location);
}
}
workStatus = WorkStatus.Done;
}
base.StartWork(stateStatus);
}
public override void StateEnter()
{
base.StateEnter();
status = StateStatus.Error;
if (brain.PathFinder == null)
{
return;
}
Vector3 center;
if (brain.InGroup() && !brain.IsGroupLeader)
{
center = brain.Events.Memory.Position.Get(5);
center = BasePathFinder.GetPointOnCircle(center, Random.Range(2f, 7f), Random.Range(0f, 359f));
}
else
{
center = brain.PathFinder.GetBestRoamPosition(brain.Navigator, brain.Events.Memory.Position.Get(4), 20f, 100f);
}
if (brain.Navigator.SetDestination(center, BaseNavigator.NavigationSpeed.Slow))
{
if (brain.InGroup() && brain.IsGroupLeader)
{
brain.SetGroupRoamRootPosition(center);
}
status = StateStatus.Running;
}
else
{
status = StateStatus.Error;
}
}
/// <summary>
///
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void submitButton_Click(object sender, EventArgs e)
{
StateStatus stateStatus = StateStatus.BLNK;
if (this.radRenew.Checked)
{
stateStatus = StateStatus.RN;
}
else if (radPaydown.Checked)
{
stateStatus = StateStatus.PD;
}
this.newPawnLoan.TempStatus = stateStatus;
// Make Update to current PawnLoan from NewPawnLoan
this.RolloverPawnLoans.Add(this.newPawnLoan);
//this.pawnLoans[this.currentLoanIndex] = this.newPawnLoan;
if (this.currentLoanIndex + 1 == this.pawnLoans.Count)
{
this.RolloverSuccess = true;
this.Close();
}
else
{
this.currentLoanIndex++;
this.radRenew.Checked = true;
this.updateButtonsAndLoanInfo();
if (rolloverError)
{
return;
}
}
}
public override void StateEnter()
{
base.StateEnter();
status = StateStatus.Error;
brain.Navigator.SetBrakingEnabled(false);
path = brain.Navigator.Path;
T entity = GetEntity();
if (path == null)
{
AIInformationZone forPoint = AIInformationZone.GetForPoint(entity.ServerPosition);
if (forPoint == null)
{
return;
}
path = forPoint.GetNearestPath(entity.ServerPosition);
if (path == null)
{
return;
}
}
currentTargetPoint = path.FindNearestPoint(entity.ServerPosition);
if (!(currentTargetPoint == null))
{
status = StateStatus.Running;
currentWaitTime = 0f;
brain.Navigator.SetDestination(currentTargetPoint.transform.position, BaseNavigator.NavigationSpeed.Slow);
}
}
// Update is called once per frame
void Update()
{
switch (State)
{
case StateStatus.Idle:
break;
case StateStatus.Interval:
AtkInterval -= Time.deltaTime;
if (AtkInterval < 0)
{
State = StateStatus.Attack;
}
break;
case StateStatus.Attack:
float rate = HitPointRate;
if (rate <= NextHPRate)
{
if (++AtkSequenceIndex < AtkSequences.Length)
{
SetAttackSequence(AtkSequenceIndex);
}
else
{
State = StateStatus.Idle;
}
}
else
{
switch (AtkKind)
{
case AttackKind.Normal:
AttackNormal();
break;
case AttackKind.Heavy:
AttackHevy();
break;
case AttackKind.Fast:
AttackFast();
break;
case AttackKind.HevyRush:
AttackHevyRush();
break;
default:
Debug.Log("No Support AttackKind");
break;
}
}
break;
case StateStatus.End:
break;
}
}
public override void Execute(AIMemory memory, AIBrainSenses senses, StateStatus stateStatus)
{
base.Result = base.Inverted;
IAIAttack iAIAttack = base.Owner as IAIAttack;
if (iAIAttack == null)
{
return;
}
BaseEntity bestTarget = iAIAttack.GetBestTarget();
if (base.Inverted)
{
if (bestTarget == null && base.ShouldSetOutputEntityMemory)
{
memory.Entity.Remove(base.OutputEntityMemorySlot);
}
base.Result = bestTarget == null;
}
else
{
if (bestTarget != null && base.ShouldSetOutputEntityMemory)
{
memory.Entity.Set(bestTarget, base.OutputEntityMemorySlot);
}
base.Result = bestTarget != null;
}
}
//private void OnEnable()
//{
// StartAction();
//}
public void Setup(UserRankInfo[] rankInfos, UserRankInfo userRank)
{
Clear();
// BoardNum = rankInfos.Length;
bool isCheckSelect = true;
RankBoards = new RankBoard[rankInfos.Length];
for (int i = 0; i < RankBoards.Length; i++)
{
RankBoard board = Instantiate(TemplateObject, transform);
RankBoards[i] = board;
board.SetDisplayParam(rankInfos[i]);
if (isCheckSelect && userRank.IsSame(rankInfos[i]))
{
board.SetSelectMode(true);
isCheckSelect = false;
}
}
SelfRankBord.SetDisplayParam(userRank);
SelfRankBord.SetVisibleRank(false);
SelfRankBord.gameObject.SetActive(true);
State = StateStatus.Ready;
}
public void SetState <T>() where T : AIState
{
Type t = typeof(T);
if (!_states.ContainsKey(t))
{
Debug.LogWarning("No state found of type " + t.ToString());
return;
}
if (_currentStateStatus.IsValidState)
{
_currentStateStatus.State.Deactivate();
}
StateStatus newState = new StateStatus();
newState.StateType = t;
newState.State = _states[t];
_currentStateStatus = newState;
_currentStateStatus.State.Activate();
if (StateSetEvent != null)
{
StateSetEvent(_currentStateStatus.State);
}
}
private void OnScenesLoaded()
{
foreach (var scene in _loadedScenes)
{
scene.GetRootGameObjects()[0].SetActive(true);
}
_status = StateStatus.Running;
}
private void Startup(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
StateMachine.Trigger(Trigger.NextStep);
}
protected override void StartWork(StateStatus stateStatus)
{
if (stateStatus == StateStatus.Execute)
{
Addressables.InitializeAsync().Completed += InitCompleted;
}
base.StartWork(stateStatus);
}
protected override void StartWork(StateStatus stateStatus)
{
if (stateStatus == StateStatus.Execute)
{
pathToContentPaths.Clear();
}
base.Startup(stateStatus);
}
protected virtual void Startup(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
StateMachine.Trigger(Trigger.NextStep);
}
public void Run(StateStatus status)
{
if (methodInfo == null)
{
return;
}
state(status);
}
void ChangeStatus(StateStatus newStatus)
{
CurrentStatus = newStatus;
if (newStatus == StateStatus.Exit)
{
_exitStatusEnterTime = _currentTime;
PreprocessExitStatus();
}
ProcessState();
}
public override void Execute(AIMemory memory, AIBrainSenses senses, StateStatus stateStatus)
{
BaseEntity baseEntity = memory.Entity.Get(base.InputEntityMemorySlot);
base.Result = false;
if (!(baseEntity == null))
{
bool flag = Vector3Ex.Distance2D(base.Owner.transform.position, baseEntity.transform.position) <= Range;
base.Result = (base.Inverted ? (!flag) : flag);
}
}
protected void ContentTriage(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
DoContentTriage();
StateMachine.Trigger(Trigger.NextStep);
}
public virtual void OnLeave()
{
_status = StateStatus.Leaving;
List <IEnumerator> enumerators = new List <IEnumerator>();
foreach (var scene in _loadedScenes)
{
enumerators.Add(UnloadScene(scene));
}
CoroutineManager.Instance.StartCoroutines(enumerators, OnScenesUnLoaded);
}
public override void StateEnter()
{
base.StateEnter();
Vector3 pos = brain.Events.Memory.Position.Get(4);
status = StateStatus.Running;
if (!brain.Navigator.SetDestination(pos, BaseNavigator.NavigationSpeed.Normal))
{
status = StateStatus.Error;
}
}
public override void Execute(AIMemory memory, AIBrainSenses senses, StateStatus stateStatus)
{
base.Result = false;
BaseEntity baseEntity = memory.Entity.Get(base.InputEntityMemorySlot);
if (!(baseEntity == null) && base.Owner is IAIAttack)
{
bool flag = senses.Memory.IsLOS(baseEntity);
base.Result = (base.Inverted ? (!flag) : flag);
}
}
public override void Execute(AIMemory memory, AIBrainSenses senses, StateStatus stateStatus)
{
base.Result = base.Inverted;
if (base.Inverted)
{
base.Result = senses.TimeInAgressiveState < Value;
}
else
{
base.Result = senses.TimeInAgressiveState >= Value;
}
}
protected virtual void Working(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
if (workStatus == WorkStatus.Done)
{
StateMachine.Trigger(Trigger.NextStep);
}
}
protected void Idle(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
if (workStatus == WorkStatus.Pending)
{
WorkIsReady();
}
}
protected virtual void StartWork(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
InvalidateAllPaths();
workStatus = WorkStatus.Working;
StateMachine.Trigger(Trigger.NextStep);
}
public override void Execute(AIMemory memory, AIBrainSenses senses, StateStatus stateStatus)
{
base.Result = base.Inverted;
IAIAttack iAIAttack = base.Owner as IAIAttack;
if (iAIAttack != null)
{
BaseEntity baseEntity = memory.Entity.Get(base.InputEntityMemorySlot);
iAIAttack.AttackTick(deltaTime, baseEntity, senses.Memory.IsLOS(baseEntity));
base.Result = !base.Inverted;
}
}
public override void StateEnter()
{
base.StateEnter();
status = StateStatus.Error;
IAISleep iAISleep;
if ((iAISleep = GetEntity() as IAISleep) != null)
{
iAISleep.StartSleeping();
status = StateStatus.Running;
}
}
private async Task CreatePlanningAppStatuses(IServiceProvider serviceProvider)
{
var UnitOfWork = serviceProvider.GetRequiredService <IUnitOfWork>();
var StateStatusRepository = serviceProvider.GetRequiredService <IStateStatusRepository>();
var ctr = await StateStatusRepository.GetStateStatusList();
if (ctr.Count == 0)
{
var stateStatus = new StateStatus {
GroupType = "InProgress", Name = "InProgress", OrderId = 1
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "InProgress", Name = "Overdue", OrderId = 2
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "InProgress", Name = "Due", OrderId = 3
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "InProgress", Name = "OnTime", OrderId = 4
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "Not InProgress", Name = "Not InProgress", OrderId = 5
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "Not InProgress", Name = "Complete", OrderId = 6
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "Not InProgress", Name = "Overran", OrderId = 7
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "Not InProgress", Name = "Terminated", OrderId = 8
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "Not InProgress", Name = "Archived", OrderId = 9
};
StateStatusRepository.AddStateStatusList(stateStatus);
stateStatus = new StateStatus {
GroupType = "All", Name = "All", OrderId = 10
};
StateStatusRepository.AddStateStatusList(stateStatus);
}
await UnitOfWork.CompleteAsync();
}
protected override void Working(StateStatus stateStatus)
{
if (stateStatus == StateStatus.Execute)
{
foreach (var lookUpInfo in lookUpInfos)
{
var filePaths = Directory.GetFiles(lookUpInfo.FullName, SEARCH_PATTERN, SearchOption.AllDirectories);
foreach (var filePath in filePaths)
{
var fileInfo = new FileInfo(filePath);
if (ShouldIgnore(fileInfo))
{
continue;
}
var relativePath = fileInfo.RelativePath(lookUpInfo);
if (pathToContentPaths.ContainsKey(relativePath))
{
pathToContentPaths.Remove(relativePath);
}
foreach (var contentFormat in contentFormats)
{
if (contentFormat.Extension != string.Empty && contentFormat.Extension.ToLower() != fileInfo.Extension.ToLower())
{
continue;
}
cacheContentPaths.Clear();
if (contentFormat.ExtractPath(relativePath, fileInfo, cacheContentPaths))
{
foreach (var contentPath in cacheContentPaths)
{
pathToContentPaths.SafeAdd(contentPath.StoragePath, contentPath);
}
}
break;
}
}
}
foreach (var relativePath in pathToContentPaths.Keys)
{
ValidatePath(relativePath);
}
workStatus = WorkStatus.Done;
}
base.Startup(stateStatus);
}
public void Tick(float deltaTime, StateStatus stateStatus)
{
foreach (BaseAIEvent @event in events)
{
@event.Tick(deltaTime, eventListener);
}
inBlock = false;
currentEventIndex = 0;
for (currentEventIndex = 0; currentEventIndex < events.Count; currentEventIndex++)
{
BaseAIEvent baseAIEvent = events[currentEventIndex];
BaseAIEvent baseAIEvent2 = ((currentEventIndex < events.Count - 1) ? events[currentEventIndex + 1] : null);
if (baseAIEvent2 != null && baseAIEvent2.EventType == AIEventType.And && !inBlock)
{
inBlock = true;
}
if (baseAIEvent.EventType != AIEventType.And)
{
if (baseAIEvent.ShouldExecute)
{
baseAIEvent.Execute(Memory, senses, stateStatus);
baseAIEvent.PostExecute();
}
bool result = baseAIEvent.Result;
if (inBlock)
{
if (result)
{
if ((baseAIEvent2 != null && baseAIEvent2.EventType != AIEventType.And) || baseAIEvent2 == null)
{
inBlock = false;
if (baseAIEvent.HasValidTriggerState)
{
baseAIEvent.TriggerStateChange(eventListener, baseAIEvent.ID);
break;
}
}
}
else
{
inBlock = false;
currentEventIndex = FindNextEventBlock() - 1;
}
}
else if (result && baseAIEvent.HasValidTriggerState)
{
baseAIEvent.TriggerStateChange(eventListener, baseAIEvent.ID);
break;
}
}
}
}
private void Idle(StateStatus stateStatus)
{
if (stateStatus != StateStatus.Execute)
{
return;
}
if (requestReceived)
{
requestReceived = false;
StateMachine.Trigger(Trigger.NextStep);
}
}
public int Volume; // 0-100 or -1 if there is no volume support
#endregion Fields
#region Constructors
public StatusInfo(Hashtable info)
{
Volume = Convert.ToInt32((string)info["volume"]);
Crossfade = Convert.ToInt32((string)info["xfade"]);
Repeat = ((string)info["repeat"] == "1");
Random = ((string)info["random"] == "1");
PlaylistVersion = Convert.ToInt32((string)info["playlist"]);
PlaylistLength = Convert.ToInt32((string)info["playlistlength"]);
Music = new MusicStatus(info);
if (info.ContainsKey("updating_db"))
UpdatingDB = ((string)info["updating_db"] != "0");
switch ((string)info["state"]) {
case "play":
State = StateStatus.Play;
break;
case "pause":
State = StateStatus.Pause;
break;
case "stop":
State = StateStatus.Stop;
break;
default:
State = StateStatus.Unknown;
break;
}
}
protected EntityBase(int id = 0, string name = "", StateType type = StateType.Standard,
StateStatus status = StateStatus.Uninitialised)
: base(id, name, type, status)
{
}
