281 lines
10 KiB
GDScript
281 lines
10 KiB
GDScript
extends Node
|
|
class_name Gift
|
|
|
|
# The underlying websocket sucessfully connected to twitch.
|
|
signal twitch_connected
|
|
# The connection has been closed. Not emitted if twitch announced a reconnect.
|
|
signal twitch_disconnected
|
|
# The connection to twitch failed.
|
|
signal twitch_unavailable
|
|
# Twitch requested the client to reconnect. (Will be unavailable until next connect)
|
|
signal twitch_reconnect
|
|
# The client tried to login. Returns true if successful, else false.
|
|
signal login_attempt(success)
|
|
# User sent a message in chat.
|
|
signal chat_message(sender_data, message)
|
|
# User sent a whisper message.
|
|
signal whisper_message(sender_data, message)
|
|
# Unhandled data passed through
|
|
signal unhandled_message(message, tags)
|
|
# A command has been called with invalid arg count
|
|
signal cmd_invalid_argcount(cmd_name, sender_data, cmd_data, arg_ary)
|
|
# A command has been called with insufficient permissions
|
|
signal cmd_no_permission(cmd_name, sender_data, cmd_data, arg_ary)
|
|
# Twitch's ping is about to be answered with a pong.
|
|
signal pong
|
|
# Emote has been downloaded
|
|
signal emote_downloaded(emote_id)
|
|
# Badge has been downloaded
|
|
signal badge_downloaded(badge_name)
|
|
|
|
# Messages starting with one of these symbols are handled as commands. '/' will be ignored, reserved by Twitch.
|
|
export(Array, String) var command_prefixes : Array = ["!"]
|
|
# Time to wait in msec after each sent chat message. Values below ~310 might lead to a disconnect after 100 messages.
|
|
export(int) var chat_timeout_ms = 320
|
|
export(bool) var get_images : bool = false
|
|
# If true, caches emotes/badges to disk, so that they don't have to be redownloaded on every restart.
|
|
# This however means that they might not be updated if they change until you clear the cache.
|
|
export(bool) var disk_cache : bool = false
|
|
# Disk Cache has to be enbaled for this to work
|
|
export(String, FILE) var disk_cache_path = "user://gift/cache"
|
|
|
|
var websocket := WebSocketClient.new()
|
|
var user_regex := RegEx.new()
|
|
var twitch_restarting
|
|
# Twitch disconnects connected clients if too many chat messages are being sent. (At about 100 messages/30s)
|
|
var chat_queue = []
|
|
var last_msg = OS.get_ticks_msec()
|
|
# Mapping of channels to their channel info, like available badges.
|
|
var channels : Dictionary = {}
|
|
var commands : Dictionary = {}
|
|
var image_cache : ImageCache
|
|
|
|
# Required permission to execute the command
|
|
enum PermissionFlag {
|
|
EVERYONE = 0,
|
|
VIP = 1,
|
|
SUB = 2,
|
|
MOD = 4,
|
|
STREAMER = 8,
|
|
# Mods and the streamer
|
|
MOD_STREAMER = 12,
|
|
# Everyone but regular viewers
|
|
NON_REGULAR = 15
|
|
}
|
|
|
|
# Where the command should be accepted
|
|
enum WhereFlag {
|
|
CHAT = 1,
|
|
WHISPER = 2
|
|
}
|
|
|
|
func _init():
|
|
websocket.verify_ssl = true
|
|
user_regex.compile("(?<=!)[\\w]*(?=@)")
|
|
|
|
func _ready() -> void:
|
|
websocket.connect("data_received", self, "data_received")
|
|
websocket.connect("connection_established", self, "connection_established")
|
|
websocket.connect("connection_closed", self, "connection_closed")
|
|
websocket.connect("server_close_request", self, "sever_close_request")
|
|
websocket.connect("connection_error", self, "connection_error")
|
|
if(get_images):
|
|
image_cache = ImageCache.new(disk_cache, disk_cache_path)
|
|
|
|
func connect_to_twitch() -> void:
|
|
if(websocket.connect_to_url("wss://irc-ws.chat.twitch.tv:443") != OK):
|
|
print_debug("Could not connect to Twitch.")
|
|
emit_signal("twitch_unavailable")
|
|
|
|
func _process(delta : float) -> void:
|
|
if(websocket.get_connection_status() != NetworkedMultiplayerPeer.CONNECTION_DISCONNECTED):
|
|
websocket.poll()
|
|
if (!chat_queue.empty() && (last_msg + chat_timeout_ms) <= OS.get_ticks_msec()):
|
|
send(chat_queue.pop_front())
|
|
last_msg = OS.get_ticks_msec()
|
|
|
|
# Login using a oauth token.
|
|
# You will have to either get a oauth token yourself or use
|
|
# https://twitchapps.com/tokengen/
|
|
# to generate a token with custom scopes.
|
|
func authenticate_oauth(nick : String, token : String) -> void:
|
|
websocket.get_peer(1).set_write_mode(WebSocketPeer.WRITE_MODE_TEXT)
|
|
send("PASS " + ("" if token.begins_with("oauth:") else "oauth:") + token, true)
|
|
send("NICK " + nick.to_lower())
|
|
request_caps()
|
|
|
|
func request_caps(caps : String = "twitch.tv/commands twitch.tv/tags twitch.tv/membership") -> void:
|
|
send("CAP REQ :" + caps)
|
|
|
|
# Sends a String to Twitch.
|
|
func send(text : String, token : bool = false) -> void:
|
|
websocket.get_peer(1).put_packet(text.to_utf8())
|
|
if(OS.is_debug_build()):
|
|
if(!token):
|
|
print("< " + text.strip_edges(false))
|
|
else:
|
|
print("< PASS oauth:******************************")
|
|
|
|
# Sends a chat message to a channel. Defaults to the only connected channel.
|
|
func chat(message : String, channel : String = ""):
|
|
var keys : Array = channels.keys()
|
|
if(channel != ""):
|
|
chat_queue.append("PRIVMSG " + ("" if channel.begins_with("#") else "#") + channel + " :" + message + "\r\n")
|
|
elif(keys.size() == 1):
|
|
chat_queue.append("PRIVMSG #" + channels.keys()[0] + " :" + message + "\r\n")
|
|
else:
|
|
print_debug("No channel specified.")
|
|
|
|
func whisper(message : String, target : String) -> void:
|
|
chat("/w " + target + " " + message)
|
|
|
|
func data_received() -> void:
|
|
var messages : PoolStringArray = websocket.get_peer(1).get_packet().get_string_from_utf8().strip_edges(false).split("\r\n")
|
|
var tags = {}
|
|
for message in messages:
|
|
if(message.begins_with("@")):
|
|
var msg : PoolStringArray = message.split(" ", false, 1)
|
|
message = msg[1]
|
|
for tag in msg[0].split(";"):
|
|
var pair = tag.split("=")
|
|
tags[pair[0]] = pair[1]
|
|
if(OS.is_debug_build()):
|
|
print("> " + message)
|
|
handle_message(message, tags)
|
|
|
|
# Registers a command on an object with a func to call, similar to connect(signal, instance, func).
|
|
func add_command(cmd_name : String, instance : Object, instance_func : String, max_args : int = 0, min_args : int = 0, permission_level : int = PermissionFlag.EVERYONE, where : int = WhereFlag.CHAT) -> void:
|
|
var func_ref = FuncRef.new()
|
|
func_ref.set_instance(instance)
|
|
func_ref.set_function(instance_func)
|
|
commands[cmd_name] = CommandData.new(func_ref, permission_level, max_args, min_args, where)
|
|
|
|
# Removes a single command or alias.
|
|
func remove_command(cmd_name : String) -> void:
|
|
commands.erase(cmd_name)
|
|
|
|
# Removes a command and all associated aliases.
|
|
func purge_command(cmd_name : String) -> void:
|
|
var to_remove = commands.get(cmd_name)
|
|
if(to_remove):
|
|
var remove_queue = []
|
|
for command in commands.keys():
|
|
if(commands[command].func_ref == to_remove.func_ref):
|
|
remove_queue.append(command)
|
|
for queued in remove_queue:
|
|
commands.erase(queued)
|
|
|
|
func add_alias(cmd_name : String, alias : String) -> void:
|
|
if(commands.has(cmd_name)):
|
|
commands[alias] = commands.get(cmd_name)
|
|
|
|
func add_aliases(cmd_name : String, aliases : PoolStringArray) -> void:
|
|
for alias in aliases:
|
|
add_alias(cmd_name, alias)
|
|
|
|
func handle_message(message : String, tags : Dictionary) -> void:
|
|
if(message == ":tmi.twitch.tv NOTICE * :Login authentication failed"):
|
|
print_debug("Authentication failed.")
|
|
emit_signal("login_attempt", false)
|
|
return
|
|
if(message == "PING :tmi.twitch.tv"):
|
|
send("PONG :tmi.twitch.tv")
|
|
emit_signal("pong")
|
|
return
|
|
var msg : PoolStringArray = message.split(" ", true, 3)
|
|
match msg[1]:
|
|
"001":
|
|
print_debug("Authentication successful.")
|
|
emit_signal("login_attempt", true)
|
|
"PRIVMSG":
|
|
var sender_data : SenderData = SenderData.new(user_regex.search(msg[0]).get_string(), msg[2], tags)
|
|
handle_command(sender_data, msg[3].split(" ", true, 1))
|
|
emit_signal("chat_message", sender_data, msg[3].right(1))
|
|
"WHISPER":
|
|
var sender_data : SenderData = SenderData.new(user_regex.search(msg[0]).get_string(), msg[2], tags)
|
|
handle_command(sender_data, msg[3].split(" ", true, 1), true)
|
|
emit_signal("whisper_message", sender_data, msg[3].right(1))
|
|
"RECONNECT":
|
|
twitch_restarting = true
|
|
_:
|
|
emit_signal("unhandled_message", message, tags)
|
|
|
|
func handle_command(sender_data : SenderData, msg : PoolStringArray, whisper : bool = false) -> void:
|
|
if(command_prefixes.has(msg[0].substr(1, 1))):
|
|
var command : String = msg[0].right(2)
|
|
var cmd_data : CommandData = commands.get(command)
|
|
if(cmd_data):
|
|
if(whisper == true && cmd_data.where & WhereFlag.WHISPER != WhereFlag.WHISPER):
|
|
return
|
|
elif(whisper == false && cmd_data.where & WhereFlag.CHAT != WhereFlag.CHAT):
|
|
return
|
|
var args = "" if msg.size() == 1 else msg[1]
|
|
var arg_ary : PoolStringArray = PoolStringArray() if args == "" else args.split(" ")
|
|
if(arg_ary.size() > cmd_data.max_args && cmd_data.max_args != -1 || arg_ary.size() < cmd_data.min_args):
|
|
emit_signal("cmd_invalid_argcount", command, sender_data, cmd_data, arg_ary)
|
|
print_debug("Invalid argcount!")
|
|
return
|
|
if(cmd_data.permission_level != 0):
|
|
var user_perm_flags = get_perm_flag_from_tags(sender_data.tags)
|
|
if(user_perm_flags & cmd_data.permission_level != cmd_data.permission_level):
|
|
emit_signal("cmd_no_permission", command, sender_data, cmd_data, arg_ary)
|
|
print_debug("No Permission for command!")
|
|
return
|
|
if(arg_ary.size() == 0):
|
|
cmd_data.func_ref.call_func(CommandInfo.new(sender_data, command, whisper))
|
|
else:
|
|
cmd_data.func_ref.call_func(CommandInfo.new(sender_data, command, whisper), arg_ary)
|
|
|
|
func get_perm_flag_from_tags(tags : Dictionary) -> int:
|
|
var flag = 0
|
|
var entry = tags.get("badges")
|
|
if(entry):
|
|
for badge in entry.split(","):
|
|
if(badge.begins_with("vip")):
|
|
flag += PermissionFlag.VIP
|
|
if(badge.begins_with("broadcaster")):
|
|
flag += PermissionFlag.STREAMER
|
|
entry = tags.get("mod")
|
|
if(entry):
|
|
if(entry == "1"):
|
|
flag += PermissionFlag.MOD
|
|
entry = tags.get("subscriber")
|
|
if(entry):
|
|
if(entry == "1"):
|
|
flag += PermissionFlag.SUB
|
|
return flag
|
|
|
|
func join_channel(channel : String) -> void:
|
|
var lower_channel : String = channel.to_lower()
|
|
send("JOIN #" + lower_channel)
|
|
channels[lower_channel] = {}
|
|
|
|
func leave_channel(channel : String) -> void:
|
|
var lower_channel : String = channel.to_lower()
|
|
send("PART #" + lower_channel)
|
|
channels.erase(lower_channel)
|
|
|
|
func connection_established(protocol : String) -> void:
|
|
print_debug("Connected to Twitch.")
|
|
emit_signal("twitch_connected")
|
|
|
|
func connection_closed(was_clean_close : bool) -> void:
|
|
if(twitch_restarting):
|
|
print_debug("Reconnecting to Twitch")
|
|
emit_signal("twitch_reconnect")
|
|
connect_to_twitch()
|
|
yield(self, "twitch_connected")
|
|
for channel in channels.keys():
|
|
join_channel(channel)
|
|
twitch_restarting = false
|
|
else:
|
|
print_debug("Disconnected from Twitch.")
|
|
emit_signal("twitch_disconnected")
|
|
|
|
func connection_error() -> void:
|
|
print_debug("Twitch is unavailable.")
|
|
emit_signal("twitch_unavailable")
|
|
|
|
func server_close_request(code : int, reason : String) -> void:
|
|
pass
|