private async Task Connect()
{
try
{
var factory = new ConnectionFactory();
factory.UserName = _rabbitSettings.UserName;
factory.Password = _rabbitSettings.Password;
factory.VirtualHost = _rabbitSettings.VirtualHost;
factory.HostName = _rabbitSettings.HostName;
factory.Port = _rabbitSettings.Port;
factory.Ssl = new SslOption
{
Enabled = _rabbitSettings.SslEnabled,
CertPath = _rabbitSettings.SslCertPath,
ServerName = _rabbitSettings.SslServerName,
Version = _rabbitSettings.SslVersion
};
_connection = factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.QueueBind(_rabbitSettings.QueueName, exchange: string.Empty, routingKey: string.Empty);
SetOnMessageReceived();
await Task.CompletedTask;
}
catch (Exception e)
{
OnConnectionError?.Invoke(this, new ConnectionEventArgs(e));
}
}
/// <summary>
/// Handles connection info response from PlayFab (called on Connect) and starts the connection to the hub.
/// </summary>
/// <param name="connectionInfo"></param>
private async void OnConnectionInfoSuccess(GetConnectionInfoResponse connectionInfo)
{
_accessToken = connectionInfo.AccessToken;
_uri = connectionInfo.Url;
CreateHubConnection();
try
{
if (Debugging)
{
Debug.Log("Trying to connect to hub");
}
await _hubConnection.StartAsync();
if (Debugging)
{
Debug.Log("Connected To Hub");
}
OnConnect?.Invoke();
}
catch (Exception ex)
{
OnConnectionError?.Invoke(new PlayFabError()
{
Error = PlayFabErrorCode.InternalServerError,
ErrorMessage =
string.Format("PersistentSocket failed to start the connection with the message: {0}",
!string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty)
});
}
}
private void ConnectionError(object sender, EventArgs e)
{
Reconnect();
System.Threading.Thread.Sleep(2000);
OnConnectionError?.Invoke(_client, new OnConnectionErrorArgs {
Username = TwitchUsername
});
}
private bool ServerDisconnected()
{
if (!_forceDisconnect)
{
OnConnectionError?.Invoke(new Exception());
}
return(false);
}
private void _client_OnError(object sender, ErrorEventArgs e)
{
OnConnectionError?.Invoke(_client, new OnConnectionErrorArgs {
BotUsername = TwitchUsername, Error = new ErrorEvent {
Exception = e.Exception, Message = e.Exception.Message
}
});
Reconnect();
}
public SimpleTcpClient(string hostName, int port, int bufferSize, OnServerResponse onServerResponse, OnConnectionError onConnectionError)
{
_hostName = hostName;
_port = port;
_bufferSize = bufferSize;
_onServerResponse = onServerResponse;
_onConnectionError = onConnectionError;
_tasks = new List <Task>();
}
private void _client_OnError(object sender, ErrorEventArgs e)
{
Reconnect();
System.Threading.Thread.Sleep(2000);
OnConnectionError?.Invoke(_client, new OnConnectionErrorArgs {
Username = TwitchUsername, Error = new ErrorEvent {
Exception = e.Exception, Message = e.Message
}
});
}
private void Awake()
{
client = new Twitch.Client();
// Transfert events
client.OnDisconnected += (s, e) => OnDisconnected?.Invoke(this, e);
client.OnConnectionError += (s, e) => OnConnectionError?.Invoke(this, e);
client.OnChatCleared += (s, e) => OnChatCleared?.Invoke(this, e);
client.OnUserTimedout += (s, e) => OnUserTimedout?.Invoke(this, e);
client.OnLeftChannel += (s, e) => OnLeftChannel?.Invoke(this, e);
client.OnUserBanned += (s, e) => OnUserBanned?.Invoke(this, e);
client.OnModeratorsReceived += (s, e) => OnModeratorsReceived?.Invoke(this, e);
client.OnChatColorChanged += (s, e) => OnChatColorChanged?.Invoke(this, e);
client.OnSendReceiveData += (s, e) => OnSendReceiveData?.Invoke(this, e);
client.OnNowHosting += (s, e) => OnNowHosting?.Invoke(this, e);
//client.OnBeingHosted += (s, e) => OnBeingHosted ?.Invoke(this, e);
client.OnRaidNotification += (s, e) => OnRaidNotification?.Invoke(this, e);
client.OnGiftedSubscription += (s, e) => OnGiftedSubscription?.Invoke(this, e);
client.OnSelfRaidError += (s, e) => OnSelfRaidError?.Invoke(this, e);
client.OnNoPermissionError += (s, e) => OnNoPermissionError?.Invoke(this, e);
client.OnRaidedChannelIsMatureAudience += (s, e) => OnRaidedChannelIsMatureAudience?.Invoke(this, e);
client.OnRitualNewChatter += (s, e) => OnRitualNewChatter?.Invoke(this, e);
client.OnHostingStopped += (s, e) => OnHostingStopped?.Invoke(this, e);
client.OnHostingStarted += (s, e) => OnHostingStarted?.Invoke(this, e);
client.OnUserLeft += (s, e) => OnUserLeft?.Invoke(this, e);
client.OnExistingUsersDetected += (s, e) => OnExistingUsersDetected?.Invoke(this, e);
client.OnLog += (s, e) => OnLog?.Invoke(this, e);
client.OnConnected += (s, e) => OnConnected?.Invoke(this, e);
client.OnJoinedChannel += (s, e) => OnJoinedChannel?.Invoke(this, e);
client.OnIncorrectLogin += (s, e) => OnIncorrectLogin?.Invoke(this, e);
client.OnChannelStateChanged += (s, e) => OnChannelStateChanged?.Invoke(this, e);
client.OnUserStateChanged += (s, e) => OnUserStateChanged?.Invoke(this, e);
client.OnMessageReceived += (s, e) => OnMessageReceived?.Invoke(this, e);
client.OnWhisperReceived += (s, e) => OnWhisperReceived?.Invoke(this, e);
client.OnFailureToReceiveJoinConfirmation += (s, e) => OnFailureToReceiveJoinConfirmation?.Invoke(this, e);
client.OnMessageSent += (s, e) => OnMessageSent?.Invoke(this, e);
client.OnChatCommandReceived += (s, e) => OnChatCommandReceived?.Invoke(this, e);
client.OnWhisperCommandReceived += (s, e) => OnWhisperCommandReceived?.Invoke(this, e);
client.OnUserJoined += (s, e) => OnUserJoined?.Invoke(this, e);
client.OnModeratorJoined += (s, e) => OnModeratorJoined?.Invoke(this, e);
client.OnModeratorLeft += (s, e) => OnModeratorLeft?.Invoke(this, e);
client.OnNewSubscriber += (s, e) => OnNewSubscriber?.Invoke(this, e);
client.OnReSubscriber += (s, e) => OnReSubscriber?.Invoke(this, e);
client.OnHostLeft += (s, e) => OnHostLeft?.Invoke(this, e);
client.OnWhisperSent += (s, e) => OnWhisperSent?.Invoke(this, e);
client.OnUnaccountedFor += (s, e) => OnUnaccountedFor?.Invoke(this, e);
// Log client activity
client.OnLog += (s, e) => Debug.Log(e.Data);
client.OnConnected += (s, e) => NotificationManager.Instance.PushNotification("Connected to Twitch servers", Color.white, Color.green);
client.OnJoinedChannel += (s, e) => NotificationManager.Instance.PushNotification($"Joined {e.Channel} channel", Color.white, Color.cyan);
client.OnLeftChannel += (s, e) => NotificationManager.Instance.PushNotification($"Left {e.Channel} channel", Color.white, Color.yellow);
client.OnDisconnected += (s, e) => NotificationManager.Instance.PushNotification("Disconnected from Twitch servers", Color.white, Color.red);
client.OnFailureToReceiveJoinConfirmation += (s, e) => NotificationManager.Instance.PushNotification("Failed to join channel", Color.white, Color.magenta);
}
/// <summary>
/// Internal Handler for connection failures
/// Initiates retry & back-off states
/// Note: OnConnectionError only fires if we cannot retry after 15 minutes.
/// </summary>
/// <param name="error"></param>
private void OnInternalConnectionError(PlayFabError error)
{
_currentState = ConnectionStates.ConnectionFailed;
switch (_CurrentErrorState)
{
case ErrorStates.Ok:
_CurrentErrorState = ErrorStates.Retry30S;
OnRetryConnection?.Invoke((float)_CurrentErrorState, "Trying to Reconnect in 30s");
if (Debugging)
{
Debug.Log("Trying to Reconnect in 30s");
}
break;
case ErrorStates.Retry30S:
_CurrentErrorState = ErrorStates.Retry5M;
OnRetryConnection?.Invoke((float)_CurrentErrorState, "Trying to Reconnect in 5m");
if (Debugging)
{
Debug.Log("Trying to Reconnect in 5m");
}
break;
case ErrorStates.Retry5M:
_CurrentErrorState = ErrorStates.Retry10M;
OnRetryConnection?.Invoke((float)_CurrentErrorState, "Trying to Reconnect in 10m");
if (Debugging)
{
Debug.Log("Trying to Reconnect in 10m");
}
break;
case ErrorStates.Retry10M:
_CurrentErrorState = ErrorStates.Retry15M;
OnRetryConnection?.Invoke((float)_CurrentErrorState, "Trying to Reconnect in 15m");
if (Debugging)
{
Debug.Log("Trying to Reconnect in 15m");
}
break;
case ErrorStates.Retry15M:
_CurrentErrorState = ErrorStates.Cancelled;
OnRetryConnection?.Invoke((float)_CurrentErrorState, "Cannot reconnect to server, no more retries");
OnConnectionError?.Invoke(error);
if (Debugging)
{
Debug.Log("Cannot reconnect to server, no more retries");
}
break;
}
}
public SimpleTcpServer(int port, OnServerStart onStart, int bufferSize, OnClientConnected onClientConnected
, OnConnectionError onConnectionError, OnClientRequest onClientRequest, string endOfFileTag)
{
_onStart = onStart;
_bufferSize = bufferSize;
_onClientConnected = onClientConnected;
_onConnectionError = onConnectionError;
_onClientRequest = onClientRequest;
_endOfFileTag = endOfFileTag;
Port = port;
_activeClients = new List <TcpClient>();
_tasks = new List <Task>();
}
public Connection(OnConnectionConnect onConnected = null,
OnConnectionDisconnect onDisconnected = null,
OnConnectionError onError = null,
OnConnectionRecv onRecv = null)
{
m_OnConnectionConnect = onConnected;
m_OnConnectionDisconnect = onDisconnected;
m_OnConnectionError = onError;
m_OnConnectionRecv = onRecv;
m_MessageQueue = new Queue();
m_Mutex = new object();
}
public override void Run()
{
try
{
socket.Connect();
}
catch (Exception ex)
{
OnConnectionError?.Invoke(ex);
return;
}
OnConnected?.Invoke(socket, device);
}
private async void InitProxyAsync(string serverUrl)
{
//perform async initiating operations.
var pl = await PlayerContext.GetPlayerStateAsync(DeviceInfo.Instance.GetSystemId());
CurrentPlayerGuid = pl.UserId.ToString();
hubConnection = new HubConnection(serverUrl);
hubConnection.Headers.Add("UserGuid", CurrentPlayerGuid);
MultiPlayerHub = hubConnection.CreateHubProxy("MultiplayerHub");
hubConnection.StateChanged += HubConnection_StateChanged;
await hubConnection.Start().ContinueWith(async task =>
{
if (task.IsFaulted)
{
OnConnectionError?.Invoke(task.Exception);
//could also be unauthorized due to no correct userguid
}
else
{
//connected:
MultiPlayerHub.On <MultiPlayerSession>("updateSession", sessionObject => UpdateSession(sessionObject));
MultiPlayerHub.On <List <Player>, NormalGamePlatform, bool>("receiveNormalMonsterBroadcast", ReceiveNormalMonsterBroadcast);
MultiPlayerHub.On <List <Player>, BossGamePlatform, bool>("receiveBossMonsterBroadcast", ReceiveBossMonsterBroadcast);
MultiPlayerHub.On("broadcastYourClicks", RequestClickBatches);
MultiPlayerHub.On <BatchedClick>("receiveUploadedBatchClicks", ReceiveUploadedBatchClicks);
MultiPlayerHub.On <InviteModel>("receiveInvite", ReceiveInvite);
}
//for now render a new level anyways.
SessionContext = new MultiPlayerSession {
CurrentPlayerList = new List <Player> {
pl
}, HostPlayerId = CurrentPlayerGuid
};
SessionContext.CurrentLevel = LevelGenerator.BuildLevel(SessionContext.CurrentPlayerList);
await BroadcastSessionToServer();
});
InitializeComplete?.Invoke(null, null);
Dictionary <string, string> dingetje = new Dictionary <string, string>
{
{ "sessionguid", CurrentPlayerGuid }
};
await RestHelper.GetRequestAsync("api/multiplayer/AddSession", dingetje);
}
public void Connect(bool throwsException = false)
{
try
{
_watsonTcpClient = new WatsonTcpClient(_serverIp, _serverPort, ServerConnected, ServerDisconnected, MessageReceived, true);
}
catch (Exception e)
{
OnConnectionError?.Invoke(e);
if (throwsException)
{
throw;
}
}
SetOfflineMode(false);
}
/// <summary>
/// Connect to the PlayFab to get connection info
/// </summary>
public void Connect()
{
if (!PlayFabClientAPI.IsClientLoggedIn())
{
//Invoke Authentication error if we are not logged in and stop processing.
OnConnectionError?.Invoke(new PlayFabError()
{
Error = PlayFabErrorCode.NotAuthenticated,
ErrorMessage = "Developer must authenticate with a PlayFabClientAPI Login before calling Connect on the Service."
});
return;
}
//Reach out to PlayFab endpoint and get the connection info
Internal.PlayFabHttp.MakeApiCall <GetConnectionInfoResponse>(Endpoints.GetConnectionInfo,
new GetConnectionInfoRequest(),
Internal.AuthType.EntityToken,
OnConnectionInfoSuccess, OnConnectionInfoFailure);
}
public void Init()
{
_closing = false;
_server = new WebSocket(Settings.Default.ServerAddress + "/facelock");
_server.OnError += (s, e) =>
{
OnConnectionError?.Invoke(this, Resources.ConnectionLostMessage);
};
_server.OnClose += (s, e) =>
{
if (!_closing)
{
OnConnectionError?.Invoke(this, Resources.ConnectionLostMessage);
}
};
_server.OnMessage += (s, e) =>
{
var msg = JsonConvert.DeserializeObject <Message>(e.Data);
if (msg.MessageType == MessageType.FileCatalogUpdate)
{
var updateMsg = JsonConvert.DeserializeObject <FileCatalogUpdate>(e.Data);
OnFileCatalogUpdate?.Invoke(this, updateMsg.files);
}
};
try
{
_server.Connect();
}
catch (Exception ex)
{
OnConnectionError?.Invoke(this, Resources.CantConnectMessage);
}
if (_server.ReadyState != WebSocketState.Open)
{
OnConnectionError?.Invoke(this, Resources.CantConnectMessage);
}
}
public void Disconnect(bool reuse = false)
{
m_OnConnectionConnect = null;
m_OnConnectionDisconnect = null;
m_OnConnectionError = null;
m_OnConnectionRecv = null;
if (m_Socket?.Connected == true)
{
try {
m_Socket.BeginDisconnect(reuse, OnDisconnected, null);
} catch (SocketException) {}
}
if (!reuse)
{
m_Socket.Dispose();
m_Socket = null;
}
}
/// <summary>
/// Create the action Hub connection and listen for messages received
/// </summary>
private void CreateHubConnection()
{
try
{
//Note: removed error trapping on setting strings (_uri & _accessToken) because they are guaranteed to be there.
_hubConnection = new HubConnectionBuilder()
.WithUrl(_uri, options =>
{
options.Transports = HttpTransportType.WebSockets;
options.AccessTokenProvider = () => Task.FromResult(_accessToken);
}).Build();
var closedTcs = new TaskCompletionSource <object>();
_hubConnection.Closed += e =>
{
if (Debugging)
{
UnityEngine.Debug.Log($"Connection closed: {e}");
}
closedTcs.SetResult(null);
return(Task.CompletedTask);
};
_hubConnection.On <PlayFabNetworkMessage>("ReceiveEvent", InternalOnReceiveMessage);
if (Debugging)
{
UnityEngine.Debug.Log("Hub Created! This should only happen once");
}
}
catch (Exception ex)
{
OnConnectionError?.Invoke(new PlayFabError()
{
Error = PlayFabErrorCode.InternalServerError,
ErrorMessage = string.Format("PersistentSocket failed to start the connection with the message: {0}", !string.IsNullOrEmpty(ex.Message) ? ex.Message : string.Empty)
});
}
}
public void Connect()
{
if (UseProcessDetection)
{
StartWaitingForTargetProcess();
return;
}
soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
try
{
soc.Connect("127.0.0.1", 34243);
}
catch (SocketException e)
{
OnConnectionError?.Invoke(this, EventArgs.Empty);
}
RunSocketConnection();
}
private void TargetProcessStarted()
{
soc = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
_ = Task.Run(() => {
while (!IsAlive())
{
try
{
soc.Connect("127.0.0.1", 34243);
}
catch (SocketException)
{
if (!_run)
{
OnConnectionError?.Invoke(this, EventArgs.Empty);
return;
}
}
}
});
RunSocketConnection();
}
private bool MessageReceived(byte[] data)
{
if (data == null || data.Length <= 0)
{
return(false);
}
try
{
using (var stream = new MemoryStream(data))
{
var bProtocolVersion = new byte[4];
stream.Read(bProtocolVersion, 0, 4);
var protocolVersion = BitConverter.ToInt32(bProtocolVersion, 0);
if (protocolVersion != Protocol.Version)
{
throw new Exception("Invalid protocol version");
}
var bPacketId = new byte[4];
stream.Read(bPacketId, 0, 4);
var packetId = (Protocols)BitConverter.ToInt32(bPacketId, 0);
// ReSharper disable once SwitchStatementMissingSomeCases
switch (packetId)
{
case Protocols.LOGIN_ACK:
var loginAck = Serializer.Deserialize <PPNetLib.Contracts.LoginAck>(stream);
OnLoginAck?.Invoke(loginAck);
break;
case Protocols.ZONECOUNT_ACK:
var zoneCountAck = Serializer.Deserialize <PPNetLib.Contracts.ZoneCountAck>(stream);
OnZoneCountAck?.Invoke(zoneCountAck);
break;
case Protocols.ZONELIST_ACK:
var zoneListAck = Serializer.Deserialize <PPNetLib.Contracts.ZoneListAck>(stream);
OnZoneListAck?.Invoke(zoneListAck);
break;
case Protocols.INSERTZONE_ACK:
var zoneInsertAck = Serializer.Deserialize <PPNetLib.Contracts.InsertZoneAck>(stream);
OnZoneInsertAck?.Invoke(zoneInsertAck);
OnZoneInsertAck = null;
break;
case Protocols.INSERTPOINT_ACK:
var pointInsertAck = Serializer.Deserialize <PPNetLib.Contracts.InsertPointAck>(stream);
OnPointInsertAck?.Invoke(pointInsertAck);
OnPointInsertAck = null;
break;
case Protocols.CITYLIST_ACK:
var cityListAck = Serializer.Deserialize <PPNetLib.Contracts.CityListAck>(stream);
OnCityListAck?.Invoke(cityListAck);
break;
case Protocols.USERLIST_ACK:
var userListAck = Serializer.Deserialize <PPNetLib.Contracts.UserListAck>(stream);
OnUserListAck?.Invoke(userListAck);
break;
case Protocols.ISDUPLICATEUSER_ACK:
var isDuplicateUserAck = Serializer.Deserialize <PPNetLib.Contracts.IsDuplicateUserAck>(stream);
OnIsDuplicateUserAck?.Invoke(isDuplicateUserAck);
OnIsDuplicateUserAck = null;
break;
case Protocols.POINTUPDATED_ACK:
var pointUpdatedAck =
Serializer.Deserialize <PPNetLib.Contracts.SynchroniseAcks.PointUpdatedAck>(stream);
OnPointUpdatedAck?.Invoke(pointUpdatedAck);
break;
case Protocols.ZONEINFOUPDATED_ACK:
var zoneInfoUpdatedAck =
Serializer.Deserialize <PPNetLib.Contracts.SynchroniseAcks.ZoneInfoUpdatedAck>(stream);
OnZoneInfoUpdatedAck?.Invoke(zoneInfoUpdatedAck);
break;
case Protocols.LOGINDUPLICATE_ACK:
OnLoginDuplicateAck?.Invoke();
break;
case Protocols.SHUTDOWN_ACK:
var shutdownAck = Serializer.Deserialize <PPNetLib.Contracts.ShutdownAck>(stream);
OnShutdownAck?.Invoke(shutdownAck);
break;
case Protocols.SERVERMONITOR_ACK:
var serverMonitorAck = Serializer.Deserialize <PPNetLib.Contracts.Monitor.ServerMonitorAck>(stream);
OnServerMonitorAck?.Invoke(serverMonitorAck);
break;
case Protocols.ONLINEUSERS_ACK:
var onlineUsersAck = Serializer.Deserialize <PPNetLib.Contracts.Monitor.OnlineUsersAck>(stream);
OnOnlineUsersAck?.Invoke(onlineUsersAck);
break;
case Protocols.ABORTSESSION_ACK:
OnConnectionError?.Invoke(new Exception("Session aborted"));
break;
case Protocols.LISTBANNEDIPS_ACK:
var listBannedIps = Serializer.Deserialize <PPNetLib.Contracts.Monitor.ListBannedIpsAck>(stream);
OnListBannedIpsAck?.Invoke(listBannedIps);
break;
case Protocols.COMMAND_ACK:
var commandAck = Serializer.Deserialize <PPNetLib.Contracts.Monitor.CommandAck>(stream);
OnCommandAck?.Invoke(commandAck);
break;
}
Debug.WriteLine("Received PID {0}", packetId);
}
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
return(true);
}
private void Client_OnError(object sender, OnErrorEventArgs e)
{
// TODO : Message MainForm there was an error
OnConnectionError.Invoke(sender, e);
MainForm.StaticPostToDebug($"Twitch Bot Client Error Occured: {e.Exception}");
}
public Client() : base(null)
{
ThreadDispatcher.EnsureCreated();
base.OverrideBeingHostedCheck = true;
base.OnLog += (object sender, OnLogArgs e) => { ThreadDispatcher.Enqueue(() => OnLog?.Invoke(sender, e)); };
base.OnConnected += ((object sender, OnConnectedArgs e) => { ThreadDispatcher.Enqueue(() => OnConnected?.Invoke(sender, e)); });
base.OnJoinedChannel += ((object sender, OnJoinedChannelArgs e) => {
ThreadDispatcher.Enqueue(() => OnJoinedChannel?.Invoke(sender, e));
if (OnBeingHosted == null)
{
return;
}
if (e.Channel.ToLower() != TwitchUsername && !OverrideBeingHostedCheck)
{
ThreadDispatcher.Enqueue(() => throw new BadListenException("BeingHosted", "You cannot listen to OnBeingHosted unless you are connected to the broadcaster's channel as the broadcaster. You may override this by setting the TwitchClient property OverrideBeingHostedCheck to true."));
}
});
base.OnIncorrectLogin += ((object sender, OnIncorrectLoginArgs e) => { ThreadDispatcher.Enqueue(() => OnIncorrectLogin?.Invoke(sender, e)); });
base.OnChannelStateChanged += ((object sender, OnChannelStateChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnChannelStateChanged?.Invoke(sender, e)); });
base.OnUserStateChanged += ((object sender, OnUserStateChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserStateChanged?.Invoke(sender, e)); });
base.OnMessageReceived += ((object sender, OnMessageReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageReceived?.Invoke(sender, e)); });
base.OnWhisperReceived += ((object sender, OnWhisperReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperReceived?.Invoke(sender, e)); });
base.OnMessageSent += ((object sender, OnMessageSentArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageSent?.Invoke(sender, e)); });
base.OnWhisperSent += ((object sender, OnWhisperSentArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperSent?.Invoke(sender, e)); });
base.OnChatCommandReceived += ((object sender, OnChatCommandReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatCommandReceived?.Invoke(sender, e)); });
base.OnWhisperCommandReceived += ((object sender, OnWhisperCommandReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperCommandReceived?.Invoke(sender, e)); });
base.OnUserJoined += ((object sender, OnUserJoinedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserJoined?.Invoke(sender, e)); });
base.OnModeratorJoined += ((object sender, OnModeratorJoinedArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorJoined?.Invoke(sender, e)); });
base.OnModeratorLeft += ((object sender, OnModeratorLeftArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorLeft?.Invoke(sender, e)); });
base.OnNewSubscriber += ((object sender, OnNewSubscriberArgs e) => { ThreadDispatcher.Enqueue(() => OnNewSubscriber?.Invoke(sender, e)); });
base.OnReSubscriber += ((object sender, OnReSubscriberArgs e) => { ThreadDispatcher.Enqueue(() => OnReSubscriber?.Invoke(sender, e)); });
base.OnHostLeft += ((object sender, EventArgs arg) => { ThreadDispatcher.Enqueue(() => OnHostLeft?.Invoke(sender, arg)); });
base.OnExistingUsersDetected += ((object sender, OnExistingUsersDetectedArgs e) => { ThreadDispatcher.Enqueue(() => OnExistingUsersDetected?.Invoke(sender, e)); });
base.OnUserLeft += ((object sender, OnUserLeftArgs e) => { ThreadDispatcher.Enqueue(() => OnUserLeft?.Invoke(sender, e)); });
base.OnHostingStarted += ((object sender, OnHostingStartedArgs e) => { ThreadDispatcher.Enqueue(() => OnHostingStarted?.Invoke(sender, e)); });
base.OnHostingStopped += ((object sender, OnHostingStoppedArgs e) => { ThreadDispatcher.Enqueue(() => OnHostingStopped?.Invoke(sender, e)); });
base.OnDisconnected += ((object sender, OnDisconnectedEventArgs e) => { ThreadDispatcher.Enqueue(() => OnDisconnected?.Invoke(sender, e)); });
base.OnConnectionError += ((object sender, OnConnectionErrorArgs e) => { ThreadDispatcher.Enqueue(() => OnConnectionError?.Invoke(sender, e)); });
base.OnChatCleared += ((object sender, OnChatClearedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatCleared?.Invoke(sender, e)); });
base.OnUserTimedout += ((object sender, OnUserTimedoutArgs e) => { ThreadDispatcher.Enqueue(() => OnUserTimedout?.Invoke(sender, e)); });
base.OnLeftChannel += ((object sender, OnLeftChannelArgs e) => { ThreadDispatcher.Enqueue(() => OnLeftChannel?.Invoke(sender, e)); });
base.OnUserBanned += ((object sender, OnUserBannedArgs e) => { ThreadDispatcher.Enqueue(() => OnUserBanned?.Invoke(sender, e)); });
base.OnModeratorsReceived += ((object sender, OnModeratorsReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnModeratorsReceived?.Invoke(sender, e)); });
base.OnChatColorChanged += ((object sender, OnChatColorChangedArgs e) => { ThreadDispatcher.Enqueue(() => OnChatColorChanged?.Invoke(sender, e)); });
base.OnSendReceiveData += ((object sender, OnSendReceiveDataArgs e) => { ThreadDispatcher.Enqueue(() => OnSendReceiveData?.Invoke(sender, e)); });
base.OnNowHosting += ((object sender, OnNowHostingArgs e) => { ThreadDispatcher.Enqueue(() => OnNowHosting?.Invoke(sender, e)); });
base.OnBeingHosted += ((object sender, OnBeingHostedArgs e) => { ThreadDispatcher.Enqueue(() => OnBeingHosted?.Invoke(sender, e)); });
base.OnRaidNotification += ((object sender, OnRaidNotificationArgs e) => { ThreadDispatcher.Enqueue(() => OnRaidNotification?.Invoke(sender, e)); });
base.OnGiftedSubscription += ((object sender, OnGiftedSubscriptionArgs e) => { ThreadDispatcher.Enqueue(() => OnGiftedSubscription?.Invoke(sender, e)); });
base.OnRaidedChannelIsMatureAudience += ((object sender, EventArgs arg) => { ThreadDispatcher.Enqueue(() => OnRaidedChannelIsMatureAudience?.Invoke(sender, arg)); });
base.OnRitualNewChatter += ((object sender, OnRitualNewChatterArgs e) => { ThreadDispatcher.Enqueue(() => OnRitualNewChatter?.Invoke(sender, e)); });
base.OnFailureToReceiveJoinConfirmation += ((object sender, OnFailureToReceiveJoinConfirmationArgs e) => { ThreadDispatcher.Enqueue(() => OnFailureToReceiveJoinConfirmation?.Invoke(sender, e)); });
base.OnUnaccountedFor += ((object sender, OnUnaccountedForArgs e) => { ThreadDispatcher.Enqueue(() => OnUnaccountedFor?.Invoke(sender, e)); });
base.OnSelfRaidError += ((object sender, EventArgs e) => { ThreadDispatcher.Enqueue(() => OnSelfRaidError?.Invoke(sender, e)); });
base.OnNoPermissionError += ((object sender, EventArgs e) => { ThreadDispatcher.Enqueue(() => OnNoPermissionError?.Invoke(sender, e)); });
base.OnMessageCleared += ((object sender, OnMessageClearedArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageCleared?.Invoke(sender, e)); });
base.OnReconnected += ((object sender, OnReconnectedEventArgs e) => { ThreadDispatcher.Enqueue(() => OnReconnected?.Invoke(sender, e)); });
base.OnWhisperThrottled += ((object sender, OnWhisperThrottledEventArgs e) => { ThreadDispatcher.Enqueue(() => OnWhisperThrottled?.Invoke(sender, e)); });
base.OnMessageThrottled += ((object sender, OnMessageThrottledEventArgs e) => { ThreadDispatcher.Enqueue(() => OnMessageThrottled?.Invoke(sender, e)); });
base.OnCommunitySubscription += ((object sender, OnCommunitySubscriptionArgs e) => { ThreadDispatcher.Enqueue(() => OnCommunitySubscription?.Invoke(sender, e)); });
base.OnError += ((object sender, OnErrorEventArgs e) => { ThreadDispatcher.Enqueue(() => OnError?.Invoke(sender, e)); });
base.OnVIPsReceived += ((object sender, OnVIPsReceivedArgs e) => { ThreadDispatcher.Enqueue(() => OnVIPsReceived?.Invoke(sender, e)); });
}
private void Client_OnConnectionError(object sender, OnConnectionErrorArgs e)
{
OnConnectionError.Invoke(sender, e);
MainForm.StaticPostToDebug($"Twitch Bot Client Error Occured: {e.Error}");
}
public TwitchClientUnity(ILogger <TwitchClientUnity> logger) : base(logger)
{
CoroutineHost.PrepareCrossThread();
// client = new TwitchClient(credentials, channel, chatCommandIdentifier,whisperCommandIdentifier,logging,logger,autoReListenOnExceptions);
base.OnLog += ((object sender, OnLogArgs e) => { CoroutineHost.Host(() => OnLog?.Invoke(sender, e)); });
base.OnConnected += ((object sender, OnConnectedArgs e) => { CoroutineHost.Host(() => OnConnected?.Invoke(sender, e)); });
base.OnJoinedChannel += ((object sender, OnJoinedChannelArgs e) => { CoroutineHost.Host(() => OnJoinedChannel?.Invoke(sender, e)); });
base.OnIncorrectLogin += ((object sender, OnIncorrectLoginArgs e) => { CoroutineHost.Host(() => OnIncorrectLogin?.Invoke(sender, e)); });
base.OnChannelStateChanged += ((object sender, OnChannelStateChangedArgs e) => { CoroutineHost.Host(() => OnChannelStateChanged?.Invoke(sender, e)); });
base.OnUserStateChanged += ((object sender, OnUserStateChangedArgs e) => { CoroutineHost.Host(() => OnUserStateChanged?.Invoke(sender, e)); });
base.OnMessageReceived += ((object sender, OnMessageReceivedArgs e) => { CoroutineHost.Host(() => OnMessageReceived?.Invoke(sender, e)); });
base.OnWhisperReceived += ((object sender, OnWhisperReceivedArgs e) => { CoroutineHost.Host(() => OnWhisperReceived?.Invoke(sender, e)); });
base.OnMessageSent += ((object sender, OnMessageSentArgs e) => { CoroutineHost.Host(() => OnMessageSent?.Invoke(sender, e)); });
base.OnWhisperSent += ((object sender, OnWhisperSentArgs e) => { CoroutineHost.Host(() => OnWhisperSent?.Invoke(sender, e)); });
base.OnChatCommandReceived += ((object sender, OnChatCommandReceivedArgs e) => { CoroutineHost.Host(() => OnChatCommandReceived?.Invoke(sender, e)); });
base.OnWhisperCommandReceived += ((object sender, OnWhisperCommandReceivedArgs e) => { CoroutineHost.Host(() => OnWhisperCommandReceived?.Invoke(sender, e)); });
base.OnUserJoined += ((object sender, OnUserJoinedArgs e) => { CoroutineHost.Host(() => OnUserJoined?.Invoke(sender, e)); });
base.OnModeratorJoined += ((object sender, OnModeratorJoinedArgs e) => { CoroutineHost.Host(() => OnModeratorJoined?.Invoke(sender, e)); });
base.OnModeratorLeft += ((object sender, OnModeratorLeftArgs e) => { CoroutineHost.Host(() => OnModeratorLeft?.Invoke(sender, e)); });
base.OnNewSubscriber += ((object sender, OnNewSubscriberArgs e) => { CoroutineHost.Host(() => OnNewSubscriber?.Invoke(sender, e)); });
base.OnReSubscriber += ((object sender, OnReSubscriberArgs e) => { CoroutineHost.Host(() => OnReSubscriber?.Invoke(sender, e)); });
base.OnHostLeft += ((object sender, EventArgs arg) => { CoroutineHost.Host(() => OnHostLeft(sender, arg)); });
base.OnExistingUsersDetected += ((object sender, OnExistingUsersDetectedArgs e) => { CoroutineHost.Host(() => OnExistingUsersDetected?.Invoke(sender, e)); });
base.OnUserLeft += ((object sender, OnUserLeftArgs e) => { CoroutineHost.Host(() => OnUserLeft?.Invoke(sender, e)); });
base.OnHostingStarted += ((object sender, OnHostingStartedArgs e) => { CoroutineHost.Host(() => OnHostingStarted?.Invoke(sender, e)); });
base.OnHostingStopped += ((object sender, OnHostingStoppedArgs e) => { CoroutineHost.Host(() => OnHostingStopped?.Invoke(sender, e)); });
base.OnDisconnected += ((object sender, OnDisconnectedArgs e) => { CoroutineHost.Host(() => OnDisconnected?.Invoke(sender, e)); });
base.OnConnectionError += ((object sender, OnConnectionErrorArgs e) => { CoroutineHost.Host(() => OnConnectionError?.Invoke(sender, e)); });
base.OnChatCleared += ((object sender, OnChatClearedArgs e) => { CoroutineHost.Host(() => OnChatCleared?.Invoke(sender, e)); });
base.OnUserTimedout += ((object sender, OnUserTimedoutArgs e) => { CoroutineHost.Host(() => OnUserTimedout?.Invoke(sender, e)); });
base.OnLeftChannel += ((object sender, OnLeftChannelArgs e) => { CoroutineHost.Host(() => OnLeftChannel?.Invoke(sender, e)); });
base.OnUserBanned += ((object sender, OnUserBannedArgs e) => { CoroutineHost.Host(() => OnUserBanned?.Invoke(sender, e)); });
base.OnModeratorsReceived += ((object sender, OnModeratorsReceivedArgs e) => { CoroutineHost.Host(() => OnModeratorsReceived?.Invoke(sender, e)); });
base.OnChatColorChanged += ((object sender, OnChatColorChangedArgs e) => { CoroutineHost.Host(() => OnChatColorChanged?.Invoke(sender, e)); });
base.OnSendReceiveData += ((object sender, OnSendReceiveDataArgs e) => { CoroutineHost.Host(() => OnSendReceiveData?.Invoke(sender, e)); });
base.OnNowHosting += ((object sender, OnNowHostingArgs e) => { CoroutineHost.Host(() => OnNowHosting?.Invoke(sender, e)); });
base.OnBeingHosted += ((object sender, OnBeingHostedArgs e) => { CoroutineHost.Host(() => OnBeingHosted?.Invoke(sender, e)); });
base.OnRaidNotification += ((object sender, OnRaidNotificationArgs e) => { CoroutineHost.Host(() => OnRaidNotification?.Invoke(sender, e)); });
base.OnGiftedSubscription += ((object sender, OnGiftedSubscriptionArgs e) => { CoroutineHost.Host(() => OnGiftedSubscription?.Invoke(sender, e)); });
base.OnRaidedChannelIsMatureAudience += ((object sender, EventArgs arg) => { CoroutineHost.Host(() => OnRaidedChannelIsMatureAudience(sender, arg)); });
base.OnRitualNewChatter += ((object sender, OnRitualNewChatterArgs e) => { CoroutineHost.Host(() => OnRitualNewChatter?.Invoke(sender, e)); });
base.OnFailureToReceiveJoinConfirmation += ((object sender, OnFailureToReceiveJoinConfirmationArgs e) => { CoroutineHost.Host(() => OnFailureToReceiveJoinConfirmation?.Invoke(sender, e)); });
base.OnUnaccountedFor += ((object sender, OnUnaccountedForArgs e) => { CoroutineHost.Host(() => OnUnaccountedFor?.Invoke(sender, e)); });
}
public SimpleTcpServerCreator OnClientConnectionError(OnConnectionError onConnectionError)
{
_onConnectionError = onConnectionError;
return(this);
}
/// <summary>
/// Handler for if we could not connect to a PlayFab title and get SignalR Hub connection info
/// </summary>
/// <param name="error"></param>
private void OnConnectionInfoFailure(PlayFabError error)
{
OnConnectionError?.Invoke(error);
}
public Client() : base(null)
{
_threadDispatcher = new GameObject("TwitchClientUnityDispatcher");
_threadDispatcher.AddComponent <ThreadDispatcher>();
UnityEngine.Object.DontDestroyOnLoad(_threadDispatcher);
base.OnLog += ((object sender, OnLogArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnLog?.Invoke(sender, e)); });
base.OnConnected += ((object sender, OnConnectedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnConnected?.Invoke(sender, e)); });
base.OnJoinedChannel += ((object sender, OnJoinedChannelArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnJoinedChannel?.Invoke(sender, e)); });
base.OnIncorrectLogin += ((object sender, OnIncorrectLoginArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnIncorrectLogin?.Invoke(sender, e)); });
base.OnChannelStateChanged += ((object sender, OnChannelStateChangedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnChannelStateChanged?.Invoke(sender, e)); });
base.OnUserStateChanged += ((object sender, OnUserStateChangedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUserStateChanged?.Invoke(sender, e)); });
base.OnMessageReceived += ((object sender, OnMessageReceivedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnMessageReceived?.Invoke(sender, e)); });
base.OnWhisperReceived += ((object sender, OnWhisperReceivedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnWhisperReceived?.Invoke(sender, e)); });
base.OnMessageSent += ((object sender, OnMessageSentArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnMessageSent?.Invoke(sender, e)); });
base.OnWhisperSent += ((object sender, OnWhisperSentArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnWhisperSent?.Invoke(sender, e)); });
base.OnChatCommandReceived += ((object sender, OnChatCommandReceivedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnChatCommandReceived?.Invoke(sender, e)); });
base.OnWhisperCommandReceived += ((object sender, OnWhisperCommandReceivedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnWhisperCommandReceived?.Invoke(sender, e)); });
base.OnUserJoined += ((object sender, OnUserJoinedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUserJoined?.Invoke(sender, e)); });
base.OnModeratorJoined += ((object sender, OnModeratorJoinedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnModeratorJoined?.Invoke(sender, e)); });
base.OnModeratorLeft += ((object sender, OnModeratorLeftArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnModeratorLeft?.Invoke(sender, e)); });
base.OnNewSubscriber += ((object sender, OnNewSubscriberArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnNewSubscriber?.Invoke(sender, e)); });
base.OnReSubscriber += ((object sender, OnReSubscriberArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnReSubscriber?.Invoke(sender, e)); });
base.OnHostLeft += ((object sender, EventArgs arg) => { ThreadDispatcher.Instance().Enqueue(() => OnHostLeft(sender, arg)); });
base.OnExistingUsersDetected += ((object sender, OnExistingUsersDetectedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnExistingUsersDetected?.Invoke(sender, e)); });
base.OnUserLeft += ((object sender, OnUserLeftArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUserLeft?.Invoke(sender, e)); });
base.OnHostingStarted += ((object sender, OnHostingStartedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnHostingStarted?.Invoke(sender, e)); });
base.OnHostingStopped += ((object sender, OnHostingStoppedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnHostingStopped?.Invoke(sender, e)); });
base.OnDisconnected += ((object sender, OnDisconnectedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnDisconnected?.Invoke(sender, e)); });
base.OnConnectionError += ((object sender, OnConnectionErrorArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnConnectionError?.Invoke(sender, e)); });
base.OnChatCleared += ((object sender, OnChatClearedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnChatCleared?.Invoke(sender, e)); });
base.OnUserTimedout += ((object sender, OnUserTimedoutArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUserTimedout?.Invoke(sender, e)); });
base.OnLeftChannel += ((object sender, OnLeftChannelArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnLeftChannel?.Invoke(sender, e)); });
base.OnUserBanned += ((object sender, OnUserBannedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUserBanned?.Invoke(sender, e)); });
base.OnModeratorsReceived += ((object sender, OnModeratorsReceivedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnModeratorsReceived?.Invoke(sender, e)); });
base.OnChatColorChanged += ((object sender, OnChatColorChangedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnChatColorChanged?.Invoke(sender, e)); });
base.OnSendReceiveData += ((object sender, OnSendReceiveDataArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnSendReceiveData?.Invoke(sender, e)); });
base.OnNowHosting += ((object sender, OnNowHostingArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnNowHosting?.Invoke(sender, e)); });
base.OnBeingHosted += ((object sender, OnBeingHostedArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnBeingHosted?.Invoke(sender, e)); });
base.OnRaidNotification += ((object sender, OnRaidNotificationArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnRaidNotification?.Invoke(sender, e)); });
base.OnGiftedSubscription += ((object sender, OnGiftedSubscriptionArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnGiftedSubscription?.Invoke(sender, e)); });
base.OnRaidedChannelIsMatureAudience += ((object sender, EventArgs arg) => { ThreadDispatcher.Instance().Enqueue(() => OnRaidedChannelIsMatureAudience(sender, arg)); });
base.OnRitualNewChatter += ((object sender, OnRitualNewChatterArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnRitualNewChatter?.Invoke(sender, e)); });
base.OnFailureToReceiveJoinConfirmation += ((object sender, OnFailureToReceiveJoinConfirmationArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnFailureToReceiveJoinConfirmation?.Invoke(sender, e)); });
base.OnUnaccountedFor += ((object sender, OnUnaccountedForArgs e) => { ThreadDispatcher.Instance().Enqueue(() => OnUnaccountedFor?.Invoke(sender, e)); });
}
