public async Task JoinOrCreateRoom(string roomName, string playerName)
{
#region 因为Context的不一样,导致广播调用不到函数,所以其他hub必须加入Context才行,所以先只是创建而已,等作者添加支持
var result = RoomManager.GetRoom(roomName, out _room);
if (result)
{
await RoomManager.JoinRoom(_room, Context);
}
else
{
_room = await Group.AddAsync(roomName);
RoomManager.AddRoom(_room);
}
_playerName = playerName;
#endregion
Broadcast(_room).OnJoinRoom(playerName);
Console.WriteLine($"{playerName} Join {roomName} Room.");
}
public async Task <JoinResult> JoinAsync(string roomName, string playerName, string userId)
{
Guid connectionId = this.Context.ContextId;
GrpcEnvironment.Logger.Debug("VoiceChatHub - ConnectionId: " + connectionId);
self = RoomManager.Instance.JoinOrCreateRoom(roomName, playerName, userId);
Player[] roomPlayers = RoomManager.Instance.GetRoom(roomName).GetPlayers();
GrpcEnvironment.Logger.Debug("VoiceChatHub - PlayerCount: " + roomPlayers.Length);
currentRoom = roomName;
if (self.ActorNumber >= 0)
{
this.group = await Group.AddAsync(roomName);
BroadcastExceptSelf(group).OnJoin(self);
// Broadcast(group).OnJoin(self);
}
return(new JoinResult()
{
LocalPlayer = self
});
}
public async Task JoinAsync(ChatJoinRequest request)
{
room = await Group.AddAsync(request.RoomName);
myName = request.UserName;
Broadcast(room).OnJoin(request.UserName);
}
public async Task JoinAsync(string roomName, PlayerIdentifier playerIdentifier)
{
(room, storage) = await Group.AddAsync(roomName, playerIdentifier);
self = playerIdentifier;
BroadcastExceptSelf(room).Join(playerIdentifier);
Players = storage.AllValues;
join.OnNext(roomName);
}
public async Task <Player[]> JoinAsync(string roomName, string playerId, string playerName)
{
self = new Player(playerId, playerName);
(room, storage) = await Group.AddAsync(roomName, self);
BroadcastExceptSelf(room).OnJoin(self);
return(storage.AllValues.ToArray());
}
public async Task JoinAsync(string name, string room)
{
_player = new Player {
Name = name, Room = room
};
await Console.Out.WriteLineAsync($"Join {_player.Name} to the {_player.Room}");
(_room, _) = await Group.AddAsync(_player.Room, _player);
Broadcast(_room).OnJoin(_player);
}
protected override ValueTask OnConnecting()
{
AccessControlHub
.JoinAsObservable
.Subscribe(async groupName => room = await Group.AddAsync(groupName));
AccessControlHub
.LeaveAsObservable
.Subscribe(async _ => await room.RemoveAsync(Context));
return(CompletedTask);
}
public async Task <Player[]> JoinAsync(string roomName, string userName)
{
_player = new Player()
{
Name = userName
};
(_room, _storage) = await Group.AddAsync(roomName, _player);
Console.WriteLine($"player [{userName}] joined to room [{roomName}].");
Broadcast(_room).OnJoin(_player);
return(_storage.AllValues.ToArray());
}
protected override async ValueTask OnConnecting()
{
nodeId = Guid.Parse(Context.CallContext.RequestHeaders.GetValue("node-id"));
// TODO:use specified id???
var group = await Group.AddAsync("global-masterhub-group");
var broadcaster = group.CreateBroadcaster <IWorkerReceiver>();
workerConnectionContext.Broadcaster = broadcaster;
workerConnectionContext.AddConnection(nodeId);
}
public async Task <Player[]> JoinAsync(string roomName, string userName, Vector3 position, Quaternion rotation)
{
self = new Player()
{
Name = userName, Position = position, Rotation = rotation
};
(room, storage) = await Group.AddAsync(roomName, self);
Broadcast(room).OnJoin(self);
return(storage.AllValues.ToArray());
}
public async Task <Player[]> JoinAsync(string roomName, string userName, double position, double rotation)
{
self = new Player()
{
Name = userName, Position = position, Rotation = rotation
};
// Group can bundle many connections and it has inmemory-storage so add any type per group.
(room, storage) = await Group.AddAsync(roomName, self);
// Typed Server->Client broadcast.
Broadcast(room).OnJoin(self);
return(storage.AllValues.ToArray());
}
public async Task <PlayerMPO[]> JoinAsync(string roomName, PlayerMPO player)
{
Console.Out.WriteLine($"JoinAsync:{roomName},{player.Name}");
//自分の情報を保持
self = player;
//ルームに参加&ルームを保持
(room, storage) = await Group.AddAsync(roomName, self);
//参加したことをルームに参加している全メンバーに通知
this.Broadcast(room).OnJoin(self);
return(storage.AllValues.ToArray());
}
public async Task <Player[]> JoinAsync(string roomName, string userName, Vector3 position, Quaternion rotation)
{
player = new Player()
{
Name = userName, Position = position, Rotation = rotation
};
(room, storage) = await Group.AddAsync(roomName, player);
Broadcast(room).OnJoin(player);
// ReSharper disable once HeapView.BoxingAllocation
Console.WriteLine($"JoinAsync - {storage.AllValues.Count}");
return(storage.AllValues.ToArray());
}
public async Task <Player[]> JoinAsync(string roomName, string userName, Vector3 position, Quaternion rotation)
{
Console.WriteLine("JoinAsync " + userName);
self = new Player()
{
Name = userName, Position = position, Rotation = rotation
};
// Group은 많은 연결들을 묶을 수 있고, 이것은 메모리 저장소를 가지므로 그룹마다 어떠한 타입도 추가할 수 있다.
(room, storage) = await Group.AddAsync(roomName, self);
// 서버->클라이언트로 브로드캐스팅 한다.
Broadcast(room).OnJoin(self);
return(storage.AllValues.ToArray());
}
private async Task When(JoinCommand cmd)
{
_group = await Group.AddAsync(cmd.RoomName);
var application = _applications.GetOrAdd(cmd.RoomName,
newRoomName => new ARWorldApplication(newRoomName, new EventStore(), new DomainEventPublisher()));
_roomName = cmd.RoomName;
application.DomainEventPublisher.EventStream
.Subscribe(e =>
{
switch (e)
{
case PlayerJoined joined:
BroadcastToSelf(_group).OnEvent(joined);
Console.WriteLine($"joined: {joined.PlayerId} as {joined.PlayerName} to {joined.RoomName}");
break;
case PlayerLeft left:
BroadcastToSelf(_group).OnEvent(left);
Console.WriteLine($"left: {left.PlayerId}");
break;
case PlayerSpoke playerSpoke:
BroadcastToSelf(_group).OnEvent(playerSpoke);
Console.WriteLine($"spoke: {playerSpoke.PlayerId} like {playerSpoke.Message}");
break;
case PlayerMoved playerMoved:
BroadcastToSelf(_group).OnEvent(playerMoved);
// Console.WriteLine($"spoke: {playerSpoke.PlayerId} like {playerSpoke.Message}");
break;
}
}).AddTo(_disposables);
application.Execute(cmd);
BroadcastToSelf(_group).OnEvent(
new ARWorldEventStream()
{
RoomName = _roomName,
EventStream = application.EventStore.LoadEventStream()
});
}
/// <summary>
/// >マッチング時に与えられたルーム名をもとにゲーム準備を宣言
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task GameReadyAsync(GameReadyRequest request)
{
IsConnected = true;
MineId = request.MineId;
EnemyId = request.EnemyId;
WithOther = request.WithOther;
// ゲームループ作成
ServerMainGameLoop.LoopData data = new ServerMainGameLoop.LoopData(MineId, EnemyId, this, NetworkInput);
ServerMainGameLoop.CreateNew(looperPool, logger, data);
// ゲーム部屋に放り込む
gameRoom = await Group.AddAsync(request.RoomName);
if (WithOther)
{ // 2P
var memberNum = await gameRoom.GetMemberCountAsync();
if (memberNum == 2)
{ // 2人揃ったらゲームを開始してよい
logger.LogInformation($"GameReady at {MineId}");
var param = new Dictionary <string, IReadOnlyList <short> >();
// 互いの情報取得
var mineLoop = ServerMainGameLoop.TryTakeGame(MineId);
var enemLoop = ServerMainGameLoop.TryTakeGame(EnemyId);
param[MineId] = mineLoop.PlayingState.Board;
param[EnemyId] = enemLoop.PlayingState.Board;
var res = new GameReadyResponse {
RoomName = request.RoomName, PlayerBoards = param
};
Broadcast(gameRoom).OnGameReady(res);
}
}
else
{ // 1P / 速攻でスタート
logger.LogInformation($"GameReady at {MineId}");
var loop = ServerMainGameLoop.TryTakeGame(request.MineId);
var param = new Dictionary <string, IReadOnlyList <short> >();
param[MineId] = loop.PlayingState.Board;
BroadcastToSelf(gameRoom).OnGameReady(new GameReadyResponse {
RoomName = request.RoomName, PlayerBoards = param
});
}
}
public async Task <Player[]> JoinAsync()
{
const string roomName = "SampleRoom";
room = await Group.AddAsync(roomName);
int _idPlayer = (await room.GetMemberCountAsync() > 1) ? 2 : 1;
await room.RemoveAsync(Context);
self = new Player()
{
IdPlayer = _idPlayer, IdFill = _idPlayer
};
Console.Write("\nPlayer " + self.IdPlayer);
(room, playerStorage) = await Group.AddAsync(roomName, self);
Broadcast(room).OnJoin(self);
return(playerStorage.AllValues.ToArray());
}
public async Task <JoinResult> JoinAsync(string name)
{
_self = new ChatRoomMember()
{
Name = name
};
(_room, _members) = await Group.AddAsync(GroupIdentifier, _self);
_self.Id = _members.AllValues.Count;
Broadcast(_room).OnJoin(_self);
return(new JoinResult()
{
You = _self,
OtherMembers = _members.AllValues.Where(mem => mem.Id != _self.Id).ToArray()
});
}
/// <summary>
/// マッチング参加(マッチングはでき次第通知)
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task JoinAsync(MatchingJoinRequest request)
{
// 待合室に放り込む
matchingRoom = await Group.AddAsync("MatchingRoom");
if (request.withOther)
{ // 誰かとマッチングして対戦
// マッチング処理(今は単純にアクセスしてきた順にマッチングさせる)
MatchingRoomManager.Data data = new MatchingRoomManager.Data(ConnectionId, Context);
(string, MatchingRoomManager.Data)addResult = roomManager.TryMatching(data);
if (!string.IsNullOrEmpty(addResult.Item1))
{
// マッチング対象から外す
roomManager.RemoveFromMatchingRoom(data.Id);
roomManager.RemoveFromMatchingRoom(addResult.Item2.Id);
// マッチングした者同士、部屋番号だけ教えるのであとは対戦サーバーにて再集結させる
var mineId = ConnectionId.ToString();
var enemyId = addResult.Item2.Guid.ToString();
BroadcastToSelf(matchingRoom).OnMatchingSuccess(new MatchingRequestSuccessResponse {
MineId = mineId, EnemeyId = enemyId, RoomName = addResult.Item1
});
BroadcastTo(matchingRoom, addResult.Item2.Guid).OnMatchingSuccess(new MatchingRequestSuccessResponse {
MineId = enemyId, EnemeyId = mineId, RoomName = addResult.Item1
});
// マッチングルーム本体から退出させる
await matchingRoom.RemoveAsync(addResult.Item2.Context);
await matchingRoom.RemoveAsync(Context);
}
}
else
{ // 1人でネットワーク(スコア更新用) / 特にすることもないので専用の部屋を作ってプレイしてもらう
BroadcastToSelf(matchingRoom).OnMatchingSuccess(new MatchingRequestSuccessResponse {
MineId = ConnectionId.ToString(), EnemeyId = "", RoomName = roomManager.GenerateRoomId()
});
// マッチングルーム本体から退出させる
await matchingRoom.RemoveAsync(Context);
}
}
public async Task <PlayerData[]> JoinAsync(string roomName, string userName)
{
self = new PlayerData()
{
Name = userName,
Uuid = Context.ContextId
};
(room, storage) = await Group.AddAsync(roomName, self);
PlayerData[] connectedPlayers = storage.AllValues.ToArray();
bool isUserHost = (connectedPlayers.Length == 1);
self.IsHost = isUserHost;
Console.WriteLine(userName + " / " + self.Uuid + " connected to + " + roomName + "! isHost = " + isUserHost);
BroadcastToSelf(room).OnReceiveLobbyInfo(connectedPlayers);
Broadcast(room).OnJoin(self);
return(connectedPlayers);
}
public async Task <PlayerNetworkObject> MatchMake(string pass)
{
self = new PlayerNetworkObject {
Id = storage == null ? 0 : storage.AllValues.Count,
Position = new float[] { 0, 0, 0 },
Rotation = new float[] { 0, 0, 0, 0 },
Character = storage == null ? Character.BG72 : Character.SG27,
Velocity = new float[] { 0, 0, 0 }
};
if (storage != null)
{
if (storage.AllValues.Count > 1)
{
return(null);
}
}
(room, storage) = await Group.AddAsync(pass, self);
if (storage.AllValues.Count == 2)
{
Broadcast(room).MatchMade(storage.AllValues.ToArray());
}
return(self);
}
public async Task JoinRoom()
{
room = await Group.AddAsync("test_group");
}
protected override async ValueTask OnConnecting()
{
var group = await Group.AddAsync("global-masterhub-group");
_broadcaster = group.CreateBroadcaster <IEchoHubReceiver>();
}
async Task IUnityChanController.RegisterAsync()
{
_group = await Group.AddAsync("UnityLibrary");
}
public async Task JoinAsync(string addressHex)
{
_addressGroup = await Group.AddAsync(addressHex);
}
public async Task JoinAsync()
{
group = await Group.AddAsync(string.Empty);
}
public async Task JoinAsync(string userName, string roomName)
{
this.userName = userName;
this.room = await Group.AddAsync("InMemoryRoom:" + roomName);
}
protected override async ValueTask OnConnecting()
{
group = await Group.AddAsync("global");
}
public async Task <SyncObjectTransform> RegisterAsync(string name)
{
room = await Group.AddAsync(name);
return(currentSyncObjectTransform);
}
