void OnPrivMsg(TwitchIRCMessage message)
{
//if (activeChatWindow != null && !message.Message.StartsWith("!") && message.User != ToolkitSettings.Username)
//{
// if ((_voteActive && !int.TryParse(message.Message[0].ToString(), out int result)) || !_voteActive)
// {
// activeChatWindow.AddMessage(
// message.Message,
// message.User,
// (message.Parameters.ContainsKey("color")) ? message.Parameters["color"].Remove(0, 1) : Viewer.GetViewerColorCode(message.User)
// );
// }
//}
message.Viewer = TwitchViewer.GetTwitchViewer(message.User);
if (message.Viewer == null)
{
Helper.Log(message.User.CapitalizeFirst() + " tried to run a command but is not registed.");
return;
}
if (Helper.ModActive)
{
CommandsHandler.CheckCommand(message);
}
if (VoteHandler.voteActive && int.TryParse(message.Message[0].ToString(), out int voteKey))
{
VoteHandler.currentVote.RecordVote(Viewers.GetViewer(message.User).id, voteKey - 1);
}
}
public bool IsPlaying(TwitchViewer viewer)
{
lock (mutex)
{
return(viewers.Any(x => x.Identifier == viewer.Identifier));
}
}
private bool TryGetViewer(out TwitchViewer user)
{
user = null;
return
(Request.Headers.ContainsKey("Authorization") &&
auth.Validate(Request.Headers["Authorization"], out user));
}
void RegisterNewViewerCompleted(object sender, DownloadStringCompletedEventArgs e)
{
if (e.Error != null)
{
Helper.Log("Web Get Request: " + e.Error);
throw new Exception("Viewer not found on TwitchAPI");
}
if (e.Result != null)
{
Helper.Log("Web Get Request: " + e.Result);
}
var jsonNode = JSON.Parse(e.Result);
if (jsonNode["data"] != null)
{
if (jsonNode["data"][0] != null)
{
int id = jsonNode["data"][0]["id"].AsInt;
string username = jsonNode["data"][0]["display_name"];
if (TwitchViewer.GetTwitchViewer(id, username) != null)
{
SendViewerBalance(id.ToString());
}
}
else
{
Helper.Log("Viewer info not found");
}
}
}
void SendViewerBalance(string viewerIdString)
{
int viewerId = int.Parse(viewerIdString.Replace("U", ""));
TwitchViewer twitchViewer = TwitchViewer.GetTwitchViewer(viewerId);
if (twitchViewer == null)
{
throw new Exception("Viewer with id " + viewerId + " not registered");
}
StringBuilder balance = new StringBuilder();
balance.AppendLine("{");
balance.AppendLine("\"type\": \"command\",");
balance.AppendLine($"\"id\": {ToolkitSettings.ChannelID},");
balance.AppendLine("\"message\": ");
balance.AppendLine(" { ");
balance.AppendLine($" \"endpoint\": \"/viewer/{ToolkitSettings.ChannelID}/{viewerId}\",");
balance.AppendLine($" \"value\": {twitchViewer.Coins},");
balance.AppendLine($" \"key\": \"coin_balance\",");
balance.AppendLine($" \"karma\": {twitchViewer.Karma}");
balance.AppendLine(" }");
balance.AppendLine("}");
Send(balance.ToString());
}
public void Add(TwitchViewer viewer, string playerName)
{
lock (mutex)
{
viewers.Add(viewer);
viewerPlayerNameLookup[viewer.Identifier] = playerName;
SaveProperties();
}
}
public PlayerInfo Get(TwitchViewer viewerContext)
{
if (this.viewerPlayerLookup.TryGetValue(viewerContext.Identifier, out var player))
{
return(player);
}
return(null);
}
public string GetPlayerName(TwitchViewer viewer)
{
if (this.viewerPlayerNameLookup.TryGetValue(viewer.Identifier, out var name))
{
return(name);
}
return(null);
}
public async Task <LeaveResponse> LeaveAsync(TwitchViewer viewerContext)
{
var result = await AwaitResponse <LeaveResponse>("leave", viewerContext.Identifier);
if (result != null)
{
playerHandler.Remove(viewerContext);
}
return(result);
}
public async Task <JoinResponse> JoinAsync(TwitchViewer viewerContext, string name)
{
var result = await AwaitResponse <JoinResponse>("join", viewerContext.Identifier, name);
if (result != null && !string.IsNullOrEmpty(result.Role))
{
result.Game = GameInfo.FromUpdateInfo(context.GameState, true);
playerHandler.Add(viewerContext, name);
}
return(result);
}
public void Remove(TwitchViewer viewer)
{
lock (mutex)
{
var toRemove = viewers.FirstOrDefault(x => x.Identifier == viewer.Identifier);
if (toRemove != null)
{
viewers.Remove(toRemove);
viewerPlayerNameLookup.Remove(viewer.Identifier, out _);
SaveProperties();
}
}
}
public async Task <GameStateResponse> GetStateAsync(TwitchViewer viewerContext, int revision)
{
var timeout = 0;
var state = this.GetState(viewerContext);
while (state.Revision == revision)
{
await Task.Delay(50);
timeout += 50;
state = this.GetState(viewerContext);
if (timeout >= 20_000)
{
break;
}
}
return(state);
}
public async Task <IReadOnlyList <ChatMessage> > GetChatMessagesAsync(
TwitchViewer viewerContext,
string channel,
DateTime since)
{
var elapsed = 0;
var messages = GetChatMessages(viewerContext, channel, since);
while (messages.Count == 0)
{
elapsed += 50;
await Task.Delay(50);
messages = GetChatMessages(viewerContext, channel, since);
if (elapsed >= 10000)
{
break;
}
}
return(messages);
}
public IReadOnlyList <ChatMessage> GetChatMessages(TwitchViewer viewerContext, string channel, DateTime since)
{
var player = this.playerHandler.Get(viewerContext);
if (player == null)
{
return(new ChatMessage[0]);
}
if (!this.HasAccessToChatChannel(player, channel))
{
return(new ChatMessage[0]);
}
lock (mutex)
{
var messages = this.chatMessages
.Where(x => x.Channel == channel && x.Sender != player.Name && x.TimeSent > since)
.ToList();
return(messages);
}
}
public GameStateResponse GetState(TwitchViewer viewerContext)
{
lock (mutex)
{
var state =
context.GameState == null
? GameState.NotStarted
: context.GameState.Joinable
? GameState.Joinable
: context.GameState.Started
? GameState.Started
: GameState.NotStarted;
if (state != this.lastState && state == GameState.NotStarted)
{
ResetGame();
}
var lynched = false;
var abilityArguments = new string[0];
var player = this.playerHandler.Get(viewerContext);
if (player != null)
{
lynched = player.Lynched;
abilityArguments = player.Role.GetUsableArguments(player, this.context);
}
var isPlaying = playerHandler.IsPlaying(viewerContext);
this.lastState = state;
return(new GameStateResponse(
state,
isPlaying,
lynched,
abilityArguments,
GameInfo.FromUpdateInfo(context.GameState, isPlaying),
context.Revision));
}
}
public bool Validate(string token, out TwitchViewer viewer)
{
viewer = null;
if (string.IsNullOrEmpty(token))
{
return(false);
}
if (token.StartsWith("bearer", StringComparison.InvariantCultureIgnoreCase))
{
token = token.Substring(token.IndexOf(" ", StringComparison.Ordinal)).Trim();
}
var extension = this.extensionManager.GetExtension("4bsfmhaxm72zd5izc8dj2ru7mqpmi0");
var principal = extension.Verify(token, out var validTokenOverlay);
var userId = principal.Claims.FirstOrDefault(x => x.Type == "user_id");
var channelId = principal.Claims.FirstOrDefault(x => x.Type == "channel_id");
var extensionId = principal.Claims.FirstOrDefault(x => x.Type == "extension_id");
var opaqueUserId = principal.Claims.FirstOrDefault(x => x.Type == "opaque_user_id");
//this.extensionManager.GetExtension()
if ((opaqueUserId == null && userId == null) || channelId == null)
{
return(false);
}
viewer = new TwitchViewer(
userId?.Value,
opaqueUserId?.Value,
channelId.Value,
extensionId?.Value);
return(true);
}
public Task <UseAbilityResponse> UseAbility(TwitchViewer viewerContext, string arguments)
{
return(AwaitResponse <UseAbilityResponse>("use-ability", viewerContext.Identifier, arguments));
}
public Task <DeathNoteResponse> UpdateDeathNote(TwitchViewer viewerContext, string deathNote)
{
return(AwaitResponse <DeathNoteResponse>("death-note", viewerContext.Identifier, deathNote));
}
public Task <LastWillResponse> UpdateLastWill(TwitchViewer viewerContext, string lastWill)
{
return(AwaitResponse <LastWillResponse>("last-will", viewerContext.Identifier, lastWill));
}
public Task <ChatMessage> SendChatMessageAsync(TwitchViewer viewerContext, string channel, string message)
{
return(AwaitChatResponse(viewerContext.Identifier, channel, message));
}
public Task <VoteResponse> VoteAsync(TwitchViewer viewerContext, string value)
{
return(AwaitResponse <VoteResponse>("vote", viewerContext.Identifier, value));
}
