private void CalculateState()
{
var timeOfDay = DateTime.Now.TimeOfDay;
_logger.LogDebug($"Calculating state at time: {timeOfDay}");
_logger.LogDebug($"_currentInterval.Start: {_currentInterval.Start}");
_logger.LogDebug($"_currentInterval.End: {_currentInterval.End}");
if (_currentInterval.AdditionalConditions != null)
{
foreach (var condition in _currentInterval.AdditionalConditions)
{
_logger.LogDebug($"Additional Condition: {condition.State}");
}
}
var newState = timeOfDay >= _currentInterval.Start &&
timeOfDay < _currentInterval.End &&
(_currentInterval.AdditionalConditions == null ||
_currentInterval.AdditionalConditions.All(c => c.State));
_logger.LogDebug($"newState: {newState}");
if (newState != State)
{
_logger.LogDebug($"State changed, setting new state at RealTime - {DateTime.Now.TimeOfDay}");
State = newState;
OnStateChanged?.Invoke(this, new ToggleAutomationConditionStateChangedHandler(this, newState));
}
}
private PBEBattle(BinaryReader r)
{
ushort version = r.ReadUInt16();
Settings = new PBESettings(r);
Settings.MakeReadOnly();
BattleFormat = (PBEBattleFormat)r.ReadByte();
Teams = new PBETeams(this);
var packetProcessor = new PBEPacketProcessor(this);
int numEvents = r.ReadInt32();
for (int i = 0; i < numEvents; i++)
{
INetPacket packet = packetProcessor.CreatePacket(r.ReadBytes(r.ReadInt16()));
switch (packet)
{
case PBEWinnerPacket wp:
{
Winner = wp.WinningTeam;
break;
}
}
Events.Add(packet);
}
BattleState = PBEBattleState.Ended;
OnStateChanged?.Invoke(this);
}
protected void setNewState(System.Type stateType)
{
if (mainMovementState == null || stateType != mainMovementState.GetType())
{
System.Type prevStateType = null;
CharacterStateBase prevState = mainMovementState;
if (mainMovementState != null)
{
prevStateType = mainMovementState.GetType();
}
Component newState = GetComponent(stateType);
if (newState != null)
{
if (mainMovementState != null)
{
exitState(mainMovementState);
}
mainMovementState = (CharacterStateBase)newState;
enterState(mainMovementState, prevStateType);
//Debug.Log ("new state: " + newState.GetType ().ToString ());
OnStateChanged?.Invoke(mainMovementState, prevState);
}
}
}
public HeroState()
{
connection = new HubConnectionBuilder()
.WithUrl("https://localhost:44314/HeroHub")
.WithAutomaticReconnect()
.Build();
connection.On <Hero>("ReceiveUpdatedHero", (updatedHero) =>
{
HeroList[HeroList.FindIndex(hero => hero.Id == updatedHero.Id)] = updatedHero;
Hero oldHero = TopHeroes.Find(hero => hero.Id == updatedHero.Id);
if (oldHero != null)
{
TopHeroes.Remove(oldHero);
TopHeroes.Add(updatedHero);
}
else
{
TopHeroes.RemoveAt(0);
TopHeroes.Add(updatedHero);
}
OnStateChanged?.Invoke();
});
Task.Run(() => connection.StartAsync());
}
public virtual void StateChanged(ClientState state)
{
switch (state)
{
case ClientState.ConnectionTimedOut:
case ClientState.ChallengeResponseTimedOut:
case ClientState.ConnectionRequestTimedOut:
CurrentStatus = ConnectionStatus.TimedOut;
Server = null;
break;
case ClientState.ConnectTokenExpired:
case ClientState.InvalidConnectToken:
case ClientState.ConnectionDenied:
case ClientState.Disconnected:
CurrentStatus = ConnectionStatus.Disconnected;
Server = null;
break;
case ClientState.SendingConnectionRequest:
case ClientState.SendingChallengeResponse:
CurrentStatus = ConnectionStatus.Connecting;
break;
case ClientState.Connected:
CurrentStatus = ConnectionStatus.Connected;
ID = (ushort)Client.ClientIndex;
break;
}
OnStateChanged?.Invoke(CurrentStatus);
}
public override async Task InvokeAsync(Action action)
{
//await Task.Run(action);
await Task.Run(() => action());
OnStateChanged?.Invoke();
}
private void ReloadAmmo()
{
if (ammo == 0 || reloadTimer > 0)
{
return;
}
var delta = magazineCapacity - currentMagazine;
if (delta == 0)
{
return;
}
if (ammo >= delta)
{
currentMagazine = magazineCapacity;
ammo -= delta;
}
else
{
currentMagazine += ammo;
ammo = 0;
}
isReloading = true;
reloadTimer = reloadTime;
gunReloadSound.Play();
OnStateChanged?.Invoke(currentMagazine, ammo);
}
/// <summary>
/// Incress the state of pancake that is face down in the pan.
/// </summary>
/// <returns> returns true if successful</returns>
public bool NextState()
{
if (pancakeStates[currentSideDown] >= PancakeState.Count - 1)
{
return(false);
}
// if the state is mixture update both states.
if (pancakeStates[currentSideDown] == PancakeState.Mixture)
{
//update both states.
pancakeStates[0]++;
pancakeStates[1]++;
// when going from mixture to raw state we must update the upside timer as well as the down side.
SetTimer(GetSideUp(), 0); // do down side below, it need to be done for all state changes.
}
else
{
pancakeStates[currentSideDown]++;
}
SetTimer(currentSideDown);
OnStateChanged?.Invoke(pancakeStates[currentSideDown]);
return(true);
}
private void Update()
{
if (IsRunning != (Runner != null))
{
IsRunning = Runner != null;
OnRunningChanged?.Invoke(IsRunning);
if (IsRunning)
{
OnInit?.Invoke();
}
}
if (Runner != null)
{
updateWatch.Start();
var now = Time.time;
var extraMs = Mathf.Max(0, (int)((next - now) * 1000f) - 1);
Runner.Idle(extraMs);
Thread.Sleep(extraMs);
if (now >= next)
{
OnPreRunFrame();
Runner.RunFrame();
next = now + 1f / 60f;
OnStateChanged?.Invoke();
}
updateWatch.Stop();
string status = Runner.GetStatus(updateWatch);
OnStatus?.Invoke(status);
OnChecksum?.Invoke(RenderChecksum(Runner.GameInfo.periodic) + RenderChecksum(Runner.GameInfo.now));
}
}
void Update()
{
if (Input.GetKeyDown(KeyCode.R) && reloadTimer <= 0)
{
ReloadAmmo();
}
damagePerShot = gunProperties.Damage;
timeBetweenBullets = gunProperties.Frequency;
range = gunProperties.Range;
reloadTime = gunProperties.ReloadTime;
timer += Time.deltaTime;
if (reloadTimer > 0)
{
reloadTimer -= Time.deltaTime;
}
else if (isReloading)
{
isReloading = false;
OnStateChanged?.Invoke(currentMagazine, ammo);
}
else if (playerController.AllowShooting && timer >= timeBetweenBullets && Time.timeScale != 0)
{
timer = 0f;
Shoot();
}
if (timer >= timeBetweenBullets * effectsDisplayTime)
{
DisableEffects();
}
}
private void SetState(VncState newState)
{
var o = VncState;
vncState = newState;
OnStateChanged?.Invoke(this, new VncStateChangedEventArgs(o, newState));
}
public void Terminate()
{
KillTimer();
Stop();
State = DeviceState.Uninitialized;
OnStateChanged?.Invoke(State);
}
private void MainAnimatorOnFinish()
{
switch (_state)
{
case ClassSelectorState.BackIdle:
ChangeState(ClassSelectorState.FrontTransition);
break;
case ClassSelectorState.FrontIdle:
ChangeState(ClassSelectorState.BackTransition);
break;
case ClassSelectorState.BackTransition:
ChangeState(ClassSelectorState.BackIdle);
OnStateChanged?.Invoke(this);
break;
case ClassSelectorState.FrontTransition:
ChangeState(ClassSelectorState.FrontIdle);
OnStateChanged?.Invoke(this);
break;
case ClassSelectorState.None:
break;
default:
throw new ArgumentOutOfRangeException();
}
}
/// <summary>
/// Swithes state machine to the state
/// </summary>
/// <param name="stateEnter"></param>
public void SwitchToState(StateEnter stateEnter)
{
if (stateToId.ContainsKey(stateEnter) == false)
{
Debug.LogError("[StateMachine] Error: This state is not mapped, you must map all states");
}
if (currentState.stateExit != null)
{
currentState.stateExit();
}
// internal switch state
currentStateId = stateToId[stateEnter];
currentState = idToState[currentStateId];
if (OnStateChanged != null)
{
OnStateChanged.Invoke(currentStateId);
}
currentState.stateEnter();
//Debug.LogWarning("[State Machine] Enter state: " + currentStateId + ", " + currentState);
}
private void PollThread()
{
var sleepTime = TimeSpan.FromMilliseconds(0.5);
while (!cancel)
{
if (!Connected)
{
// Do less while waiting for the controller to come back online.
Thread.Sleep(250);
continue;
}
var state = new XInput.StateEx();
if (0 != XInput.XInputGetStateEx(controllerIndex, ref state))
{
Connected = false;
OnDisconnect?.ThreadSafeInvoke();
continue;
}
var gp = state.Gamepad;
if (gp.bLeftTrigger != lastState.bLeftTrigger ||
gp.bRightTrigger != lastState.bRightTrigger ||
gp.sThumbLX != lastState.sThumbLX ||
gp.sThumbLY != lastState.sThumbLY ||
gp.sThumbRX != lastState.sThumbRX ||
gp.sThumbRY != lastState.sThumbRY ||
gp.wButtons != lastState.wButtons)
{
lastState = gp;
OnStateChanged.ThreadSafeInvoke(lastState);
}
Thread.Sleep(sleepTime);
}
}
private void InitializationButton()
{
int index = 0;
//Initialization for all entity state tags would be to clear the state
//change event and rig it up to initialize itself with the dispatchers to
//the object itself and a broadcast component if one exists
gameObject.GetComponents(typeof(IEntityStateListener))
.Cast <IEntityStateListener>()
.ToList()
.ForEach(listener =>
{
if (OnStateChanged.GetPersistentEventCount() <= index)
{
//We must call this internal method to expand the persistent listener collection before
//attempting to hack register a new one
OnStateChanged.CallMethod("AddPersistentListener", Flags.InstanceAnyVisibility);
}
//We can't easily register new persistent methods so this hack allows us to contrary to Unity
//allows us to do.
OnStateChanged.CallMethod("RegisterPersistentListener", Flags.InstanceAnyVisibility,
index, listener, typeof(IEntityStateListener).Method(nameof(IEntityStateListener.OnEntityStateChanged)));
index++;
});
}
/// <summary>
/// Check and process UniWinCore events
/// </summary>
private void UpdateEvents()
{
if (uniWinCore == null)
{
return;
}
if (uniWinCore.ObserveDroppedFiles(out var files))
{
OnDropFiles?.Invoke(files);
}
if (uniWinCore.ObserveMonitorChanged())
{
OnMonitorChanged?.Invoke();
}
if (uniWinCore.ObserveWindowStyleChanged())
{
// // モニタへのフィット指定がある状態で最大化解除された場合
// if (shouldFitMonitor && !uniWinCore.GetZoomed())
// {
// //StartCoroutine("ForceZoomed"); // 時間差で最大化を強制
// //SetZoomed(true); // 強制的に最大化 ←必ずしも働かない
// //shouldFitMonitor = false; // フィットを無効化
// }
if (_shouldFitMonitor)
{
StartCoroutine("ForceZoomed"); // 時間差で最大化を強制
}
OnStateChanged?.Invoke();
}
}
private async Task OnChanged(CheckboxState state, SelectedItem val)
{
// 子选项点击后，更新其余组件
if (!IsDisabled)
{
// 通知其余兄弟控件
if (state == CheckboxState.Checked && Items != null)
{
foreach (var item in Items)
{
item.Active = item == val;
}
StateHasChanged();
}
// 触发外界 OnStateChanged 事件
if (ValueChanged.HasDelegate)
{
await ValueChanged.InvokeAsync(val);
}
if (OnStateChanged != null)
{
await OnStateChanged.Invoke(state, val);
}
}
}
private void HandleNewState()
{
if (stateHandler_ != null)
{
stateHandler_.Cleanup();
stateHandler_ = null;
}
switch (state_)
{
case State.CanJoin:
stateHandler_ = new StateCanJoin(player_, currentStateContainer_, MoveToNextState, MoveToPreviousState);
break;
case State.Skin:
stateHandler_ = new StateSkinCustomization(player_, currentStateContainer_, MoveToNextState, MoveToPreviousState);
break;
case State.Nickname:
stateHandler_ = new StateNicknameCustomization(player_, currentStateContainer_, MoveToNextState, MoveToPreviousState);
break;
case State.Ready:
stateHandler_ = new StateReady(player_, currentStateContainer_, MoveToNextState, MoveToPreviousState);
break;
}
OnStateChanged.Invoke();
}
public override void Update()
{
if (!Visible)
{
return;
}
if (MouseIsIntersecting())
{
if (Core.Input.LeftButtonPressed())
{
IsChecked = !IsChecked;
if (IsChecked)
{
OnChecked?.Invoke();
}
else
{
OnUnchecked?.Invoke();
}
OnStateChanged?.Invoke(IsChecked);
}
}
IsHovered = MouseIsIntersecting();
}
private static void Load()
{
OnStateChanged?.Invoke(new StateChangedEventArgs()
{
type = StateChangedEventType.loadingStarted
});
if (!Directory.Exists(GetSaveGameDirectory()) || !File.Exists(GetSaveGameStatFile()))
{
StatManager.SetFromSaveData(new Dictionary <string, SaveDataStat>());
OnStateChanged?.Invoke(new StateChangedEventArgs()
{
type = StateChangedEventType.loadingCompleted
});
return;
}
Dictionary <string, SaveDataStat> saveDataStats =
JsonConvert.DeserializeObject <Dictionary <string, SaveDataStat> >(
File.ReadAllText(GetSaveGameStatFile()));
StatManager.SetFromSaveData(saveDataStats);
OnStateChanged?.Invoke(new StateChangedEventArgs()
{
type = StateChangedEventType.loadingCompleted
});
}
public static void InvokeStateChanged(DonationTransaction trans, DonationTransactionState oldState)
{
if (OnStateChanged != null)
{
OnStateChanged.Invoke(new StateChangedEventArgs(trans, oldState));
}
}
public void ApplyChanges()
{
if (this._dirty)
{
_cpuBinder.UpdateObject();
_ppuControlBinder.UpdateObject();
_ppuStatusBinder.UpdateObject();
DebugState state = _lastState;
state.CPU = (CPUState)_cpuBinder.Entity;
if (chkExternal.Checked)
{
state.CPU.IRQFlag |= IRQSource.External;
}
if (chkFrameCounter.Checked)
{
state.CPU.IRQFlag |= IRQSource.FrameCounter;
}
if (chkDMC.Checked)
{
state.CPU.IRQFlag |= IRQSource.DMC;
}
state.PPU.ControlFlags = (PPUControlFlags)_ppuControlBinder.Entity;
state.PPU.StatusFlags = (PPUStatusFlags)_ppuStatusBinder.Entity;
state.PPU.State.Mask = state.PPU.ControlFlags.GetMask();
state.PPU.State.Control = state.PPU.ControlFlags.GetControl();
state.PPU.State.Status = state.PPU.StatusFlags.GetStatus();
UInt32 cycle = 0;
UInt32.TryParse(txtCycle.Text, out cycle);
state.PPU.Cycle = cycle;
Int32 scanline = 0;
Int32.TryParse(txtScanline.Text, out scanline);
state.PPU.Scanline = scanline;
Int32 xScroll = 0;
Int32.TryParse(txtXScroll.Text, out xScroll);
state.PPU.State.XScroll = (byte)Math.Max(0, Math.Min(xScroll, 7));
UInt16 vramAddr = 0;
UInt16.TryParse(txtVRAMAddr.Text, System.Globalization.NumberStyles.HexNumber, null, out vramAddr);
state.PPU.State.VideoRamAddr = vramAddr;
UInt16 tmpVramAddr = 0;
UInt16.TryParse(txtTmpAddr.Text, System.Globalization.NumberStyles.HexNumber, null, out tmpVramAddr);
state.PPU.State.TmpVideoRamAddr = tmpVramAddr;
state.PPU.State.WriteToggle = chkWriteToggle.Checked;
InteropEmu.DebugSetState(state);
_lastState = state;
_dirty = false;
btnUndo.Enabled = false;
OnStateChanged?.Invoke(null, null);
}
}
private void UpdateState(NodeLifecycleState newState)
{
if (newState == NodeLifecycleState.New)
{
//if node is just discovered we send ping to confirm it is active
SendPing();
}
else if (newState == NodeLifecycleState.Active)
{
//TODO && !ManagedNode.IsDicoveryNode - should we exclude discovery nodes
//received pong first time
if (State == NodeLifecycleState.New)
{
var result = _nodeTable.AddNode(ManagedNode);
if (result.ResultType == NodeAddResultType.Full)
{
var evictionCandidate = _discoveryManager.GetNodeLifecycleManager(result.EvictionCandidate.Node);
if (evictionCandidate != null)
{
_evictionManager.StartEvictionProcess(evictionCandidate, this);
}
}
}
}
else if (newState == NodeLifecycleState.EvictCandidate)
{
SendPing();
}
State = newState;
OnStateChanged?.Invoke(this, State);
}
public void ExecuteCommand(ReversibleCommand command)
{
command.ExecuteReversibly();
redoHistory.Clear();
undoHistory.Push(command);
OnStateChanged?.Invoke(this, null);
}
/// <summary>
/// The dispose.
/// </summary>
public void Dispose()
{
this.AdminList.Clear();
this.ModeratorList.Clear();
this.OwnerList.Clear();
this.Users.Clear();
this.VoiceList.Clear();
this.GroupUser = null;
if (OnMessageReceived != null)
{
foreach (var d in OnMessageReceived.GetInvocationList())
{
OnMessageReceived -= (DMessageReceived)d;
}
}
if (OnUserListChange != null)
{
foreach (var d in OnUserListChange.GetInvocationList())
{
OnUserListChange -= (DUserListChange)d;
}
}
if (OnStateChanged != null)
{
foreach (var d in OnStateChanged.GetInvocationList())
{
OnStateChanged -= (DRoomStateChange)d;
}
}
stateTimer.Dispose();
}
private void SwitchToNewState(Type nextState)
{
currState.Exit();
currState = availableStates[nextState];
currState.Enter();
OnStateChanged?.Invoke(currState); //??
}
/// <summary>
/// 点击选择框方法
/// </summary>
protected override void OnToggleClick()
{
if (!IsDisabled && State == CheckboxState.UnChecked)
{
State = CheckboxState.Checked;
OnStateChanged?.Invoke(State, Value);
}
}
public async Task <StageChangeResponse> DeleteStageAsync(AppState.Stage stage)
{
var result = await _httpClient.DeleteAsyncEx <StageChangeResponse>($"api/stage/{stage.Id}", $"Delete column '{stage.Title}'");
OnStateChanged?.Invoke(this, result.AppState);
return(result);
}
public async Task <StageChangeResponse> EditStageAsync(AppState.Stage stage)
{
var result = await _httpClient.PostAsyncEx <StageChangeResponse, AppState.Stage>("api/stage", stage, $"Edit column '{stage.Title}'");
OnStateChanged?.Invoke(this, result.AppState);
return(result);
}
