public void FreeSlot()
{
occupant.transform.parent = null;
trackState = TrackState.Free;
occupant = null;
}
/// <summary>
/// Avança para o próximo quadro (Pose) para validação do gesto
/// </summary>
private void NextKeyFrame()
{
Estado = TrackState.EM_EXECUCAO;
FrameCounter = 0;
CurrentKeyFrame = CurrentKeyFrame.Next;
StepsCount++;
}
/// <summary>
/// Reinicia a validação do gesto
/// </summary>
public void RestartTracker()
{
FrameCounter = 0;
CurrentKeyFrame = KeyFrames.First;
StepsCount = 0;
Estado = TrackState.NAO_IDENTIFICADO;
}
public void OccupySlot(GameObject newOccupant)
{
trackState = TrackState.Occupied;
occupant = newOccupant;
newOccupant.transform.parent = transform;
}
public object Clone()
{
TrackState state = (TrackState)MemberwiseClone();
state.Track = (Track)Track.Clone();
return(state);
}
/// <summary></summary>
/// <param name="spotifyProcessManager"></param>
/// <param name="songClassificationInfo"></param>
/// <param name="refreshInterval"></param>
/// <param name="logger"></param>
/// <param name="maxSongs">
/// Note: -1 == infinite, and numbers between 0 and 10 inclusive are not allowed
/// (in order to guarantee current and future internal functionality)
/// </param>
public SongTracker(SpotifyProcessManager spotifyProcessManager, SongClassificationInfo songClassificationInfo, int refreshInterval, Logger logger, int maxSongs = -1)
{
if (maxSongs >= 0 && maxSongs <= 10)
{
throw new ArgumentOutOfRangeException(
nameof(maxSongs),
maxSongs,
"To guarantee correctness of current and any future internal functionality, "
+ nameof(maxSongs) + " cannot be between 0 and 10 inclusive"
);
}
this.MaxSongs = maxSongs;
this._songs = new List <SongInfo>();
this.Songs = _songs.AsReadOnly();
this.SpotifyProcessManager = spotifyProcessManager;
this.SongClassificationInfo = songClassificationInfo;
this.RefreshInterval = refreshInterval;
this._logger = logger;
this.State = TrackState.Unused;
}
public SessionsViewModel()
{
Title = "Sessions";
_logger = AppSettings.Log.CreateLogger(Title);
_dataStore = App.DataStore;
_tracks = new List <TrackState>();
_selectedTrack = null;
_sessions = new ObservableCollection <SessionState>();
_sessionsGroupedByDate = new ObservableCollection <Grouping <SessionDateInfo, SessionState> >();
DependencyService.Get <IMessageBus>().OnEventRefreshed(this, state =>
{
Sessions.Clear();
foreach (SessionState session in state.Sessions)
{
Sessions.Add(session);
}
Tracks.Clear();
foreach (var track in state.Tracks)
{
Tracks.Add(track);
}
FilterSessions(_selectedTrack);
});
}
public TrackActor(TrackState trackState, ActorPath readStorageUpdateActor)
{
_readStorageUpdateActor = readStorageUpdateActor;
_state = trackState;
Command <TrackUpdateCommand>(c => HandleUpdateCommand(c));
Recover <TrackUpdateCommand>(c => HandleUpdateCommand(c));
TellStateUpdated();
}
public void FilterSessions(TrackState track)
{
SessionsGroupedByDate.Clear();
foreach (var grouping in Sessions.SortAndFilter(track))
{
SessionsGroupedByDate.Add(grouping);
}
}
public TrackInfo(string url, string user)
{
this.url = url;
this.user = user;
trackState = TrackState.NotDownloaded;
trackId = BotSettings.TrackId;
BotSettings.TrackId++;
}
public TSTrackState()
{
InitializeComponent();
toolTip1.SetToolTip(picTrackState, TrackState.ToString());
OutlineForeColor = Color.Black;
OutlineWidth = 2;
}
public AudioTrack(AudioTrackData data, AudioSystem system)
{
this._trackState = TrackState.STATE_IDLE;
this._trackData = data;
this._channels = new Dictionary <string, AudioChannel>();
data.GenerateChannels(ref this._channels, this, system);
this._parentSystem = system;
}
public T GetAndChange()
{
var item = Get();
if (_state == TrackState.None)
{
_state = TrackState.Changed;
}
return(item);
}
public T GetAndChange()
{
T item = Get();
if (State == TrackState.None)
{
State = TrackState.Changed;
}
return(item);
}
public void Play()
{
foreach (AudioChannel t in this._channels.Values)
{
t.OnTrackBegin();
}
this._paused = false;
this._currentDuration = 0.0f;
this._trackState = TrackState.STATE_PLAYING;
}
public void Stop()
{
foreach (AudioChannel t in this._channels.Values)
{
t.OnTrackStopped();
}
this._paused = false;
this._currentDuration = 0.0f;
this._trackState = TrackState.STATE_STOPPED;
}
private void HandleUpdateCommand(TrackUpdateCommand cmd)
{
if (cmd != null && cmd.Binary != null && cmd.Timestamp > _state.Timestamp)
{
Persist(cmd, (c) =>
{
_state = _state.Update(c);
TellStateUpdated();
});
}
}
protected virtual void DisplayTrackState(TrackState trackState)
{
switch (trackState)
{
case TrackState.Green:
{
picTrackState.Image = Properties.Resources.track_state_green;
toolTip1.SetToolTip(picTrackState, "Green");
break;
}
case TrackState.Caution:
{
picTrackState.Image = Properties.Resources.track_state_yellow;
toolTip1.SetToolTip(picTrackState, "Caution");
break;
}
case TrackState.Red:
{
picTrackState.Image = Properties.Resources.track_state_red;
toolTip1.SetToolTip(picTrackState, "Red Flag");
break;
}
case TrackState.Checkered:
{
picTrackState.Image = Properties.Resources.track_state_checkers;
toolTip1.SetToolTip(picTrackState, "Checkered Flag");
break;
}
case TrackState.Warm:
{
picTrackState.Image = Properties.Resources.track_state_warm;
toolTip1.SetToolTip(picTrackState, "Track Is Warm");
break;
}
case TrackState.NotActive:
{
picTrackState.Image = Properties.Resources.track_state_cold;
toolTip1.SetToolTip(picTrackState, "Not Active");
break;
}
default:
{
picTrackState.Image = Properties.Resources.track_state_cold;
toolTip1.SetToolTip(picTrackState, "");
break;
}
}
}
public T GetAndChange()
{
TR.Enter();
T item = Get();
if (State == TrackState.None)
{
State = TrackState.Changed;
}
return(TR.Exit(item));
}
/// <summary>
/// Retorna o estado de rastreamento do gesto atual
/// </summary>
/// <param name="esqueletoUsuario"></param>
/// <returns></returns>
public override TrackState Track(Skeleton esqueletoUsuario)
{
if (esqueletoUsuario == null)
{
RestartTracker();
}
if (ValidPosition(esqueletoUsuario))
{
Estado = TrackState.EM_EXECUCAO;
if (CurrentKeyFrame.Value == KeyFrames.Last.Value)
{
Estado = TrackState.IDENTIFICADO;
}
else
{
if (FrameCounter >= CurrentKeyFrame.Value.QuadroLimiteInferior && FrameCounter <= CurrentKeyFrame.Value.QuadroLimiteSuperior)
{
NextKeyFrame();
}
else if (FrameCounter < CurrentKeyFrame.Value.QuadroLimiteInferior)
{
Tracking();
}
else if (FrameCounter > CurrentKeyFrame.Value.QuadroLimiteSuperior)
{
RestartTracker();
}
}
}
else if (CurrentKeyFrame.Value.QuadroLimiteSuperior < FrameCounter)
{
RestartTracker();
}
else
{
Tracking();
}
var index = KeyFrames.TakeWhile(n => n != CurrentKeyFrame.Value).Count();
ConsoleLog.WriteLog("(" + index + ")" + CurrentKeyFrame.Value.PoseChave.ToString() + " / " + Estado
+ " / " + FrameCounter, ConsoleStatesEnum.NOTICE);
return(Estado);
}
public T Get()
{
if (Item == null)
{
Item = TryGetInternal();
}
if (Item == null)
{
Item = factory?.Invoke() ?? new T();
State = TrackState.Added;
}
return(Item);
}
public static void AddTrackState(TrackState trackState)
{
if (trackState.DateTime - _firstTrackStateTime > TimePortion)
{
SaveWaitingTrackStates.Add(CurrentStates);
CurrentStates = new List <TrackState>();
_firstTrackStateTime = trackState.DateTime;
}
CurrentStates.Add(trackState);
Task.Run(SaveTrackStates);
}
public void FinishTracking()
{
if (this.State == TrackState.Finished)
{
return;
}
this.refreshTimer.Stop();
this.refreshTimer.Dispose();
this.refreshTimer.Tick -= RefreshTimer_Tick;
this.State = TrackState.Finished;
}
public MidReader(Stream s)
{
_s = s;
Header = MidReader.ReadHeader(s);
for (int i = 0; i < Header.TrackCount; i++)
{
var t = new TrackState();
t.ID = i;
t.Stream = new MemoryStream(MidReader.ReadTrack(s));
t.NextEvent = MidReader.ReadEvent(t.Stream);
if (t.NextEvent != null) t.TicksToNextEvent = t.NextEvent.DeltaTime;
_tracks.Add(t);
}
}
private void SwapTrackTarget()
{
// ReSharper disable once SimplifyLinqExpressionUseAll
if (Components.LiveMinionIdentities.Items.Count <= 0)
{
return;
}
var targetDupe = Components.LiveMinionIdentities.Items.GetRandom();
CameraController.Instance.SetFollowTarget(targetDupe.transform);
State = TrackState.AutoTracking;
timeRemaining = CamFollowTime;
}
public T Get()
{
if (_item == null)
{
_item = TryGetInternal();
}
if (_item != null)
{
return(_item);
}
_item = _factory?.Invoke() ?? new T();
_state = TrackState.Added;
return(_item);
}
public void SetKeyframe(int index)
{
if (index < 0 || index >= (int)TrackState.Count)
{
return;
}
track.IsSpread = index == (int)TrackState.Spread;
track.StartOffset = track.StartOffset - track.Curve.Length * Mathf.FloorToInt(track.StartOffset / track.Curve.Length);
track.Curve.Clear();
track.ForceUpdate();
curState = (TrackState)index;
}
public TrackInfo(Character character)
{
this.character = character;
this.characterAnimator = this.character.GetCharacterAnimator();
if (this.characterAnimator != null)
{
this.headTransform = this.characterAnimator.GetHeadTransform();
}
this.currentTrackState = TrackState.NOT_TRACKING;
this.currentPosition = Vector3.zero;
this.currentWeight = 0.0f;
this.changedTime = Time.time;
}
internal async Task Go()
{
var selectedMode = SelectedModeViewModel;
if (selectedMode == null)
{
return;
}
if (SettingsHolder.Drive.QuickDriveCheckTrack)
{
var doesNotFit = selectedMode.TrackDoesNotFit;
if (doesNotFit != null)
{
var respond = ShowTrackDoesNotFitMessage(doesNotFit.Item1);
if (respond == TrackDoesNotFitRespond.Cancel)
{
return;
}
if (respond == TrackDoesNotFitRespond.FixAndGo)
{
doesNotFit.Item2(SelectedTrack);
}
}
}
try {
await selectedMode.Drive(new Game.BasicProperties {
CarId = SelectedCar.Id,
CarSkinId = SelectedCar.SelectedSkin?.Id,
CarSetupId = _carSetupId,
TrackId = SelectedTrack.Id,
TrackConfigurationId = SelectedTrack.LayoutId
}, AssistsViewModel.ToGameProperties(), new Game.ConditionProperties {
AmbientTemperature = Temperature,
RoadTemperature = RoadTemperature,
SunAngle = Game.ConditionProperties.GetSunAngle(_forceTime ?? Time),
TimeMultipler = TimeMultipler,
CloudSpeed = 0.2,
WeatherName = SelectedWeather?.Id
}, TrackState.ToProperties());
} finally {
_goCommand?.RaiseCanExecuteChanged();
}
}
public void Rastrear(Skeleton esqueletoUsuario)
{
TrackState novoEstado = Movimento.Track(esqueletoUsuario);
if (novoEstado == TrackState.IDENTIFICADO && EstadoAtual != TrackState.IDENTIFICADO)
{
OnTracker(MovimentoIdentificado);
}
if (novoEstado == TrackState.EM_EXECUCAO && (EstadoAtual == TrackState.EM_EXECUCAO || EstadoAtual == TrackState.NAO_IDENTIFICADO))
{
OnTracker(MovimentoEmProgresso);
}
EstadoAtual = novoEstado;
}
private bool HandleTrackCreated(TrackCreated trackCreatedEvt)
{
if (trackCreatedEvt == null || trackCreatedEvt.Binary == null)
{
return(false);
}
PersistAsync(trackCreatedEvt, c =>
{
var state = new TrackState(trackCreatedEvt.TrackId, trackCreatedEvt.Binary, trackCreatedEvt.OwnerId);
_trackIds = _trackIds.Add(c.TrackId);
Context.ActorOf(Props.Create(() =>
new TrackActor(state, _readStorageUpdateActor)), trackCreatedEvt.TrackId);
TellTrackListUpdated();
});
return(true);
}
private void ApplyPlaylistLineFormatting(ListViewItem Line, TrackState State)
{
switch (State)
{
case TrackState.Playing:
case TrackState.Paused:
case TrackState.Fading:
if (!Line.Font.Equals(new Font(this.Font, FontStyle.Bold))) { Line.Font = new Font(this.Font, FontStyle.Bold); }
break;
default:
if (!Line.Font.Equals(new Font(this.Font, FontStyle.Regular))) { Line.Font = new Font(this.Font, FontStyle.Regular); }
break;
}
switch (State)
{
case TrackState.Aborted:
if (Line.ForeColor != Color.DarkRed) { Line.ForeColor = Color.DarkRed; }
break;
case TrackState.Done:
if (Line.ForeColor != Color.DarkGreen) { Line.ForeColor = Color.DarkGreen; }
break;
case TrackState.Excluded:
if (Line.ForeColor != Color.Gray) { Line.ForeColor = Color.Gray; }
break;
case TrackState.Error:
if (Line.ForeColor != Color.Red) { Line.ForeColor = Color.Red; }
break;
default:
if (Line.ForeColor != Color.Black) { Line.ForeColor = Color.Black; }
break;
}
switch (State)
{
case TrackState.Playing:
case TrackState.Paused:
if (Line.BackColor != Color.FromArgb(255, 255, 192)) { Line.BackColor = Color.FromArgb(255, 255, 192); }
break;
case TrackState.Fading:
if (Line.BackColor != Color.FromArgb(255, 255, 224)) { Line.BackColor = Color.FromArgb(255, 255, 224); }
break;
default:
if (Line.BackColor != Color.White) { Line.BackColor = Color.White; }
break;
}
}
/// <summary>
///
/// </summary>
/// <param name="initionaly">обновить вне зависимости от того получены или нет состояния дискретных вводов</param>
public void RefrashState(bool initionaly = false)
{
if (!_deviceManager.StateDiReceived && !initionaly)
return;
Track = GetTrackState(Track, null);
Lift = GetLiftState(Lift, null);
InDoorState = GetInDoorState(InDoorState, null);
OutDoorState = GetOutDoorState(OutDoorState, null);
Saw = _deviceManager.GetLastStateRelay(_relays[StrConst.TumblerSaw]);
TightenRope = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTightenRope]);
IsAlarmStop = _deviceManager.GetLastStateDi(_inputs[StrConst.InputButtonEmergencyStop]);
}
static public string StateFormat(TrackState State)
{
switch (State)
{
case TrackState.Queued: return "Queued";
case TrackState.Playing: return "Playing";
case TrackState.Paused: return "Paused";
case TrackState.Fading: return "Fading";
case TrackState.Excluded: return "Skipped";
case TrackState.Aborted: return "Stopped";
case TrackState.Done: return "Done";
case TrackState.Error: return "Error";
default: return "";
}
}
public string ToString(PlaylistFormat Format)
{
switch (Format)
{
case PlaylistFormat.Auto:
throw new ArgumentException("A format must be specified.");
case PlaylistFormat.Internal:
string State;
switch (this.State)
{
case TrackState.Queued: State = "Q"; break;
case TrackState.Playing:
case TrackState.Paused:
if ((double)this.Position / (double)this.Length < 0.38D) { State = "Q"; } else { State = "A"; } break;
case TrackState.Fading: if (this._Fade.Type == FadeType.End) { State = "D"; } else { State = "A"; } break;
case TrackState.Excluded: State = "S"; break;
case TrackState.Aborted: State = "A"; break;
case TrackState.Done: State = "D"; break;
case TrackState.Error: State = "E"; break;
default: State = "E"; break;
}
return State + " " + this.File;
case PlaylistFormat.M3U:
return "#EXTINF:" + (this._InfoAvailable ? this.Length.ToString() : "0") + "," + (this._InfoAvailable ? this.Name : Path.GetFileNameWithoutExtension(this.File)) + "\n" + this.File;
}
throw new ArgumentException("The specified playlist format is not supported.");
}
public bool InitStateTrack()
{
var start = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStartStop]);
var startMiddle = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStartMiddle]);
var startBody1 = _deviceManager.GetLastStateDi(_inputs[StrConst.InputBodyInTrack1]);
var startBody2 = _deviceManager.GetLastStateDi(_inputs[StrConst.InputBodyInTrack2]);
var inLift = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStopInLift]);
var endMiddle = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckEndMiddle]);
TrackState? track = null;
if (startMiddle && start && !inLift && !endMiddle)
track = TrackState.Start;
else if (!startMiddle && startBody1 && startBody2 && inLift && !endMiddle)
track = TrackState.Lift;
else if (!startMiddle && startBody1 && startBody2 && !inLift && endMiddle)
track = TrackState.End;
_logger.With(l => l.Trace(string.Format(
"InitStateTrack: \"{5}\" [startMiddle:{0}][startBody1:{1}][startBody2:{2}][inLift:{3}][endMiddle:{4}]",
startMiddle, startBody1, startBody2, inLift, endMiddle, track)));
if (track != null)
{
Track = track.Value;
return true;
}
return false;
}
public void RefrashState(IEnumerable<string> indexes)
{
try
{
if (!_deviceManager.StateDiReceived)
return;
Track = GetTrackState(Track, indexes);
Lift = GetLiftState(Lift, indexes);
InDoorState = GetInDoorState(InDoorState, indexes);
OutDoorState = GetOutDoorState(OutDoorState, indexes);
Saw = _deviceManager.GetLastStateRelay(_relays[StrConst.TumblerSaw]);
TightenRope = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTightenRope]);
IsAlarmStop = _deviceManager.GetLastStateDi(_inputs[StrConst.InputButtonEmergencyStop]);
if (indexes.Contains(StrConst.InputButtonWeigh))
_lockedPanelWeight = _deviceManager.GetLastStateDi(_inputs[StrConst.InputButtonWeigh])
? _deviceManager.Weight : _lockedPanelWeight;
CloseDoorToLastRoom = _deviceManager.GetLastStateDi(_inputs[StrConst.InputCloseDoorToLastRoot]);
LampOnOffPeriod = GetLampOnOffPeriod(LampOnOffPeriod);
if (CheckCorrectStart(indexes))
OnCorrectStart();
}
catch (Exception ex)
{
_logger.With(l => l.Error(ex.ToString()));
}
}
private TrackState GetTrackState(TrackState lastState, IEnumerable<string> indexes)
{
if (indexes == null)
return lastState;
if (!indexes.Contains(StrConst.InputTruckStartStop) &&
!indexes.Contains(StrConst.InputTruckStartMiddle) &&
!indexes.Contains(StrConst.InputTruckStopInLift) &&
!indexes.Contains(StrConst.InputTruckEndMiddle) &&
!indexes.Contains(StrConst.InputTruckEndStop))
return lastState;
bool onStart = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStartStop]);
bool onStartMiddle = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStartMiddle]);
bool onInLift = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckStopInLift]);
bool onEndMiddle = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckEndMiddle]);
bool onEnd = _deviceManager.GetLastStateDi(_inputs[StrConst.InputTruckEndStop]);
_logger.With(l => l.Trace(string.Format(
"GetTrackState: [onStart:{0}][onStartMiddle:{1}][onInLift:{2}][onEndMiddle:{3}][onEnd:{4}]",
onStart, onStartMiddle, onInLift, onEndMiddle, onEnd)));
TrackState? track = null;
if (onStart && onStartMiddle && !onInLift && !onEndMiddle && !onEnd)
track = TrackState.Start;
else if (!onStart && !onStartMiddle && onInLift && !onEndMiddle && !onEnd)
track = TrackState.Lift;
else if (!onStart && !onStartMiddle && !onInLift && onEndMiddle && onEnd)
track = TrackState.End;
if (track == null)
return lastState;
_logger.With(l => l.Trace(string.Format("GetTrackState: track = {0}", track.Value)));
return track.Value;
}
void _scenarion_StataTrackChanged(TrackState obj)
{
if (obj == Model.TrackState.Error)
{
TrackState = "Ошибка";
}
else if (obj == Model.TrackState.Start)
{
TrackState = "Начало";
StateTrack = 0;
}
else if (obj == Model.TrackState.End)
{
TrackState = "Конец";
StateTrack = 3;
}
else if (obj == Model.TrackState.Lift)
{
TrackState = "В лифте";
StateTrack = LiftState == "Внизу" ? 2 : 3;
}
}
protected virtual void OnStataTrackChanged(TrackState obj)
{
Action<TrackState> handler = StataTrackChanged;
if (handler != null) handler(obj);
}
