private static void StreamServiceProvider_OnMessageReceived(IChatService svc, IChatMessage msg)
{
try
{
Console.WriteLine($"{msg.Sender.DisplayName}: {msg.Message}");
Console.WriteLine("NAME:");
Console.WriteLine(msg.Sender.DisplayName);
string[] redeemString = msg.Message.Split(new string[] { "redeemed " }, StringSplitOptions.None);
if (msg is TwitchMessage twitchMsg)
{
int bits = twitchMsg.Bits;
if (bits > 0)
{
StreamlabsEvent streamlabsEvent = new StreamlabsEvent();
streamlabsEvent.type = "bits";
streamlabsEvent.message = new Message[1];
streamlabsEvent.message[0] = new Message();
streamlabsEvent.message[0].name = msg.Sender.UserName;
streamlabsEvent.message[0].amount = twitchMsg.Bits.ToString();
unitySyncContext.Send(SafeInvokeNormalStreamEvent, streamlabsEvent);
}
}
if (redeemString.Length > 1)
{
Console.WriteLine(redeemString[1]);
Console.WriteLine(redeemString[0]);
Console.WriteLine("REDEEMED ^");
StreamlabsEvent streamlabsEvent = new StreamlabsEvent();
streamlabsEvent.type = "channelpoints";
streamlabsEvent.message = new Message[1];
streamlabsEvent.message[0] = new Message();
streamlabsEvent.message[0].name = redeemString[0].Split(new string[] { "] " }, StringSplitOptions.None)[1].Trim();
streamlabsEvent.message[0].channelPointsName = redeemString[1].Trim();
unitySyncContext.Send(SafeInvokeStreamEvent, streamlabsEvent);
/*foreach (CustomAlert alert in AlertObjectLoader.CustomAlerts)
* {
* if(alert.Descriptor.ChannelPointsName.ToLower().Trim() == redeemString[1].ToLower().Trim())
* {
* //StreamlabsEvent labsEvent = new StreamlabsEvent();
* //labsEvent.type = "channelpoints";
* //labsEvent.message[0] = new Message();
* //labsEvent.message[0].name = redeemString[0].Trim();
* //alert.streamEvent = labsEvent;
* //Debug.WriteLine(redeemString[0]);
* //alert.ChannelPointsUser = redeemString[0].Split(new string[] { "] " }, StringSplitOptions.None)[1].Trim();
* //alert.Spawn
* }
* }*/
//.streamEvent = streamlabsEvent;
}
void SafeInvokeStreamEvent(object streamEvent) => OnEvent?.Invoke(streamEvent as StreamlabsEvent);
void SafeInvokeNormalStreamEvent(object streamEvent) => OnNormalEvent?.Invoke(streamEvent as StreamlabsEvent);
}
catch (Exception e)
{
Console.WriteLine(e);
}
//Console.WriteLine(msg.ToJson().ToString());
}
public AlertData Process(CustomAlert alert, StreamlabsEvent streamEvent)
{
AlertData data = new AlertData
{
canSpawn = false
};
if (alert == null || alert.Descriptor == null || alert.GameObject == null)
{
return(data);
}
AlertValue value = _config.Alerts.FirstOrDefault(a => a.Enabled && a.AlertType == alert.AlertType && (a.Value == alert.Descriptor.alertName || a.Value == alert.Descriptor.channelPointsName));
if (value != null)
{
data.canSpawn = true;
if (value.AlertType == AlertType.ChannelPoints && streamEvent != null)
{
data.canSpawn = alert.Descriptor.channelPointsName.ToLower().Trim() == streamEvent.Message[0].ChannelPointsName.ToLower().Trim();
}
data.delay = value.OverrideDelay ? value.DelayOverrideTime : _config.AlertDelay;
data.volume = value.Volume;
}
return(data);
}
public static void SpawnAlertFromEvent(StreamlabsEvent streamlabsEvent)
{
AlertDescriptor.AlertType alertType = streamlabsEvent.AlertType;
foreach (AlertValue alertValue in alerts)
{
if (alertValue.value != "Disabled")
{
if (alertValue.alertType == alertType)
{
// found the proper one. get by name.
foreach (CustomAlert alert in AlertObjectLoader.CustomAlerts)
{
if (alert.Descriptor.AlertName == alertValue.value)
{
// alert.streamEvent = streamlabsEvent;
// duplicate the alert.
CustomAlert newAlert = new CustomAlert(alert.gameObject, alert.Descriptor, streamlabsEvent);
QueueController.instance.QueueAlert(newAlert);
//alert.Spawn();
}
}
}
}
}
}
public static void SpawnChannelPointsAlert(StreamlabsEvent streamlabsEvent)
{
AlertDescriptor.AlertType alertType = streamlabsEvent.AlertType;
foreach (CustomAlert alert in AlertObjectLoader.CustomAlerts)
{
if (alert.Descriptor.ChannelPointsName.ToLower().Trim() == streamlabsEvent.message[0].channelPointsName.ToLower().Trim())
{
alert.streamEvent = streamlabsEvent;
//QueueController.instance.QueueAlert(alert);
// at least for now, i'm not gonna queue channel points. I think it'll be funnier when they're not queued.
alert.Spawn();
}
}
}
private void OnTwitchSub(object sender, StreamlabsEvent <TwitchSubscriptionMessage> e)
{
if (e.Message[0].Months == 1)
{
twitchClient.SendMessage(mainChannel,
userSettings.Default.newSub.Parse(e.Message[0].Name, tier: e.Message[0].SubType));
}
else
{
twitchClient.SendMessage(mainChannel,
userSettings.Default.newResub.Parse(e.Message[0].Name, amount: e.Message[0].Months.ToString(),
tier: e.Message[0].SubType));
}
}
private void OnEvent(StreamlabsEvent streamlabsEvent)
{
CustomAlert alert = _alertObjectLoader.GetAlertByType(streamlabsEvent.AlertType, streamlabsEvent.AlertType == AlertType.ChannelPoints ? streamlabsEvent?.Message[0]?.ChannelPointsName : null);
AlertData alertData = _alertObjectLoader.Process(alert, streamlabsEvent);
if (alertData.canSpawn)
{
CustomAlert newAlert = new CustomAlert(alert.GameObject, alert.Descriptor, streamlabsEvent)
{
Flatline = alertData.delay,
Volume = alertData.volume
};
Enqueue(newAlert);
}
}
private void StreamServiceProvider_OnMessageReceived(IChatService svc, IChatMessage msg)
{
try
{
string[] redeemString = msg.Message.Split(new string[] { "redeemed " }, StringSplitOptions.None);
if (msg is TwitchMessage twitchMsg)
{
int bits = twitchMsg.Bits;
if (bits > 0)
{
StreamlabsEvent streamlabsEvent = new StreamlabsEvent
{
Type = "bits",
Message = new Message[1]
};
streamlabsEvent.Message[0] = new Message
{
Name = msg.Sender.UserName,
Amount = twitchMsg.Bits.ToString()
};
_synchronizationContext.Send(SafeInvokeNormalStreamEvent, streamlabsEvent);
}
}
if (redeemString.Length > 1)
{
StreamlabsEvent streamlabsEvent = new StreamlabsEvent
{
Type = "channelpoints",
Message = new Message[1]
};
streamlabsEvent.Message[0] = new Message
{
Name = redeemString[0].Split(new string[] { "] " }, StringSplitOptions.None)[1].Trim(),
ChannelPointsName = redeemString[1].Trim()
};
_synchronizationContext.Send(SafeInvokeStreamEvent, streamlabsEvent);
}
void SafeInvokeStreamEvent(object streamEvent) => OnEvent?.Invoke(streamEvent as StreamlabsEvent);
void SafeInvokeNormalStreamEvent(object streamEvent) => OnNormalEvent?.Invoke(streamEvent as StreamlabsEvent);
}
catch (Exception e)
{
Plugin.Log.Error($"Error when processing received chat message: {e.Message}");
}
}
public StreamlabsEvent generatePreviewEvent(string channelPointsName)
{
string[] dummyBitTypes = { "100000", "10000", "5000", "1000", "100", "10" };
StreamlabsEvent streamEvent = new StreamlabsEvent
{
Type = "other",
Message = new Message[1]
};
streamEvent.Message[0] = new Message
{
Name = UnityEngine.Random.Range(0, 1000) == 0 ? "Ninja" : "username",
ChannelPointsName = channelPointsName,
Amount = dummyBitTypes[UnityEngine.Random.Range(0, dummyBitTypes.Length)],
Raiders = UnityEngine.Random.Range(0, 5000),
Viewers = UnityEngine.Random.Range(0, 5000)
};
return(streamEvent);
}
public CustomAlert(GameObject obj, AlertDescriptor descriptor, StreamlabsEvent labEvent)
{
this.Descriptor = descriptor;
this.gameObject = obj;
this.streamEvent = labEvent;
}
private void ForMessage(StreamlabsEvent streamlabsEvent, object eventData)
{
switch (streamlabsEvent.For)
{
case "streamlabs":
if (streamlabsEvent.Type == "donation")
{
var donation = JsonConvert.DeserializeObject <StreamlabsEvent <DonationMessage> >(eventData.ToString());
_logger?.LogDebug($"Donation deserialized successfully");
OnDonation?.Invoke(this, donation);
}
break;
case "twitch_account":
{
switch (streamlabsEvent.Type)
{
case "follow":
{
var follow = JsonConvert.DeserializeObject <StreamlabsEvent <TwitchFollowMessage> >(eventData.ToString());
_logger?.LogDebug($"Twitch Follow deserialized successfully");
OnTwitchFollow?.Invoke(this, follow);
}
break;
case "subscription":
{
var sub = JsonConvert.DeserializeObject <StreamlabsEvent <TwitchSubscriptionMessage> >(eventData.ToString());
_logger?.LogDebug($"Twitch Sub deserialized successfully");
OnTwitchSubscription?.Invoke(this, sub);
}
break;
case "host":
{
var host = JsonConvert.DeserializeObject <StreamlabsEvent <TwitchHostMessage> >(eventData.ToString());
_logger?.LogDebug($"Twitch Host deserialized successfully");
OnTwitchHost?.Invoke(this, host);
}
break;
case "bits":
{
var cheer = JsonConvert.DeserializeObject <StreamlabsEvent <TwitchCheerMessage> >(eventData.ToString());
_logger?.LogDebug($"Twitch Cheer deserialized successfully");
OnTwitchCheer?.Invoke(this, cheer);
}
break;
}
}
break;
case "youtube_account":
{
switch (streamlabsEvent.Type)
{
case "follow":
{
var follow = JsonConvert.DeserializeObject <StreamlabsEvent <YouTubeSubscriptionMessage> >(eventData.ToString());
_logger?.LogDebug($"YouTube Sub deserialized successfully");
OnYouTubeSubscription?.Invoke(this, follow);
}
break;
case "subscription":
{
var sub = JsonConvert.DeserializeObject <StreamlabsEvent <YouTubeSponsorMessage> >(eventData.ToString());
_logger?.LogDebug($"YouTube Sponsor deserialized successfully");
OnYouTubeSponsor?.Invoke(this, sub);
}
break;
case "superchat":
{
var super = JsonConvert.DeserializeObject <StreamlabsEvent <YouTubeSuperchatMessage> >(eventData.ToString());
_logger?.LogDebug($"YouTube Superchat deserialized successfully");
OnYouTubeSuperchat?.Invoke(this, super);
}
break;
}
}
break;
case "mixer_account":
{
switch (streamlabsEvent.Type)
{
case "follow":
{
var follow = JsonConvert.DeserializeObject <StreamlabsEvent <MixerFollowMessage> >(eventData.ToString());
_logger?.LogDebug($"Mixer Follow deserialized successfully");
OnMixerFollow?.Invoke(this, follow);
}
break;
case "subscription":
{
var sub = JsonConvert.DeserializeObject <StreamlabsEvent <MixerSubscriptionMessage> >(eventData.ToString());
_logger?.LogDebug($"Mixer Sub deserialized successfully");
OnMixerSubscription?.Invoke(this, sub);
}
break;
case "host":
{
var host = JsonConvert.DeserializeObject <StreamlabsEvent <MixerHostMessage> >(eventData.ToString());
_logger?.LogDebug($"Mixer Host deserialized successfully");
OnMixerHost?.Invoke(this, host);
}
break;
}
}
break;
}
}
public void Connect(string socketToken)
{
string url = $"https://sockets.streamlabs.com";
IO.Options opt = new IO.Options
{
QueryString = $"token={socketToken}",
Reconnection = true,
ReconnectionDelay = 500,
Port = 433,
Secure = true,
AutoConnect = false,
Upgrade = true
};
Quobject.SocketIoClientDotNet.Client.Socket socket = IO.Socket(url, opt);
socket.On(Quobject.SocketIoClientDotNet.Client.Socket.EVENT_CONNECT, () => {
log?.LogDebug("Connected");
OnConnected?.Invoke(this, new EventArgs());
});
socket.On(Quobject.SocketIoClientDotNet.Client.Socket.EVENT_DISCONNECT, data => {
log?.LogDebug($"Disonnected: {data}");
OnDisconnected?.Invoke(this, (string)data);
});
socket.On(Quobject.SocketIoClientDotNet.Client.Socket.EVENT_ERROR, data => {
log?.LogDebug($"Error: {data}");
OnError?.Invoke(this, data);
});
socket.On("event", data => {
log?.LogTrace($"EventData: {data}");
Console.WriteLine(data);
StreamlabsEvent streamlabsEvent = JsonConvert.DeserializeObject <StreamlabsEvent>(data.ToString());
Console.WriteLine(data);
JToken token = streamlabsEvent.Message;
if (token.Type == JTokenType.Array)
{
token = token.First;
}
switch (streamlabsEvent.Type)
{
case "streamlabels.underlying":
OnStreamlabels?.Invoke(this, token.ToObject <StreamlabsLabels>());
return;
case "donation":
OnDonation?.Invoke(this, token.ToObject <StreamlabsDonation>());
break;
case "redemption":
break;
case "subscription":
switch (token["platform"].Value <string>())
{
case "twitch_account":
OnTwitchSubscription?.Invoke(this, token.ToObject <StreamlabsTwitchSubscription>());
break;
}
break;
case "follow":
switch (token["platform"].Value <string>())
{
case "twitch_account":
OnTwitchFollow?.Invoke(this, token.ToObject <StreamlabsTwitchFollow>());
break;
}
break;
case "host":
switch (token["platform"].Value <string>())
{
case "twitch_account":
OnTwitchHost?.Invoke(this, token.ToObject <StreamlabsTwitchHost>());
break;
}
break;
case "bits":
switch (token["platform"].Value <string>())
{
case "twitch_account":
OnTwitchCheer?.Invoke(this, token.ToObject <StreamlabsTwitchCheer>());
break;
}
break;
case "raid":
switch (token["platform"].Value <string>())
{
case "twitch_account":
OnTwitchRaid?.Invoke(this, token.ToObject <StreamlabsTwitchRaid>());
break;
}
break;
default:
OnUndocumented?.Invoke(this, token);
break;
}
// else if (streamlabsEvent.Message.GetType() is "redemption")
// {
// }
// else if (streamlabsEvent.Message.GetType() is "pausequeue")
// {
// }
// else if (streamlabsEvent.Message.GetType() is "unpausequeue")
// {
// }
// else if (streamlabsEvent.Message.GetType() is "mutevolume")
// {
// }
// else if (streamlabsEvent.Message.GetType() is "unmutevolume")
// {
// }
// else if (streamlabsEvent.Message.GetType() is "skipalert")
// {
// }
});
socket.Open();
}
private void OnTwitchHost(object sender, StreamlabsEvent <TwitchHostMessage> e) => twitchClient.SendMessage(
mainChannel,
userSettings.Default.newHost.Parse(e.Message[0].Name, amount: e.Message[0].Viewers));
private void OnDonation(object sender, StreamlabsEvent <DonationMessage> e) => twitchClient.SendMessage(
mainChannel,
userSettings.Default.newDonation.Parse(e.Message[0].From,
amount: $"{e.Message[0].Amount}{e.Message[0].Currency}"));
private void OnTwitchFollow(object sender, StreamlabsEvent <TwitchFollowMessage> e) => twitchClient.SendMessage(mainChannel, userSettings.Default.newFollow.Parse(e.Message[0].Name));
