void OnIdle(Idle handle)
{
if (handle != null)
{
this.idleCounter++;
if (this.idleCounter == NumberOfTicks)
{
handle.Stop();
}
}
}
/// <summary>
/// Starts up the background thread, if needed, and triggers a reload
/// on the lines.
/// </summary>
public void Restart()
{
// Set the flag so we loop through at least one more time.
needRestart = true;
// If we aren't running, then start it up again.
if (!isRunning)
{
isRunning = true;
Idle.Add(OnIdleUpdate);
}
}
public override void Compose(List <State> states)
{
base.Compose(states);
this.Idle.StateMachine = this;
Idle.MoveTransition = new StateTransition("MoveTransition", Idle, Move);
Idle.AddTrigger(MoveTransition, Idle.MoveTransition);
states.Add(Idle);
this.Move.StateMachine = this;
Move.StopTransition = new StateTransition("StopTransition", Move, Idle);
Move.AddTrigger(StopTransition, Move.StopTransition);
states.Add(Move);
}
protected virtual void OnIdle(object sender, EventArgs args)
{
GLWrapper.Reset();
GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
UpdateSubTree();
DrawSubTree();
Idle?.Invoke(this, EventArgs.Empty);
GLControl.SwapBuffers();
}
private void CheckIfStoppedMoving()
{
if (_isJumping || _beganFall)
{
return;
}
if (_isMoving)
{
Idle?.Invoke();
}
_isMoving = false;
}
void OnIdle(Idle handle)
{
if (this.loopState > 0)
{
handle.CloseHandle(this.OnClosed);
return;
}
if (this.queue.TryDequeue(out Activator activator))
{
activator.Execute(this.loop);
}
}
public override void Update()
{
Vector3 dir = player.position - npc.transform.position;
float angle = Vector3.Angle(dir, npc.transform.forward);
dir.y = 0;
npc.transform.rotation = Quaternion.Slerp(npc.transform.rotation, Quaternion.LookRotation(dir), Time.deltaTime * rotationSpeed);
if (!CanAttackPlayer())
{
nextState = new Idle(npc, agent, anim, player);
stage = EVENT.EXIT;
}
}
public CharacterMainStateMachineContext(InputManager inputManager, GameObject go, IState startState,
[Inject(Id = "id")] string characterId, [Inject(Id = "playerId")] int playerId, [Inject(Id = "stats")] CharacterStats stats, [Inject(Id = "debug")] bool debug,
CharacterLocomotionHandler locomotionHandler, CharacterAnimatorController animatorController,
Idle idle, Walk walk, Die die) : base(go, startState, debug)
{
InputManager = inputManager;
CharacterId = characterId;
PlayerId = playerId;
Stats = stats;
LocomotionHandler = locomotionHandler;
AnimatorController = animatorController;
RelatedStates = new States(idle, walk, die);
}
public override State Update()
{
State state = this;
outer.fastMarchingMethod.Origin = origin;
outer.fastMarchingMethod.UpdatePath();
outer.fastMarchingMethod.DisplayPath();
outer.IncrementStep();
state = new Idle();
return(state);
}
private void Awake()
{
var idle = new Idle();
var attack = new Attack();
var chasePlayer = new ChasePlayer(GetComponent <NavMeshAgent>());
_stateMachine = new StateMachine();
_stateMachine.AddState(idle);
_stateMachine.AddState(attack);
_stateMachine.AddState(chasePlayer);
_stateMachine.SetState(idle);
}
public PlayerControlStateManager()
{
States = new[]
{
typeof(Idle),
typeof(Blocked),
typeof(Choosing),
typeof(Acting)
};
Current = new Idle();
IsPlayerIdle = true;
}
public static void Main(string [] args)
{
Program program = new Program("ImportCommandTest", "0.0", Modules.UI, args);
try {
File.Delete(db_path);
} catch {}
directory_path = args [0];
Idle.Add(new IdleHandler(OnIdleStartImport));
program.Run();
}
void NextTick(Idle handle)
{
if (handle != null)
{
handle.Stop();
this.idle = this.loop.CreateIdle();
this.idle.Start(this.IdleCallback);
this.timer = this.loop.CreateTimer();
this.timer.Start(this.TimerCallback, 0, 0);
}
}
void Start()
{
Idle idleState = new Idle(ballSpawner, enemySpawner);
Shoot shootState = new Shoot(ballSpawner, enemySpawner);
Move moveState = new Move(player, ballSpawner);
idleState.SetNext(shootState);
shootState.SetNext(moveState);
moveState.SetNext(idleState);
state = idleState;
state.Start();
}
private void Conn_OnDisconnected()
{
generation++;
if (Protocol != null)
{
Protocol.Stop();
Protocol = new Idle(this);
}
FreeResources();
this.OnDisconnected?.Invoke();
}
private void MakeFSM()
{
fsm = new SimpleAIFSMSystem();
Idle idle = new Idle(fsm, gameObject, pc);
idle.AddTransition(SimpleAITransition.FoundPlayer, SimpleAIStateID.ChasePlayer);
ChasePlayer chasePlayer = new ChasePlayer(fsm, gameObject, pc);
chasePlayer.AddTransition(SimpleAITransition.LostPlayer, SimpleAIStateID.Idle);
fsm.AddState(idle);
fsm.AddState(chasePlayer);
}
private void Start()
{
stats = GetComponent<Stats> ();
uMC = GetComponent<UnitMovementController> ();
uJC = GetComponent<UnitJobController> ();
idle = new Idle (this);
occupied = new Occupied (this);
returnHome = new ReturnHome (this);
fullfilingNeeds = new FullfilingNeeds (this);
currentState = idle;
}
public Boolean Save()
{
Boolean Saved = true;
try
{
XmlNode Node;
m_Doc.RemoveAll();
Node = m_Doc.CreateXmlDeclaration("1.0", "utf-8", String.Empty);
m_Doc.AppendChild(Node);
Node = m_Doc.CreateComment(String.Format(" ScpControl Configuration Data. {0} ", DateTime.Now));
m_Doc.AppendChild(Node);
Node = m_Doc.CreateWhitespace("\r\n");
m_Doc.AppendChild(Node);
Node = m_Doc.CreateNode(XmlNodeType.Element, "ScpControl", null);
{
CreateTextNode(Node, "Idle", Idle.ToString());
CreateTextNode(Node, "LX", LX.ToString());
CreateTextNode(Node, "LY", LY.ToString());
CreateTextNode(Node, "RX", RX.ToString());
CreateTextNode(Node, "RY", RY.ToString());
CreateTextNode(Node, "LED", LED.ToString());
CreateTextNode(Node, "Rumble", Rumble.ToString());
CreateTextNode(Node, "Triggers", Triggers.ToString());
CreateTextNode(Node, "Latency", Latency.ToString());
CreateTextNode(Node, "DeadL", DeadL.ToString());
CreateTextNode(Node, "DeadR", DeadR.ToString());
CreateTextNode(Node, "Native", Native.ToString());
CreateTextNode(Node, "SSP", SSP.ToString());
CreateTextNode(Node, "Brightness", Brightness.ToString());
CreateTextNode(Node, "Bus", Bus.ToString());
CreateTextNode(Node, "Force", Repair.ToString());
}
m_Doc.AppendChild(Node);
m_Doc.Save(m_File);
}
catch { Saved = false; }
return(Saved);
}
private void Start()
{
#region Configuring State Machine
_animator = GetComponent <Animator>();
_spriteRenderer = GetComponent <SpriteRenderer>();
_rb = GetComponent <Rigidbody2D>();
_stateMachine = new StateMachine();
// Instantiating states
var running = new Running(this, _animator);
var idle = new Idle(this, _animator);
var dashing = new Dashing(this, _animator, _rb);
var stunned = new Stunned(this, _rb);
// Assigning transitions
_stateMachine.AddAnyTransition(stunned, IsStunned());
At(running, idle, IsIdle());
At(idle, running, IsMoving());
At(idle, dashing, IsDashing());
At(running, dashing, IsDashing());
At(stunned, idle, IsNotStunned());
// Starting state
_stateMachine.SetState(running);
// Method to assign transitions easily
void At(IState to, IState from, Func <bool> condition) => _stateMachine.AddTransition(to, from, condition);
// Transition conditions
Func <bool> IsMoving() => () => (xInput != 0 || yInput != 0);
Func <bool> IsIdle() => () => (xInput == 0 && yInput == 0);
Func <bool> IsDashing() => () => (isDashing);
Func <bool> IsNotDashing() => () => (!isDashing);
Func <bool> IsStunned() => () => (isStunned);
Func <bool> IsNotStunned() => () => (!isStunned);
#endregion
#region Instantiating instance variables
// Get boundaries object to set player movement boundaries
GameObject boundaryObj = GameObject.Find("Boundaries");
Boundaries boundary = boundaryObj.GetComponent <Boundaries>();
xBoundary = boundary.playerBoundary_x;
yBoundary = boundary.playerBoundary_y;
// Base sorting layer
baseLayer = GetComponent <SpriteRenderer>().sortingOrder;
#endregion
}
/// <summary>
/// Starts the background update of the elements if it isn't already
/// running.
/// </summary>
private void StartBackgroundUpdate()
{
using (new WriteLock(sync))
{
// If the idle is already running, then we don't need to worry
// about the idle. If it isn't, then set the flag and attach
// the idle function to the Gtk# loop.
if (!idleRunning)
{
idleRunning = true;
Idle.Add(OnIdle);
}
}
}
public async Task HandleAsync_CommandAndRegisteredCommandHandler_HandlesTheCommand()
{
var wrapper = new RequestHandlerWrapper <Idle, VoidUnit>();
var provider = new ServiceProvider(serviceType =>
{
return(serviceType == typeof(IQueryHandler <Idle, VoidUnit>)
? new SyncIdleHandler()
: null);
});
var request = new Idle();
var actual = await wrapper.HandleAsync(request, provider, default);
actual.Should().Be(default);
public override void ReadXML(XElement ele, ElderScrollsPlugin master)
{
XElement subEle;
if (ele.TryPathTo("IdleTime", false, out subEle))
{
if (IdleTime == null)
{
IdleTime = new SimpleSubrecord <Single>();
}
IdleTime.ReadXML(subEle, master);
}
if (ele.TryPathTo("ScriptMarker", false, out subEle))
{
if (ScriptMarker == null)
{
ScriptMarker = new SubMarker();
}
ScriptMarker.ReadXML(subEle, master);
}
if (ele.TryPathTo("Idle", false, out subEle))
{
if (Idle == null)
{
Idle = new RecordReference();
}
Idle.ReadXML(subEle, master);
}
if (ele.TryPathTo("Script", false, out subEle))
{
if (Script == null)
{
Script = new EmbeddedScript();
}
Script.ReadXML(subEle, master);
}
if (ele.TryPathTo("Topic", false, out subEle))
{
if (Topic == null)
{
Topic = new RecordReference();
}
Topic.ReadXML(subEle, master);
}
}
public MainWindow() : base(Gtk.WindowType.Toplevel)
{
Build();
InitControls();
InitToolbar();
Tic();
GtkSelection.Selection.EllipseMode = false;
Idle.Add(new IdleHandler(OnIdle));
}
// Use this for initialization
void Start()
{
m_InitState = new Initialize(this);
m_MoveState = new Move(this);
m_IdleState = new Idle(this);
m_MecanimController = gameObject.GetComponent <QuerySDMecanimController>();
m_CameraPosition = Camera.main.transform.position;
m_CameraPosition.y = 20.5f;
m_Target = m_CameraPosition;
SetState(m_MoveState);
}
void LnStateIdle(object sender, EventArgs e)
{
if (Idle != null)
{
if (ui.InvokeRequired)
{
ui.BeginInvoke(new EventHandler(LnStateIdle), sender, e);
}
else
{
Idle.Fire(this);
}
}
}
// Start is called before the first frame update
void Awake()
{
_rigidbody = GetComponent <Rigidbody>();
_animator = GetComponent <Animator>();
_idleState = new Idle(this);
_aimState = new Aim(this);
_walkingState = new Walking(this);
_throwState = new Throw(this);
_controls = new InputPlayerControls();
ControlsInitialization();
}
/// <summary>
/// Handles application shutdown procedures - terminating render threads, cleaning
/// up the UI, etc.
/// </summary>
/// <param name="sender">Sender.</param>
/// <param name="a">The alpha component.</param>
private void OnDeleteEvent(object sender, DeleteEventArgs a)
{
this.IsShuttingDown = true;
Idle.Remove(OnIdleRenderFrame);
this.RenderingEngine.SetRenderTarget(null);
this.RenderingEngine.Dispose();
this.ViewportWidget.Dispose();
Application.Quit();
a.RetVal = true;
}
private void HandleIdle()
{
lock (_lock) {
if ((DateTime.Now - _lastActivityTime).TotalMilliseconds > IdleDelay)
{
_timesFired++;
if (_timesFired > MaxTimesFired)
{
StopTimer();
}
_mainThread.Post(() => Idle?.Invoke(this, EventArgs.Empty), ThreadPostPriority.IdleOnce);
}
}
}
// Start is called before the first frame update
void Start()
{
_playerTransform = GlobalController.Instance.player.GetComponent <Transform>();
_transform = gameObject.GetComponent <Transform>();
_rigidbody = gameObject.GetComponent <Rigidbody2D>();
_animator = gameObject.GetComponent <Animator>();
_spriteRenderer = gameObject.GetComponent <SpriteRenderer>();
_isShootable = true;
_isShooting = false;
// default to idle mode
_currentState = new Idle();
}
public void IdleStarvation()
{
this.loop = new Loop();
this.idle = this.loop.CreateIdle().Start(this.OnIdle);
this.check = this.loop.CreateCheck().Start(this.OnCheck);
this.loop.CreateTimer().Start(this.OnTimer, 50, 0);
this.loop.RunDefault();
Assert.True(this.idleCount > 0);
Assert.Equal(1, this.timerCount);
Assert.True(this.checkCount > 0);
Assert.Equal(3, this.closeCount);
}
public void AddToIdle(IClient client)
{
if (client == null)
{
return;
}
if (g_traceInfo.IsInfoEnabled)
{
TraceHelper.TraceInfo(g_traceInfo, "Idle - {0}", client);
}
client.IdleState.Reset();
Idle.Return(client);
}
protected override void Update()
{
SetNavMeshAgentSpeed();
StateData.NavMeshAgent.SetDestination(_positionToCheck);
if (IsPositionReached())
{
NextState = new Idle(StateData);
Stage = StateEvent.Exit;
}
if (StateData.EnemySight.CanSeeTarget() || StateData.EnemySight.IsAttacked)
{
NextState = StateData.StateFactory.GetPursueState(StateData);
Stage = StateEvent.Exit;
}
}
// Use this for initialization
void Start()
{
// initialize the agent
/*for(int i = 0; i < transform.childCount; i++)
{
agents.Add(transform.GetChild(i).GetComponent<Member>());
}*/
uniqueAgent = transform.GetChild(0).GetComponent<Member>();
// State machine for member
statePatrol = new StateMachine();
Idle monIdle = new Idle(uniqueAgent);
Search monWalk = new Search(uniqueAgent);
Chase monFire = new Chase(uniqueAgent);
//from Idle to...
Transition transitionIdle = new Transition(uniqueAgent.changeToWalk, monWalk);
Transition transitionWalk = new Transition(uniqueAgent.canShoot, monFire);
Transition transitionFire = new Transition(uniqueAgent.changeToIdle, monIdle);
monIdle.addTransition(transitionIdle);
monWalk.addTransition(transitionWalk);
monFire.addTransition(transitionFire);
statePatrol.currentState = monIdle;
// State machine for team
stateTactic = new StateMachine();
Regroup regroup = new Regroup(this);
Reform reform = new Reform(this);
StateMachineWrapper stateWrapper = new StateMachineWrapper(statePatrol);
Transition transitionRegroup = new Transition(checkNeedToReform, reform);
Transition transitionReform = new Transition(() => { return doTransitionToPatrol; }, stateWrapper);
Transition transitionPatrol = new Transition(() => { return doTransitionToRegroup; }, regroup);
regroup.addTransition(transitionRegroup);
reform.addTransition(transitionReform);
stateWrapper.addTransition(transitionPatrol);
stateTactic.currentState = regroup;
}
void Start()
{
SearchCooldown = SearchCooldownRate;
idle = GetComponent<Idle>();
rotate = GetComponent<AIRotate>();
hunt = GetComponent<Hunt>();
if( GetComponent<Predation>() ) pred = GetComponent<Predation>();
// StartCoroutine( SearchForTarget() );
Targetify( SecondaryTarget );
}
public void Idle(Idle action)
{
dbe.Idle(action);
}
public PrimaryStances(bool directional, string projectileType, Projectile projectile, Idle idle, Windup windup, Cooldown cooldown)
{
this.directional = directional;
this.projectileType = projectileType;
this.projectile = projectile;
this.idle = idle;
this.windup = windup;
this.cooldown = cooldown;
}
public void Process(Processing process, out IProcessingState timeoutState)
{
timeoutState = new Idle(5);
}
void EvaluateAI()
{
if (!CanControlMovement) return;
if (State != UnitState.Alive)
{
if (!(aiState is Idle))
ChangeState(new Idle(this));
return;
}
var e = evalAILastFrame;
evalAILastFrame = Game.Instance.FrameId;
if (!InCombat && e >= inRangeLastChangedFrame) return;
var inRange = new List<Destructible>(NearestNeightboursObject.InRange);
foreach (var u in new List<Destructible>(inRange))
if (u is NPC && ((NPC)u).aiState is TryPerformAbility)
inRange.Add(((TryPerformAbility)((NPC)u).aiState).Chasing);
if (lastChasing != null && !inRange.Contains(lastChasing))
inRange.Add(lastChasing);
foreach (var u in inRange)
InCombat |= Mechanics.TeamReleations.IsHostile(this.Team, u.Team);
var bestState = aiState;
var s = new Idle(this);
if (bestState.IsBetterState(s)) bestState = s;
foreach (var u in inRange)
bestState = TryFindBetterState(bestState, u);
if (bestState != aiState)
{
ChangeState(bestState);
return;
}
}
protected virtual void InitializeStateMachine()
{
Idle idleState = new Idle(this);
idleState.AddTransition(Transition.E_FAILGESTURE, StateID.E_ATTACK);
idleState.AddTransition(Transition.E_LOSTHP, StateID.E_DAMAGED);
idleState.AddTransition(Transition.E_NOHP, StateID.E_DEATH);
Attack atkState = new Attack(this);
atkState.AddTransition(Transition.E_FINISHATTACK, StateID.E_IDLE);
atkState.AddTransition(Transition.E_LOSTHP, StateID.E_DAMAGED);
Damaged dmgState = new Damaged(this);
dmgState.AddTransition(Transition.E_NOHP, StateID.E_DEATH);
dmgState.AddTransition(Transition.E_FINISHATTACK, StateID.E_IDLE);
dmgState.AddTransition(Transition.E_LOSTHP, StateID.E_DAMAGED);
Death deathState = new Death(this);
enemyState = new FiniteStateMachine();
enemyState.AddState(idleState);
enemyState.AddState(atkState);
enemyState.AddState(dmgState);
enemyState.AddState(deathState);
}
