public Task Initialize(IGameGrain game, string name) { _game = game; _name = name; // Console.WriteLine(" -- {0,-10} -- {1} initialized.", "Star", _name); return(TaskDone.Done); }
public Task ProcessExited(Guid processId) { IGameGrain session = GrainFactory.GetGrain <IGameGrain>(processId); session.UnsubscribeStatus(this); return(TaskDone.Done); }
public Task Heartbeat(byte[] data) { Packet.Heartbeat packet = PacketSerializer.Deserialize <Packet.Heartbeat>(data); IGameGrain game = base.GrainFactory.GetGrain <IGameGrain>(packet.Game); return(game.UpdateGameStatistics(packet.Status)); }
public Task GameStarts(byte[] data) { Packet.GameStarts packet = PacketSerializer.Deserialize <Packet.GameStarts>(data); IGameGrain game = base.GrainFactory.GetGrain <IGameGrain>(packet.Game); return(game.GameStarts(packet.Players)); }
public Task ChangeState(IGameGrain game, GameState oldState, GameState newState) { var gameId = game.GetPrimaryKey(); switch (oldState) { case GameState.Unstarted: _unstarted.Remove(gameId); break; case GameState.InProgress: _inProgress.Remove(gameId); break; case GameState.Finished: _finished.Remove(gameId); break; default: throw new InvalidOperationException(); } switch (newState) { case GameState.Unstarted: _unstarted.Add(gameId, game); break; case GameState.InProgress: _inProgress.Add(gameId, game); break; case GameState.Finished: _finished.Add(gameId, game); break; default: throw new InvalidOperationException(); } return TaskDone.Done; }
public Task Heartbeat(byte[] data) { HeartbeatData heartbeatData = HeartbeatDataDotNetSerializer.Deserialize(data); IGameGrain game = GrainFactory.GetGrain <IGameGrain>(heartbeatData.Game); return(game.UpdateGameStatus(heartbeatData.Status)); }
/// <summary> /// Game grain calls this method to notify that the player has left the game. /// </summary> public Task LeaveGameAsync(IGameGrain game) { currentGame = null; logger.LogInformation("Player {@PlayerKey} left game {@GameKey}", GrainKey, game.GetPrimaryKey()); return(Task.CompletedTask); }
/// <summary> /// Game grain calls this method to notify that the player has joined the game. /// </summary> public Task JoinGameAsync(IGameGrain game) { currentGame = game; logger.LogInformation("Player {@PlayerKey} joined game {@GameKey}", GrainKey, game.GetPrimaryKey()); return(Task.CompletedTask); }
public Task Create(IGameGrain game, IAccountGrain account, string name) { _game = game; _accountGrain = account; _name = name; _stars = new List <IStarGrain>(); Console.WriteLine(" -- {0,-10} -- {1} created.", "Player", _name); return(TaskDone.Done); }
// Game grain calls this method to notify that the player has left the game. public Task LeaveGame(IGameGrain game) { currentGame = null; Console.WriteLine( "Player {0} left game {1}", this.GetPrimaryKey(), game.GetPrimaryKey()); return(Task.CompletedTask); }
// Game grain calls this method to notify that the player has joined the game. public Task JoinGame(IGameGrain game) { currentGame = game; Console.WriteLine( "Player {0} joined game {1}", this.GetPrimaryKey(), game.GetPrimaryKey()); return(Task.CompletedTask); }
public Task JoinGame(IGameGrain game, IPlayerGrain player) { var primaryKey = game.GetPrimaryKey(); if (_activeGames.ContainsKey(primaryKey)) { return(TaskDone.Done); } _activeGames.Add(primaryKey, game); _activePlayers.Add(primaryKey, player); Console.WriteLine(" -- {0,-10} -- {1} joined a game.", "Account", _username); return(TaskDone.Done); }
public Task LeaveGame(IGameGrain game) { syncTimer.Dispose(); syncTimer = null; currentGame = null; Console.WriteLine("Player {0} left game {1}", this.GetPrimaryKey(), game.GetPrimaryKey()); // TODO: Have to consider a player leave a game during a running game. previous = null; return(TaskDone.Done); }
static async Task <IClusterClient> RunWatcher() { try { // Connect to local silo var config = ClientConfiguration.LocalhostSilo(); var client = new ClientBuilder().UseConfiguration(config).Build(); await client.Connect(); // Hardcoded player ID Guid playerId = new Guid("{2349992C-860A-4EDA-9590-000000000006}"); IPlayerGrain player = client.GetGrain <IPlayerGrain>(playerId); IGameGrain game = null; while (game == null) { Console.WriteLine("Getting current game for player {0}...", playerId); try { game = await player.GetCurrentGame(); if (game == null) // Wait until the player joins a game { await Task.Delay(5000); } } catch (Exception exc) { Console.WriteLine("Exception: ", exc.GetBaseException()); } } Console.WriteLine("Subscribing to updates for game {0}...", game.GetPrimaryKey()); // Subscribe for updates var watcher = new GameObserver(); await game.SubscribeForGameUpdates( await client.CreateObjectReference <IGameObserver>(watcher)); Console.WriteLine("Subscribed successfully. Press <Enter> to stop."); return(client); } catch (Exception exc) { Console.WriteLine("Unexpected Error: {0}", exc.GetBaseException()); throw; } }
public void GameStart(Guid gameId, int seconds) { currentGame = GrainFactory.GetGrain <IGameGrain>(gameId); Console.WriteLine("Player {0} joined game {1}", this.GetPrimaryKeyLong(), gameId); if (previous == null) { previous = new Progression(); } if (syncTimer == null) { syncTimer = base.RegisterTimer(TimerCallback, null, TimeSpan.Zero, TimeSpan.FromSeconds(2)); } }
private async Task StartWatcherAsync() { // observing a hardcoded player id for sample purposes // the load generator will update player ids within a range that includes this player var playerId = new Guid("{2349992C-860A-4EDA-9590-000000000006}"); var player = client.GetGrain <IPlayerGrain>(playerId); IGameGrain game = null; // poll for this player to join a game while (game == null) { logger.LogInformation("Getting current game for player {@PlayerId}...", playerId); try { game = await player.GetCurrentGameAsync(); } catch (Exception error) { logger.LogError(error, "Error while requesting current game for player {@PlayerId}", playerId); } if (game == null) { try { await Task.Delay(1000, startCancellation.Token); } catch (OperationCanceledException) { return; } } } logger.LogInformation("Observing updates for game {@GameKey}", game.GetPrimaryKey()); // subscribe for updates var watcher = client.ServiceProvider.GetService <IGameObserver>(); await game.ObserveGameUpdatesAsync( await client.CreateObjectReference <IGameObserver>(watcher)); logger.LogInformation("Subscribed successfully to game {@GameKey}", game.GetPrimaryKey()); }
public Task JoinGame(IGameGrain game) { currentGame = game; Console.WriteLine("Player {0} joined game {1}", this.GetPrimaryKeyLong(), game.GetPrimaryKey()); if (previous == null) { previous = new Progression(); } if (syncTimer == null) { syncTimer = base.RegisterTimer(TimerCallback, null, TimeSpan.Zero, TimeSpan.FromSeconds(2)); } return(TaskDone.Done); }
public async Task StartAsync(CancellationToken cancellationToken) { // the load generator will update player ids within a range that includes this player var playerId = new Guid("{2349992C-860A-4EDA-9590-000000000006}"); var player = _client.GetGrain <IPlayerGrain>(playerId); // poll for this player to join a game while (_game == null) { _logger.LogInformation("Getting current game for player {@PlayerId}...", playerId); try { _game = await player.GetCurrentGameAsync(); } catch (Exception error) { _logger.LogError(error, "Error while requesting current game for player {@PlayerId}", playerId); } if (_game == null) { try { await Task.Delay(1000, cancellationToken); } catch (OperationCanceledException) { return; } } } _logger.LogInformation("Observing updates for game {@GameKey}", _game.GetPrimaryKey()); // subscribe for updates var reference = await _client.CreateObjectReference <IGameObserver>(_observer); await _game.ObserveGameUpdatesAsync(reference); _logger.LogInformation("Subscribed successfully to game {@GameKey}", _game.GetPrimaryKey()); }
/// <summary> /// Simulates a companion application that connects to the game that a particular player is currently part of /// and subscribes to receive live notifications about its progress. /// </summary> static void Main(string[] args) { try { var config = ClientConfiguration.LocalhostSilo(); GrainClient.Initialize(config); // Hardcoded player ID Guid playerId = new Guid("{2349992C-860A-4EDA-9590-000000000006}"); IPlayerGrain player = GrainClient.GrainFactory.GetGrain <IPlayerGrain>(playerId); IGameGrain game = null; while (game == null) { Console.WriteLine("Getting current game for player {0}...", playerId); try { game = player.GetCurrentGame().Result; if (game == null) // Wait until the player joins a game { game = null; Thread.Sleep(5000); } } catch (Exception exc) { Console.WriteLine("Exception: ", exc.GetBaseException()); } } Console.WriteLine("Subscribing to updates for game {0}...", game.GetPrimaryKey()); // Subscribe for updates var watcher = new GameObserver(); game.SubscribeForGameUpdates(GrainClient.GrainFactory.CreateObjectReference <IGameObserver>(watcher).Result).Wait(); // Block main thread so that the process doesn't exit. Updates arrive on thread pool threads. Console.WriteLine("Subscribed successfully. Press <Enter> to stop."); Console.ReadLine(); } catch (Exception exc) { Console.WriteLine("Unexpected Error: {0}", exc.GetBaseException()); } }
// Reported by dedicated server manager: process created, with processId as id. public Task ProcessCreated(Guid processId) { source.Peek().SetResult(processId); IGameGrain session = GrainFactory.GetGrain <IGameGrain>(processId); session.SubscribeStatus(this); try { sessionStatus.Add(processId, true); } catch (Exception) { throw new Exception("Unexpected state: processId should NOT exist in dictionary."); } return(TaskDone.Done); }
public Task NewGame(IGameGrain game) { var gameId = game.GetPrimaryKey(); _unstarted.Add(gameId, game); return TaskDone.Done; }
public override Task OnActivateAsync() { currentGame = null; return(TaskDone.Done); }
public override Task OnActivateAsync() { currentGame = null; return TaskDone.Done; }
// Game grain calls this method to notify that the player has left the game. public Task LeaveGame(IGameGrain game) { currentGame = null; Console.WriteLine("Player {0} left game {1}", this.GetPrimaryKey(), game.GetPrimaryKey()); return TaskDone.Done; }
// Game grain calls this method to notify that the player has joined the game. public Task JoinGame(IGameGrain game) { currentGame = game; Console.WriteLine("Player {0} joined game {1}", this.GetPrimaryKey(), game.GetPrimaryKey()); return TaskDone.Done; }