/// <summary> /// Handles this server sessions spawn. /// </summary> /// <param name="sender">Local session.</param> /// <param name="e">Formal junk.</param> private void RoutingServer_SessionSpawned(object sender, EventArgs e) { var session = sender as ActiveSession <T>; session.End += Session_End; session.IsClientSide = true; session.ExceptionThrown += AllTargets_ExceptionThrown; session.MessageReceived += Session_MessageReceived; var servers = new List <ActiveEndPoint <T> >(); for (int i = 0, n = Targets.Length; i < n; i++) { var remote = new ActiveEndPoint <T>(Targets[i], session) { Index = i }; remote.ExceptionThrown += AllTargets_ExceptionThrown; remote.MessageReceived += Remote_MessageReceived; remote.SessionClosed += Remote_SessionClosed; servers.Add(remote); } session.Remotes = servers.ToArray(); session.Route = RouteDefault; session.IsBroadcast = IsBroadcast; SessionStarted?.Invoke(session, EventArgs.Empty); foreach (var server in session.Remotes) { server.Connect(); } if (!session.Remotes.All(i => i.IsConnected)) { session.Close(); } }
/// <summary> /// Finishes the break and resumes current task /// </summary> public void Resume() { // Stop the break EndBreak(); // Launch session if has not been yet started if (!mSecondsTicker.Enabled) { // Update timestamp mStartTime = DateTime.Now; // Start first task StartNextTask(mCurrentTask); // Broadcast session is started SessionStarted.Invoke(); // Do not perform any other action return; } // If current task is already finished... (the case when user opted for break when task's time ended) if (CurrentTimeLeft <= TimeSpan.Zero) { // Fire finish command Finish(); return; } // Recalculate remaining tasks after break RecalculateTasksAfterBreak(); }
private void EventBasedNetListenerOnNetworkReceiveEvent(NetPeer peer, NetDataReader reader) { //Not the used connector = end if (!IsConnected) { return; } DatagramPayload payload; using (MemoryStream memoryStream = new MemoryStream()) { memoryStream.Write(reader.Data, 0, reader.AvailableBytes); memoryStream.Seek(0, SeekOrigin.Begin); payload = (DatagramPayload)_formatter.Deserialize(memoryStream); } SimulatorDataSet simulatorDataSet = _datagramPayloadUnPacker.UnpackDatagramPayload(payload); if (payload.PayloadKind == DatagramPayloadKind.SessionStart || _firstPackage) { _firstPackage = false; SessionStarted?.Invoke(this, new DataEventArgs(simulatorDataSet)); } else { DataLoaded?.Invoke(this, new DataEventArgs(simulatorDataSet)); } }
private void GameStartedHandler(MainGameData gameData) { if (gameData != null) { SessionStarted?.Invoke(gameData); } }
private void EnsureSessionStarted(RequiredModel model) { if (model.Type != null && _previousModel?.Type == null) { SessionStarted?.Invoke(this, model); } }
public void LogStart(SessionStarted e) { if (_writer != null) { return; } _writer = new LogFileWriter(TemporaryFile, TemporaryDirectory); _dataSource.MarkDirty(); }
public void UpdateSessionBasics(SessionType type, SessionPhase phase) { if (phase == SessionPhase.None) { return; } if (_session == null) { _session = CreateSession(type); Logger.Log($"{type} session started - new weekend"); SessionStarted?.Invoke(this, EventArgs.Empty); } else if (type != _session.Type) { if (IsInProgress(_session.Phase)) { EndTimedPhase(); } Logger.Log($"{_session.Type} session ended"); SessionEnded?.Invoke(this, EventArgs.Empty); var isPartOfWeekend = type > _session.Type; _session = isPartOfWeekend ? CreateSession(type, _session.WeekendId) : CreateSession(type); var message = isPartOfWeekend ? $"{type} session started - part of existing weekend" : $"{type} session started - new weekend"; Logger.Log(message, Severity.Verbose); SessionStarted?.Invoke(this, EventArgs.Empty); } // We capture this so we the nested methods can use the up-to-date session var oldPhase = _session.Phase; _session.UpdateSessionInfo(type, phase); // If we are in the same session, check if we are advancing through the timed phases if (type == _session.Type) { if (IsStarting(oldPhase) && IsInProgress(_session.Phase)) { StartTimedPhase(); } if (IsInProgress(oldPhase) && IsEnding(_session.Phase)) { EndTimedPhase(); } } }
/// <summary> /// This method will let the AI play the maze for one game (windowless) /// </summary> public MazeCycleOutcome Travel(int timerTimeout = 5000) { MazeGame game = new MazeGame(); game.traveler = this; game.InitGame(maze); MazeCycleOutcome outcome = new MazeCycleOutcome(); // Start AI Training currentSessionID = rlmNet.SessionStart(); SessionStarted?.Invoke(rlmNet.RandomnessCurrentValue); tmr.Interval = timerTimeout; tmr.Start(); timeout = 0; int movesCnt = 0; while (!outcome.GameOver && timeout == 0) { // set up input for x and y based on our current location on the maze var inputs = new List <RlmIOWithValue>() { new RlmIOWithValue(rlmNet.Inputs.First(a => a.Name == "X"), game.traveler.location.X.ToString()), new RlmIOWithValue(rlmNet.Inputs.First(a => a.Name == "Y"), game.traveler.location.Y.ToString()), }; // get AI output based on inputs RlmCycle cycle = new RlmCycle(); var aiResult = cycle.RunCycle(rlmNet, currentSessionID, inputs, Learn); var direction = Convert.ToInt16(aiResult.CycleOutput.Outputs.First().Value); // make the move outcome = game.CycleMaze(direction); // score AI output double score = ScoreAI(outcome, game.traveler); rlmNet.ScoreCycle(aiResult.CycleOutput.CycleID, score); MazeCycleComplete?.Invoke(game.traveler.location.X, game.traveler.location.Y, outcome.BumpedIntoWall); movesCnt++; } tmr.Stop(); // compute final score outcome.FinalScore = game.CalculateFinalScore(game.Moves); // End AI Training rlmNet.SessionEnd(outcome.FinalScore); SessionComplete?.Invoke(rlmNet.SessionCount, outcome.FinalScore, movesCnt); return(outcome); }
protected override async Task SessionBeginInternal() { startTime = DateTime.Now; lastSessionUpdateTime = startTime; SessionTimerStart(); SessionStarted?.Invoke(null, EventArgs.Empty); Metrics metrics = new Metrics(DeviceData.OS, null, null, null, null, AppVersion, DeviceData.Locale); await AddSessionEvent(new BeginSession(AppKey, await DeviceData.GetDeviceId(), sdkVersion, metrics)); }
private IEnumerator StartSessionCoroutine() { //Wait one frame so components that want to subcribe to //SessionStarted event can be initialized after game scene //being loaded yield return(null); IsSessionActive = true; //Session has started now, notify other components SessionStarted?.Invoke(); }
void HandleSessionStartedMessage(SessionStarted message) { Player challenger = GetPlayerById(message.ChallengerId); Player challenged = GetPlayerById(message.ChallengedId); if (challenger == null || challenged == null) { return; } Dispatcher.Instance.Enqueue(() => GameManager.Instance.StartSession(message.SessionId, challenger, challenged)); }
/// <summary> /// Initializes a new Session /// </summary> /// <param name="AutoStart">(optional) also start the set automatically</param> public void StartSession(bool AutoStart = false) { Debug.Log("Session Starting"); currentSetCount = 0; currentBreathCount = 0; timeBreathpaused = 0; isSessionStarted = true; SessionStarted?.Invoke(this); if (AutoStart) { StartSet(); } }
private void RaiseSessionStartedEvent(SimulatorDataSet data) { DataEventArgs args = new DataEventArgs(data); Logger.Info("New Session starting"); if (_oldDataSet != null) { Logger.Info("Old set:"); LogSimulatorDataSet(_oldDataSet); } _oldDataSet = data; Logger.Info("New set:"); LogSimulatorDataSet(_oldDataSet); SessionStarted?.Invoke(this, args); }
private void RaiseSessionStartedEvent(SimulatorDataSet data) { DataEventArgs args = new DataEventArgs(data); Logger.Info("New Session starting" + data.SessionInfo.SessionType); /*if (_oldDataSet != null) * { * Logger.Info("Old set:"); * LogSimulatorDataSet(_oldDataSet); * } * * _oldDataSet = data; * Logger.Info("New set:"); * LogSimulatorDataSet(_oldDataSet);*/ SessionStarted?.Invoke(this, args); }
public async Task <EventSession> StartSessionAsync(TraceProfileDescriptor descriptor) { if (runningSession != null) { throw new InvalidOperationException("Session already in progress."); } var traceLog = new TraceLog(); var session = new EventSession(descriptor, traceLog); SessionStarting?.Invoke(traceLog); await session.StartAsync(); runningSession = session; SessionStarted?.Invoke(runningSession); return(session); }
/// <summary> /// Handles this server sessions spawn. /// </summary> /// <param name="sender">Local session.</param> /// <param name="e">Formal junk.</param> private void ProxyServer_SessionSpawned(object sender, EventArgs e) { var session = sender as ActiveSession <T>; session.End += Session_End; session.IsClientSide = true; session.ExceptionThrown += Session_ExceptionThrown; session.MessageReceived += Session_MessageReceived; var remote = new ActiveEndPoint <T>(A, session); remote.MessageReceived += Remote_MessageReceived; remote.ExceptionThrown += Session_ExceptionThrown; session.Remotes = new[] { remote }; SessionStarted?.Invoke(this, EventArgs.Empty); remote.Connect(); if (!remote.IsConnected) { session.Close(); } }
void HandleAcceptChallengeMessage(AcceptChallenge message) { ServerPlayer player = GetPlayerBySecret(message.Secret); if (player == null) { return; } Challenge accepted = null; foreach (Challenge challenge in _challenges) { if (challenge.Challenged.Id != player.Id) { continue; } ServerPlayer challenger = GetPlayerById(challenge.Challenger.Id); ServerPlayer challenged = GetPlayerById(challenge.Challenged.Id); GameState session = new GameState(NextSessionId, challenger.CreateGamePlayer(), challenged.CreateGamePlayer()); _sessions[session.Id] = session; var sessionStarted = new SessionStarted(session.Id, challenger.Id, challenged.Id); BaseServer.SendTo(challenger.NetPlayer, sessionStarted); BaseServer.SendTo(challenged.NetPlayer, sessionStarted); accepted = challenge; Task.Run(() => RunGame(session).ConfigureAwait(false)); break; } if (accepted != null) { _challenges.Remove(accepted); } }
public IGameSession Add(IBotServer server, Guid sessionId, string userId, string username, DateTime created) { lock (sessionMutex) { var existingSession = sessions.FirstOrDefault(x => x.Id == sessionId); if (existingSession != null) { if (SessionStarted != null) { SessionStarted.Invoke(this, existingSession); } return(existingSession); } var session = new RavenfallGameSession(server, sessionId, userId, username, created); sessions.Add(session); if (SessionStarted != null) { SessionStarted.Invoke(this, session); } return(session); } }
private void GameStartedHandler(MainGameData gameData) { print($"[SESSION] Started"); SessionStarted?.Invoke(gameData); }
protected void OnSessionStarted() { SessionStarted?.Invoke(this); }
public void OnSessionStarted(ActiveSession s) { SessionStarted?.Invoke(s); }
public void LogStart(SessionStarted e) { if (_writer != null) return; _writer = new LogFileWriter(TemporaryFile, TemporaryDirectory); _dataSource.MarkDirty(); }
protected virtual void OnDataSessionStarted(DataManagerEventArgs e) { SessionStarted?.Invoke(this, e); }
private void Session_Started(object sender, EventArgs e) { RaiseSessionStatusChangedAndTrace(MeterSessionStatus.SessionStarted, "#Sesión Iniciada. Estableciendo Conexión"); SessionStarted?.Invoke(this, new EventArgs()); }
public void RestartSession() { Data.Session.Reset(); SessionStarted?.Invoke(); }
/// <summary> /// Starts Processing Commands /// </summary> /// <param name="cancellationToken">The cancellation token</param> /// <returns>A Task which performs the operation</returns> public async override Task StartAsync(CancellationToken cancellationToken) { // Validate Port before starting if (Port == 0) { throw new Exception("Invalid port number"); } // Initializes Server try { Server = new TcpListener(IPAddress.Any, Port); Server.Start(10); // Notify the listening started ListeningStarted?.Invoke(this, new ListeningStartedEventArgs(Port)); while (cancellationToken.IsCancellationRequested == false) { // Keep listening for incoming connections var client = await Server.AcceptTcpClientAsync().WithCancellation(cancellationToken).ConfigureAwait(false); cancellationToken.ThrowIfCancellationRequested(); // Creates the Communication Session var sessionID = this.BeginSession(); // Notify that a session is started var sessionStartedEventArgs = new SessionStartedEventArgs(sessionID); SessionStarted?.Invoke(this, sessionStartedEventArgs); // Make sure session is not denied if (sessionStartedEventArgs.Deny) { // Session is denied, unregister it this.EndSession(sessionID); } else { // Session is allowed, continue with it var networkCommunicationSession = new NetworkCommunicationSession(client, sessionID, ShowTimer, ShowPrompt); networkCommunicationSession.RawCommandReceived += (sender, commandEventArgs) => { // Executes the command and waits for the answer var taskResponse = Task.Run <CommandExecutionResponse>(async() => await ExecuteCommandAsync(networkCommunicationSession.ID, commandEventArgs.RawCommand)); var response = taskResponse.Result; // Outputs the response commandEventArgs.Response = this.ResponseFormatter.Format(response); // Replace "\n" by the environment NewLine commandEventArgs.Response = commandEventArgs.Response.Replace("\n", System.Environment.NewLine); }; // Add session to the collection lock (NetworkCommunicationSessionsLock) { NetworkCommunicationSessions.Add(networkCommunicationSession.ID, networkCommunicationSession); } #pragma warning disable 4014 // Run Communication Session networkCommunicationSession.RunAsync(cancellationToken).ContinueWith(t => { // Stop Session networkCommunicationSession.Stop(); // Remove Session from Internal Controls lock (NetworkCommunicationSessionsLock) { NetworkCommunicationSessions.Remove(networkCommunicationSession.ID); } // Unregister session with the Command Processor this.EndSession(networkCommunicationSession.ID); // Call SessionEnded event SessionEnded?.Invoke(this, new SessionEndedEventArgs(networkCommunicationSession.ID)); }, cancellationToken); #pragma warning restore 4014 } } } catch (Exception) { throw; } finally { if (Server != null) { Server.Stop(); } } }
void StartSession() { StopAllCoroutines(); SessionStarted?.Invoke(); }
/// <summary> /// Starts a new <see cref="Session"/> with the specified <paramref name="userName"/> and <paramref name="password"/> /// </summary> /// <param name="userName">The user for which the Session is to be started.</param> /// <param name="password">The password with which to authenticate the user.</param> /// <returns>A Result containing the result of the operation and the created Session.</returns> public IResult <ISession> StartSession(string userName, string password) { logger.EnterMethod(xLogger.Params(userName, xLogger.Exclude())); logger.Info($"Starting Session for User '{userName}'..."); IResult <ISession> retVal = new Result <ISession>(); if (State != State.Running) { retVal.AddError($"The Manager is not in a state in which it can service requests (Currently {State})."); } else { IUser foundUser = FindUser(userName); if (foundUser != default(User)) { string hash = SDK.Common.Utility.ComputeSHA512Hash(password); if (foundUser.PasswordHash == hash) { ISession foundSession = FindUserSession(foundUser.Name); if (foundSession == default(Session)) { retVal.ReturnValue = SessionFactory.CreateSession(foundUser, Configuration.SessionLength); sessionLock.EnterWriteLock(); try { SessionList.Add(retVal.ReturnValue); } finally { sessionLock.ExitWriteLock(); } } else { retVal.AddWarning($"The specified User has an existing Session. The existing Session is being returned."); retVal.ReturnValue = foundSession; } } else { retVal.AddError($"Supplied password does not match."); } } else { retVal.AddError($"User '{userName}' does not exist."); } } if (retVal.ResultCode != ResultCode.Failure) { if (retVal.ResultCode == ResultCode.Success) { Task.Run(() => SessionStarted?.Invoke(this, new SessionEventArgs(retVal.ReturnValue))); } } retVal.LogResult(logger); logger.ExitMethod(retVal); return(retVal); }
private MazeCycleOutcome Travel(bool learn, int?timerTimeout = null, CancellationToken?token = null, bool perMoveDisplay = false) { IMazeGame game = GetNewGameInstance(); MazeCycleOutcome outcome = new MazeCycleOutcome(); // Start AI Training var currentSessionID = network.SessionStart(); SessionStarted?.Invoke(network.RandomnessCurrentValue); recentMoves.Clear(); //tmr.Interval = timerTimeout; //tmr.Start(); //timeout = 0; int movesCnt = 1; while (!outcome.GameOver) // && timeout == 0) { if (token?.IsCancellationRequested == true) { break; } // set up input for x and y based on our current location on the maze var inputs = new List <RlmIOWithValue>() { //new RlmIOWithValue(network.Inputs.First(a => a.Name == "X"), game.traveler.location.X.ToString()), //new RlmIOWithValue(network.Inputs.First(a => a.Name == "Y"), game.traveler.location.Y.ToString()), new RlmIOWithValue(network.Inputs.First(a => a.Name == "Move"), movesCnt.ToString()) }; // get AI output based on inputs RlmCycle cycle = new RlmCycle(); var aiResult = cycle.RunCycle(network, currentSessionID, inputs, learn); var direction = Convert.ToInt16(aiResult.CycleOutput.Outputs.First().Value); // make the move outcome = game.CycleMaze(direction); // score AI output double score = 0.0; //score = ScoreAI(outcome, game.traveler); network.ScoreCycle(aiResult.CycleOutput.CycleID, score); if (timerTimeout.HasValue) { Task.Delay(timerTimeout.Value).Wait(); } if (perMoveDisplay) { MazeCycleComplete?.Invoke(game.traveler.location.X, game.traveler.location.Y, outcome.BumpedIntoWall); } if (!learn) { recentMoves.Add(new MoveDetails() { Direction = direction, MoveNumber = movesCnt }); } movesCnt++; } //tmr.Stop(); // compute final score outcome.FinalScore = game.CalculateFinalScore(game.Moves); // End AI Training network.SessionEnd(outcome.FinalScore); SessionComplete?.Invoke(network.SessionCount, outcome.FinalScore, movesCnt - 1); if (movesCnt > HighestMoveCount) { HighestMoveCount = movesCnt; } return(outcome); }
/// <summary> /// Called whenever the <see cref="Session"/> has been started. /// </summary> /// <remarks> /// <remarks> /// In order for this override and properties like <see cref="IsSessionStarted"/> /// to be tracked correctly, use the <see cref="StartSessionAsync"/> and /// <see cref="StopSession"/> methods rather than calling methods /// directly on the <see cref="Session"/> instance. /// </remarks> protected virtual void OnSessionStarted() { SessionStarted?.Invoke(this, EventArgs.Empty); }
//public async Task<bool> ReleaseSession(string sessionId) //{ // if (pool.TryGet(sessionId, out var session)) { // await session.ReleaseAsync(); // OnSessionReleased(session); // return true; // } // return false; //} protected void OnSessionStarted(ServerSessionBase session) { SessionStarted?.Invoke(this, new SessionStateEventArgs(session)); }