public async Task Connect(Guid userId, Guid connectionId)
{
EnsureGameIsNotStarted();
if (!_playerListEditor.Contains(userId))
{
var player = _playerListEditor.Add(userId);
var playerJoined = new PlayerJoined(_state.RoomId, player);
if (_playerListEditor.Count == 1)
{
_mapEditor.Generate();
}
if (!_mapEditor.CanPlacePlanet)
{
var options = new GameOptionsData
{
MapWidth = _mapEditor.MapWidth + 1,
MapHeight = _mapEditor.MapHeigth + 1,
NeutralPlanetsCount = _mapEditor.NeutralPlanetsCount
};
_mapEditor.Generate(options);
}
_mapEditor.PlacePlanet(userId);
var mapUpdated = new MapUpdated(_state.RoomId, _state.MapEditor.Map);
await _hub.NotifyEverybodyExcept(userId, playerJoined, mapUpdated);
}
await _hub.Connect(userId, connectionId);
}
private void UpdateConnectionsList(NetConnection connection, NetConnectionStatus status)
{
if (status == NetConnectionStatus.Connected)
{
string name = connection.RemoteHailMessage.ReadString();
Output(name + " @" + connection.RemoteEndPoint + " has connected");
ConnectionInfo info = new ConnectionInfo {
Name = name, Connection = connection
};
_connectionInfoList.Add(info);
if (PlayerJoined != null)
{
PlayerJoined.Invoke(info, null);
}
}
else if (status == NetConnectionStatus.Disconnected)
{
ConnectionInfo info = _connectionInfoList.Find((x) => { return(x.Connection == connection); });
Output(info.Name + " @" + connection.RemoteEndPoint + " has disconnected");
_connectionInfoList.Remove(info);
if (PlayerLeft != null)
{
PlayerLeft.Invoke(info, null);
}
// _connectionInfoList.RemoveAll((x)=> { return x.Connection == connection;});
}
}
void CheckStreamsReceived()
{
if (InitJsonReceived && WaspJsonReceived && PlayerJsonReceived)
{
if (initLauncher == null)
{
return;
}
if (playerJsonData.Length == 1)
{
initLauncher.Initialize(initJsonData, waspJsonData);
if (ControllerReferences.MultiPlayer == null)
{
playerSetup.SetActive(true);
}
}
else
{
initLauncher.Initialize(initJsonData, waspJsonData, playerJsonData);
changePlayer.SetActive(true);
}
progressBars.gameObject.SetActive(false);
if (SceneManager.GetActiveScene().name == playScene)
{
PlayerJoined.Create().Send();
}
}
}
public async Task <Result <Player, JoinGameError> > JoinGameAsync(GameId gameId, string playerName)
{
var result = await _gameRepository.GetGameAndVersionAsync(gameId);
return(await result.Map <Task <Result <Player, JoinGameError> > >(
async gameAndVersion =>
{
var(game, version) = gameAndVersion;
if (game.Players.Count >= Models.Game.MaxNumberOfPlayers)
{
return JoinGameError.GameFull;
}
var playerJoined = new PlayerJoined(playerName);
await _eventRepository.AddEventAsync(gameId, playerJoined, version);
var changedResources = playerJoined.ApplyAndGetModifiedResources(game);
var changedResourceNames = ChangedResourcesResolver.GetResourceNames(changedResources);
await _gameEventService.NotifyWorldUpdatedAsync(game.Id, changedResourceNames.ToArray());
return Convert(game.Players.Last());
},
readGameError =>
{
return readGameError switch
{
ReadGameError.NotFound => Task.FromResult(new Result <Player, JoinGameError>(JoinGameError.GameNotFound)),
_ => throw new ArgumentOutOfRangeException(nameof(readGameError), readGameError, null)
};
}));
private void When(PlayerJoined @event)
{
if (!Players.TryAdd(@event.PlayerId, new Player(@event.PlayerId, @event.PlayerName, _domainEventPublisher)))
{
Console.WriteLine($"player {@event.PlayerId} is already added");
}
}
internal virtual void OnPlayerJoined(RoomPlayerEventArgs e)
{
if (Disposed)
{
return;
}
PlayerJoined?.Invoke(this, e);
RoomManager.Channel.BroadcastCencored(new RoomChangeRoomInfoAck2Message(GetRoomInfo()));
}
public override bool Equals(object obj)
{
PlayerJoined other = obj as PlayerJoined;
if (other == null)
{
return(false);
}
return(userID == other.userID);
}
private void AckPlayerJoinedBroadcast(int userID, PlayerJoined playerJoined)
{
var list = pendingPlayerJoined[playerJoined.UserID];
list.RemoveAll(x => x == userID);
if (list.Count == 0)
{
pendingPlayerJoined.Remove(playerJoined.UserID);
clients[playerJoined.UserID].Confirm();
}
}
private void UserAccepted(ulong steamId)
{
typeof(MyDedicatedServerBase).GetMethod("UserAccepted", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(MyMultiplayer.Static, new object[] { steamId });
var vm = new PlayerViewModel(steamId)
{
State = ConnectionState.Connected
};
Log.Info($"Player {vm.Name} joined ({vm.SteamId})");
Players.Add(steamId, vm);
PlayerJoined?.Invoke(vm);
}
private void PlayerConnected(long playerId)
{
MyAPIGateway.Utilities.InvokeOnGameThread(() =>
{
Refresh();
PlayerAuxData aux;
if (_playerById.TryGetValue(playerId, out aux) && aux.RealPlayer != null)
{
PlayerJoined?.Invoke(aux.RealPlayer);
}
});
}
public void Handle(PlayerJoined e)
{
var user = _db.Users.GetById(e.UserId);
_tables.Update(e.Id, table => table.Players.Add(new PlayerDocument()
{
UserId = e.UserId,
Position = e.Position,
Cash = e.Cash,
Name = user.UserName,
AvatarId = user.AvatarId
}));
}
