private void OnLeaveButtonClick()
{
ToggleActiveState();
NetworkingService.LeaveRoom(true, () =>
{
SceneManager.LoadScene("Main");
});
}
private void Awake()
{
defaultOutlineWidth = playerOneHead.outlineWidth;
playerOneHead.outlineWidth = playerTurnOutlineWidth;
GameBoardHandler.OnSetupFinished += OnSetupFinished;
NetworkingService.AddGameEventListener(NameOfTurnFinishedEvent, OnTurnFinished);
}
private void Awake()
{
State = GameState.WaitingForPlayers;
GameBoardHandler.OnSetupFinished += OnGameBoardSetupFinish;
GameBoardHandler.OnGameFinished += OnGameFinished;
NetworkingService.AddClientsLoadedSceneListener(OnAllClientsLoadedScene);
}
// <summary>Called when the join lobby button is pressed to jon the currently selected lobby</summary>
public void JoinSelectedLobby()
{
ListItem lobbyItem = lobbyListItems.CurrentSelected;
if (lobbyItem != null)
{
NetworkingService.JoinLobby(lobbyItem.TxtName.text);
}
}
public void Init()
{
_gcSpeechRecognition = GCSpeechRecognition.Instance;
_networkingService = new NetworkingService();
_networkingService.NetworkResponseEvent += NetworkResponseEventHandler;
CurrentConfig = Resources.Load <Config>("GCSpeechRecognitonConfig");
}
private void OnDestroy()
{
joinRoomForm.RemoveListener(OnJoinRoomFinish);
btnCreate.onClick.RemoveListener(ToggleCreateRoomForm);
btnJoin.onClick.RemoveListener(OnJoinbuttonClick);
NetworkingService.RemoveRoomListListener(UpdateListItemsWithRoomData);
}
/// <summary>Setsup player color picking and shares the first available color as this clients player color property</summary>
private void SetupPlayerColorButton()
{
RefreshPlayerColorButtonListeners();
playerColorPicker.UpdateAvailableColors();
//set first available color from color picker as player color property
NetworkingService.UpdateClientProperty(ClientHandler.PlayerColorKey, playerColorPicker.FirstAvailableColor);
}
private void CreatePlayerPawns(bool isPlayerOne)
{
Transform lineup = isPlayerOne ? playerOneSpawns : playerTwoSpawns;
string nameOfPrefab = isPlayerOne ? nameOfDiskPrefab : nameOfCrossPrefab;
foreach (Transform child in lineup)
{
pawns.Add(NetworkingService.InstantiateOwnedObject(nameOfPrefab, child.position, child.rotation));
}
}
private static async Task Start()
{
using (var networkingService = new NetworkingService(
new TcpClientWrapper(),
new IoService(),
new ConfigurationProvider()))
{
await networkingService.Connect();
}
}
private void OnDestroy()
{
playerColorPicker.OnColorPicked -= OnColorPicked;
playerColorPicker.OnCancel -= ToggleInteractabilityOfColorButton;
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.JoinedRoom, OnJoinedRoom);
NetworkingService.RemoveCallbackListener(InRoomCallbackEvent.ClientJoined, OnRoomUpdate);
NetworkingService.RemoveCallbackListener(InRoomCallbackEvent.ClientLeft, OnRoomUpdate);
NetworkingService.RemoveCallbackListener(InRoomCallbackEvent.HostChanged, OnRoomUpdate);
NetworkingService.RemoveClientPropertyUpdateListener(OnClientPropertyUpdate);
}
public static void Register()
{
if (registered)
{
return;
}
NetworkingService.RegisterCustomSerializable(typeof(TurnFinishedInfo), 'T', TurnFinishedInfo.Serialize, TurnFinishedInfo.Deserialize);
NetworkingService.RegisterGameEvent(TurnManager.NameOfTurnFinishedEvent, typeof(TurnFinishedInfo));
registered = true;
}
private void Start()
{
ToggleCreateRoomForm();
ToggleJoinRoomForm();
btnCreate.onClick.AddListener(ToggleCreateRoomForm);
btnJoin.onClick.AddListener(OnJoinbuttonClick);
joinRoomForm.AddListener(OnJoinRoomFinish);
NetworkingService.AddRoomListListener(UpdateListItemsWithRoomData);
}
private void Awake()
{
playerColorPicker.OnColorPicked += OnColorPicked;
playerColorPicker.OnCancel += ToggleInteractabilityOfColorButton;
MultiplayerRegistrations.Register();
NetworkingService.AddCallbackListener(MatchmakingCallbackEvent.JoinedRoom, OnJoinedRoom);
NetworkingService.AddCallbackListener(InRoomCallbackEvent.ClientJoined, OnRoomUpdate);
NetworkingService.AddCallbackListener(InRoomCallbackEvent.ClientLeft, OnRoomUpdate);
NetworkingService.AddCallbackListener(InRoomCallbackEvent.HostChanged, OnRoomUpdate);
NetworkingService.AddClientPropertyUpdateListener(OnClientPropertyUpdate);
}
public Layer3ExtensionTests(ITestOutputHelper testLog)
{
var testOutput = new XunitTraceListener(testLog);
Trace.Listeners.Add(testOutput);
OpenStackNet.Tracing.Http.Listeners.Add(testOutput);
// The operator identity is necessary to create external networks
var authenticationProvider = TestIdentityProvider.GetOperatorIdentity();
_networkingService = new NetworkingService(authenticationProvider, "RegionOne");
_testData = new NetworkingTestDataManager(_networkingService);
var compute = new ComputeService(authenticationProvider, "RegionOne");
_computeTestData = new ComputeTestDataManager(compute);
}
private void OnDestroy()
{
btnMultiplayer.onClick.RemoveListener(OnMultiplayerButtonClick);
btnOffline.onClick.RemoveListener(OnOfflineButtonClick);
btnSettings.onClick.RemoveListener(OnSettingsButtonClick);
lobbyListItems.RemoveListener(OnLobbyItemSelect);
roomListItems.RemoveListener(OnRoomItemSelect);
//remove listeners on destroy
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.Disconnected, OnDisconnected);
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.JoinedLobby, OnJoinedLobby);
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.JoinedRoom, OnJoinedRoom);
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.LeftRoom, OnLeftRoom);
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.LeftLobby, OnLeftLobby);
NetworkingService.RemoveCallbackListener(MatchmakingCallbackEvent.CreatedRoom, OnCreatedRoom);
}
/// <summary>Starts offline mode and switches to offline mode buttons</summary>
private void OnOfflineButtonClick()
{
if (!NetworkingService.IsConnected)
{
ChangeGroupFocus("OfflineButtons");
NetworkingService.SetOffline(true);
}
else
{
NetworkingService.Disconnect(() =>
{
ChangeGroupFocus("OfflineButtons");
NetworkingService.SetOffline(true);
});
}
}
public Layer3ExtensionTests(ITestOutputHelper testLog)
{
var testOutput = new XunitTraceListener(testLog);
Trace.Listeners.Add(testOutput);
OpenStackNet.Tracing.Http.Listeners.Add(testOutput);
// The operator identity is necessary to create external networks
var authenticationProvider = TestIdentityProvider.GetOperatorIdentity();
_networkingService = new NetworkingService(authenticationProvider, "RegionOne");
_testData = new NetworkingTestDataManager(_networkingService);
var compute = new ComputeService(authenticationProvider, "RegionOne");
_computeTestData = new ComputeTestDataManager(compute);
}
public void ContainsPort_Mac_returns_true_if_port_is_listening(int port, bool isListening, string fileName)
{
FileInfo responseFile = new FileInfo(Path.Combine(Directory.GetCurrentDirectory(), "SystemResponses", "Mac", fileName));
if (!responseFile.Exists)
throw new FileNotFoundException($"Could not find test file: {responseFile.FullName}");
_runtimeInfoMock.Setup(m => m.NewLine).Returns("\n").Verifiable();
_runtimeInfoMock.Setup(m => m.IsMac).Returns(true).Verifiable();
string netstatResponse = File.ReadAllText(responseFile.FullName);
NetworkingService service = (NetworkingService)CreateService();
Assert.Equal(isListening, service.ContainsNetstatPort(netstatResponse, port));
_runtimeInfoMock.Verify();
}
private void Awake()
{
var clients = NetworkingService.ClientsInRoom;
if (clients.Count != 2)
{
Debug.LogError("for this game there can only be 2 clients");
return;
}
InitGridState();
SetupPlayerDistinction(clients);
playerOneHead.alpha = 0f;
playerTwoHead.alpha = 0f;
NetworkingService.AddClientsLoadedSceneListener(OnAllClientsLoadedScene);
NetworkingService.AddGameEventListener(TurnManager.NameOfTurnFinishedEvent, OnTurnFinished);
}
public void SetupDefaultTestValues()
{
_configMock = new Mock <IConfigurationProvider>();
_configMock.Setup(m => m.Host).Returns(_host);
_configMock.Setup(m => m.Port).Returns(_port);
_configMock.Setup(m => m.Nickname).Returns("nickname");
_configMock.Setup(m => m.Username).Returns("username");
_configMock.Setup(m => m.RealName).Returns("realname");
_tcpClientMock = new Mock <ITcpClientWrapper>();
_tcpClientMock.Setup(m => m.ConnectAsync(_host, _port)).Returns(Task.CompletedTask);
_tcpClientMock.Setup(m => m.GetStream()).Returns((NetworkStream)null);
_ioServiceMock = new Mock <IIoService>();
_networkingService = new NetworkingService(
_tcpClientMock.Object,
_ioServiceMock.Object,
_configMock.Object);
}
public Layer3Tests()
{
_networking = new NetworkingService(Stubs.AuthenticationProvider, "region");
}
public NetworkingServiceTestFixture()
{
processProxy = new Mock <IProcessProxy>();
config = new Mock <IConfiguration>();
networkingService = new NetworkingService(processProxy.Object);
}
public Layer3Tests()
{
_networking = new NetworkingService(Stubs.AuthenticationProvider, "region");
}
/// <inheritdoc cref="NetworkingService_Layer3_Extensions.ListSecurityGroupRulesAsync" />
public static IEnumerable <SecurityGroupRule> ListSecurityGroupRules(this NetworkingService service, SecurityGroupRuleListOptions options = null)
{
return(service.ListSecurityGroupRulesAsync(options).ForceSynchronous());
}
/// <inheritdoc cref="NetworkingService_Layer3_Extensions.DeleteFloatingIPAsync" />
public static void DeleteFloatingIP(this NetworkingService service, Identifier floatingIPId)
{
service._networkingApiBuilder.DeleteFloatingIPAsync(floatingIPId).ForceSynchronous();
}
/// <inheritdoc cref="NetworkingApiBuilder.ListFloatingIPsAsync{T}" />
public static async Task <IEnumerable <FloatingIP> > ListFloatingIPsAsync(this NetworkingService service, FloatingIPListOptions options = null, CancellationToken cancellationToken = default(CancellationToken))
{
return(await service._networkingApiBuilder.ListFloatingIPsAsync <FloatingIPCollection>(options, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc cref="NetworkingApiBuilder.DeleteFloatingIPAsync" />
public static Task DeleteFloatingIPAsync(this NetworkingService service, Identifier floatingIPId, CancellationToken cancellationToken = default(CancellationToken))
{
return(service._networkingApiBuilder.DeleteFloatingIPAsync(floatingIPId, cancellationToken));
}
/// <inheritdoc cref="NetworkingApiBuilder.UpdateFloatingIPAsync{T}" />
public static Task <FloatingIP> UpdateFloatingIPAsync(this NetworkingService service, FloatingIPUpdateDefinition floatingIP, CancellationToken cancellationToken = default(CancellationToken))
{
return(service._networkingApiBuilder.CreateFloatingIPAsync <FloatingIP>(floatingIP, cancellationToken));
}
/// <inheritdoc cref="NetworkingApiBuilder.DetachSubnetFromRouterAsync" />
public static Task DetachSubnetFromRouterAsync(this NetworkingService service, Identifier routerId, Identifier subnetId, CancellationToken cancellationToken = default(CancellationToken))
{
return(service._networkingApiBuilder.DetachSubnetFromRouterAsync(routerId, subnetId, cancellationToken));
}
/// <inheritdoc cref="NetworkingApiBuilder.AttachSubnetToRouterAsync" />
public static async Task <Identifier> AttachSubnetToRouterAsync(this NetworkingService service, Identifier routerId, Identifier subnetId, CancellationToken cancellationToken = default(CancellationToken))
{
return(await service._networkingApiBuilder.AttachSubnetToRouterAsync(routerId, subnetId, cancellationToken).ConfigureAwait(false));
}
/// <inheritdoc cref="NetworkingApiBuilder.AttachPortToRouterAsync" />
public static Task AttachPortToRouterAsync(this NetworkingService service, Identifier routerId, Identifier portId, CancellationToken cancellationToken = default(CancellationToken))
{
return(service._networkingApiBuilder.AttachPortToRouterAsync(routerId, portId, cancellationToken));
}
/// <inheritdoc cref="NetworkingApiBuilder.UpdateRouterAsync{T}" />
public static Task <Router> UpdateRouterAsync(this NetworkingService service, RouterUpdateDefinition router, CancellationToken cancellationToken = default(CancellationToken))
{
return(service._networkingApiBuilder.CreateRouterAsync <Router>(router, cancellationToken));
}
