async Task <Tuple <IGamePlayer, int, GameInfo> > IUser.JoinGame(long gameId, IGameObserver observer)
{
if (_joinedGameMap.ContainsKey(gameId))
{
throw new ResultException(ResultCodeType.NeedToBeOutOfGame);
}
// Try to get game ref
IActorRef gameRef;
try
{
var reply = await _clusterContext.GameTable.GetOrCreate(gameId, null);
gameRef = reply.Actor;
}
catch (Exception e)
{
_logger.Warn($"Failed in querying game from GameTable. (Id={gameId})", e);
throw new ResultException(ResultCodeType.InternalError);
}
if (gameRef == null)
{
throw new ResultException(ResultCodeType.GameNotFound);
}
var game = gameRef.Cast <GameRef>().WithRequestWaiter(this);
// Let's enter the game !
var observerForMe = CreateObserver <IGameUserObserver>();
var joinRet = await game.Join(_id, _userContext.Data.Name, observer, observerForMe);
IRequestTarget boundTarget = null;
try
{
boundTarget = await _channel.BindActorOrOpenChannel(
game.CastToIActorRef(), new[] { new TaggedType(typeof(IGamePlayer), _id) },
ActorBindingFlags.OpenThenNotification | ActorBindingFlags.CloseThenNotification,
"GameGateway", _id);
}
catch (Exception e)
{
_logger.Error($"BindActorOrOpenChannel error (Id={gameId})", e);
}
if (boundTarget == null)
{
await game.Leave(_id);
_logger.Error($"Failed in binding GamePlayer");
throw new ResultException(ResultCodeType.InternalError);
}
_joinedGameMap[gameId] = game;
return(Tuple.Create((IGamePlayer)boundTarget.Cast <GamePlayerRef>(), joinRet.Item1, joinRet.Item2));
}
Tuple <int, GameInfo> IGameSync.Join(long userId, string userName, IGameObserver observer, IGameUserObserver observerForUserActor)
{
if (_state != GameState.WaitingForPlayers)
{
throw new ResultException(ResultCodeType.GameStarted);
}
if (_players.Count > 2)
{
throw new ResultException(ResultCodeType.GamePlayerFull);
}
var playerId = _players.Count + 1;
NotifyToAllObservers((id, o) => o.Join(playerId, userId, userName));
_players.Add(new Player
{
UserId = userId,
UserName = userName,
Observer = (GameObserver)observer,
ObserverForUserActor = (GameUserObserver)observerForUserActor,
});
if (_players.Count == 2)
{
RunTask(() => BeginGame());
}
return(Tuple.Create(playerId, GetGameInfo()));
}
public MockMatch(string comments = "Penny Dreadful", string[] players = null, MagicFormat format = MagicFormat.PennyDreadful, bool SkipObservers = false)
{
Comments = comments;
if (players == null)
{
Players = new string[] { "silasary", "kaet" }
}
;
else
{
Players = players;
}
Format = format;
if (SkipObservers)
{
Observers = new IGameObserver[0];
}
else
{
var task = Resolver.Helpers.GetObserversAsync(this);
task.Wait();
Observers = task.Result;
}
}
public Task SubscribeForGameUpdates(IGameObserver subscriber)
{
if (!subscribers.IsSubscribed(subscriber))
{
subscribers.Subscribe(subscriber);
}
return(TaskDone.Done);
}
/// <summary>
/// Connects to a Snake server on the specified <see cref="Uri"/>.
/// Returns a new instance of <see cref="SnakeClient"/> that can be used
/// to interact with the server.
/// </summary>
public static SnakeClient Connect(Uri uri, IGameObserver observer)
{
var ws = new ClientWebSocket();
ws.ConnectAsync(uri, CancellationToken.None).Wait();
Task.Run(() => HearBeat(ws));
return(new SnakeClient(ws, observer));
}
public PlayerWatcherHostedService(
ILogger <PlayerWatcherHostedService> logger,
IClusterClient client,
IGameObserver observer)
{
_logger = logger;
_client = client;
_observer = observer;
}
public static SurrogateForIGameObserver Convert(IGameObserver value)
{
if (value == null)
{
return(null);
}
var o = (GameObserver)value;
return(new SurrogateForIGameObserver {
Channel = o.Channel, ObserverId = o.ObserverId
});
}
private Tuple <int, GameInfo> Enter(string userId, IGameObserver observer)
{
if (_userMap.ContainsKey(userId))
{
throw new InvalidOperationException();
}
NotifyToAllObservers(o => o.Enter(userId));
var clientId = ++_lastClientId;
var userData = new UserData
{
UserActor = Sender.Cast <UserRef>().WithRequestWaiter(this),
Observer = (GameObserver)observer,
ClientId = clientId,
};
userData.OutboundChannel = new ProtobufChannelToClientZoneOutbound
{
TypeTable = _typeTable.Value,
TypeModel = _typeModel.Value,
OutboundChannel = userData
};
userData.InboundChannel = new ProtobufChannelToServerZoneInbound
{
TypeTable = _typeTable.Value,
TypeModel = _typeModel.Value,
ClientId = clientId,
InboundServerZone = _zone
};
_userMap.Add(userId, userData);
_zone.AddClient(clientId, userData.OutboundChannel);
// TEST SPAWN
_zone.RunAction(zone =>
{
zone.Spawn(typeof(ISpaceShip), clientId, EntityFlags.Normal);
});
return(Tuple.Create(
clientId,
new GameInfo
{
Name = _name,
Users = _userMap.Keys.ToList(),
}));
}
/// <summary>
/// Initializes a new instance of the <see cref="SnakeClient" /> class that communicates
/// with a Snake server over the specified <see cref="WebSocket" /> instance.
/// The specified <see cref="IGameObserver" /> will receive notifications on applicable messages.
/// Note that the specified <see cref="WebSocket" /> does not need to be in an <see cref="WebSocketState.Open" />
/// state in order to create this instance. However, it will need to be connected before starting a game.
/// </summary>
/// <param name="socket">The specified <see cref="WebSocket" /> instance.</param>
/// <param name="observer">The specified <see cref="IGameObserver" /> instance.</param>
public SnakeClient(WebSocket socket, IGameObserver observer)
{
if (socket == null)
{
throw new ArgumentNullException(nameof(socket));
}
if (observer == null)
{
throw new ArgumentNullException(nameof(observer));
}
_socket = socket;
_observer = observer;
}
public static SnakeClient CreateSnakeClient(Uri uri, IGameObserver observer)
{
var ws = new ClientWebSocket();
ws.ConnectAsync(uri, CancellationToken.None).Wait();
new TaskFactory().StartNew(() =>
{
while (ws.State == WebSocketState.Open)
{
var msg = new JObject
{
["type"] = MessageType.HeartBeatRequest
};
SendString(JsonConvert.SerializeObject(msg), ws);
Task.Delay(TimeSpan.FromSeconds(30)).Wait();
}
});
return(new SnakeClient(ws, observer));
}
async Task<Tuple<IGamePlayer, int, GameInfo>> IUser.JoinGame(long gameId, IGameObserver observer)
{
if (_joinedGameMap.ContainsKey(gameId))
throw new ResultException(ResultCodeType.NeedToBeOutOfGame);
// Try to get game ref
IActorRef gameRef;
try
{
var reply = await _clusterContext.GameTable.GetOrCreate(gameId, null);
gameRef = reply.Actor;
}
catch (Exception e)
{
_logger.Warn($"Failed in querying game from GameTable. (Id={gameId})", e);
throw new ResultException(ResultCodeType.InternalError);
}
if (gameRef == null)
throw new ResultException(ResultCodeType.GameNotFound);
var game = gameRef.Cast<GameRef>().WithRequestWaiter(this);
// Let's enter the game !
var observerForMe = CreateObserver<IGameUserObserver>();
var joinRet = await game.Join(_id, _userContext.Data.Name, observer, observerForMe);
IRequestTarget boundTarget = null;
try
{
boundTarget = await _channel.BindActorOrOpenChannel(
game.CastToIActorRef(), new[] { new TaggedType(typeof(IGamePlayer), _id) },
ActorBindingFlags.OpenThenNotification | ActorBindingFlags.CloseThenNotification,
"GameGateway", _id);
}
catch (Exception e)
{
_logger.Error($"BindActorOrOpenChannel error (Id={gameId})", e);
}
if (boundTarget == null)
{
await game.Leave(_id);
_logger.Error($"Failed in binding GamePlayer");
throw new ResultException(ResultCodeType.InternalError);
}
_joinedGameMap[gameId] = game;
return Tuple.Create((IGamePlayer)boundTarget.Cast<GamePlayerRef>(), joinRet.Item1, joinRet.Item2);
}
public void AddObserver(IGameObserver observer)
{
m_dealer.AddObserver(observer);
}
/*
* IGameObserver Methods
*/
public void addGameObserver(IGameObserver go)
{
this.observers.Add(go);
}
public void AddObvs(IGameObserver toAdd)
{
_obvs.Add(toAdd);
}
public void Attach(IGameObserver observer)
{
_observers.Add(observer);
}
public void Subscribe(IGameObserver subject)
{
// TODO : Add check
observers.Add(subject);
}
public Task UnsubscribeStatus(IGameObserver subscriber)
{
subscribers.Unsubscribe(subscriber);
return(TaskDone.Done);
}
//取消订阅指定类型的事件
public void Remove(Type subjectType, IGameObserver observer)
{
GetSubject(subjectType).Remove(observer);
}
public void AddHealthObserver(IGameObserver o)
{
healthObservers.Add(o);
}
async Task <Tuple <IGameClient, int, GameInfo> > IUser.EnterGame(string name, IGameObserver observer)
{
if (_enteredGame != null)
{
throw new InvalidOperationException();
}
// try to get game ref
IActorRef actor;
try
{
actor = await Context.ActorSelection("/user/game_" + name).ResolveOne(TimeSpan.Zero);
}
catch (ActorNotFoundException)
{
actor = Context.System.ActorOf(Props.Create(() => new GameActor(name)), "game_" + name);
}
var game = actor.Cast <GameRef>().WithRequestWaiter(this);
// enter the game
var join = await game.Enter(_id, observer);
// Bind an game actor to channel
var boundActor = await _channel.BindActor(game.CastToIActorRef(),
new[] { new TaggedType(typeof(IGameClient), _id) });
if (boundActor == null)
{
await game.Leave(_id);
_logger.Error($"Failed in binding GameClient");
throw new InvalidOperationException();
}
_enteredGame = game;
return(Tuple.Create((IGameClient)boundActor.Cast <GameClientRef>(), join.Item1, join.Item2));
}
public void Register(IGameObserver observer)
{
observers.Add(observer);
}
public void Remove(IGameObserver observer)
{
observers.Remove(observer);
}
public void AddObserver(IGameObserver observer)
{
m_observer.Add(observer);
}
public void Unsubscribe(IGameObserver subject)
{
// TODO : Add check
observers.Remove(subject);
}
void IGameObservable.removeObserver(IGameObserver newObserver)
{
observers.Remove(newObserver);
}
public static SurrogateForIGameObserver Convert(IGameObserver value)
{
if (value == null) return null;
var o = (GameObserver)value;
return new SurrogateForIGameObserver { Channel = o.Channel, ObserverId = o.ObserverId };
}
private IEnumerator ProcessJoinGameInternal()
{
G.Logger.Info("ProcessJoinGame");
// Finding Game
// Register user to pairing queue and waiting for 5 secs.
LoadingText.text = "Finding Game...";
_pairedGame = null;
var pairingObserver = G.Communicator.ObserverRegistry.Create<IUserPairingObserver>(this);
yield return G.User.RegisterPairing(pairingObserver).WaitHandle;
var startTime = DateTime.Now;
while ((DateTime.Now - startTime).TotalSeconds < 5 && _pairedGame == null && _isLeaveRequested == false)
{
yield return null;
}
G.Communicator.ObserverRegistry.Remove(pairingObserver);
if (_isLeaveRequested)
yield break;
if (_pairedGame == null)
{
yield return G.User.UnregisterPairing().WaitHandle;
if (_isLeaveRequested == false)
yield return UiMessageBox.Show("Cannot find game").WaitForHide();
SceneManager.LoadScene("MainScene");
yield break;
}
// Join Game
var gameObserver = G.Communicator.ObserverRegistry.Create<IGameObserver>(this, startPending: true);
gameObserver.GetEventDispatcher().KeepingOrder = true;
var roomId = _pairedGame.Item1;
var joinRet = G.User.JoinGame(roomId, gameObserver);
yield return joinRet.WaitHandle;
if (joinRet.Exception != null)
{
G.Communicator.ObserverRegistry.Remove(gameObserver);
var box = UiMessageBox.Show("Failed to join\n" + joinRet.Exception);
yield return StartCoroutine(box.WaitForHide());
SceneManager.LoadScene("MainScene");
}
_gameObserver = gameObserver;
_gameInfo = joinRet.Result.Item3;
_myPlayerId = joinRet.Result.Item2;
_myPlayer = (GamePlayerRef)joinRet.Result.Item1;
if (_myPlayer.IsChannelConnected() == false)
{
var connectTask = _myPlayer.ConnectChannelAsync();
yield return connectTask.WaitHandle;
if (connectTask.Exception != null)
{
var box = UiMessageBox.Show("Failed to connect\n" + joinRet.Exception);
G.Communicator.ObserverRegistry.Remove(gameObserver);
yield return StartCoroutine(box.WaitForHide());
_myPlayer = null;
yield break;
}
((IChannel)_myPlayer.RequestWaiter).StateChanged += (_, state) =>
{
if (state == ChannelStateType.Closed)
ChannelEventDispatcher.Post(OnChannelClose, _);
};
}
gameObserver.GetEventDispatcher().Pending = false;
LoadingText.text = "Waiting for " + _pairedGame.Item2 + "...";
}
Tuple<int, GameInfo> IGameSync.Join(long userId, string userName, IGameObserver observer, IGameUserObserver observerForUserActor)
{
if (_state != GameState.WaitingForPlayers)
throw new ResultException(ResultCodeType.GameStarted);
if (_players.Count > 2)
throw new ResultException(ResultCodeType.GamePlayerFull);
var playerId = _players.Count + 1;
NotifyToAllObservers((id, o) => o.Join(playerId, userId, userName));
_players.Add(new Player
{
UserId = userId,
UserName = userName,
Observer = (GameObserver)observer,
ObserverForUserActor = (GameUserObserver)observerForUserActor,
});
if (_players.Count == 2)
RunTask(() => BeginGame());
return Tuple.Create(playerId, GetGameInfo());
}
public void RemoveObvs(IGameObserver toRemove)
{
_obvs.Remove(toRemove);
}
public void RemoveHealthObserver(IGameObserver o)
{
healthObservers.Remove(o);
}
public void Detach(IGameObserver observer)
{
_observers.Remove(observer);
}
public Task UnsubscribeForGameUpdates(IGameObserver subscriber)
{
subscribers.Unsubscribe(subscriber);
return TaskDone.Done;
}
public void AddLevelObserver(IGameObserver o)
{
levelObservers.Add(o);
}
//注册指定类型的事件
public void Register(Type subjectType, IGameObserver observer)
{
GetSubject(subjectType).Register(observer);
}
public void RemoveLevelObserver(IGameObserver o)
{
levelObservers.Remove(o);
}
void IGameObservable.registerObserver(IGameObserver newObserver)
{
observers.Add(newObserver);
}
public void AddScoreObserver(IGameObserver o)
{
scoreObservers.Add(o);
}
public Task UnsubscribeForGameUpdates(IGameObserver subscriber)
{
subscribers.Unsubscribe(subscriber);
return(TaskDone.Done);
}
public void RemoveScoreObserver(IGameObserver o)
{
scoreObservers.Remove(o);
}
