issork/gift
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases Wiki Activity

refactoring

Browse Source
This commit is contained in:
Max Kross 2023-12-02 14:20:20 +01:00
parent 0545456faa
commit 3da055ad87
36 changed files with 1078 additions and 1179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
Example.gd Normal file
View File

@ -0,0 +1,156 @@
extends Control
# Your client id. You can share this publicly. Default is my own client_id.
# Please do not ship your project with my client_id, but feel free to test with it.
# Visit https://dev.twitch.tv/console/apps/create to create a new application.
# You can then find your client id at the bottom of the application console.
# DO NOT SHARE THE CLIENT SECRET. If you do, regenerate it.
@export var client_id : String = "9x951o0nd03na7moohwetpjjtds0or"
# The name of the channel we want to connect to.
@export var channel : String
# The username of the bot account.
@export var username : String
var id : TwitchIDConnection
var api : TwitchAPIConnection
var irc : TwitchIRCConnection
var eventsub : TwitchEventSubConnection
var cmd_handler : GIFTCommandHandler = GIFTCommandHandler.new()
var iconloader : TwitchIconDownloader
func _ready() -> void:
# We will login using the Implicit Grant Flow, which only requires a client_id.
# Alternatively, you can use the Authorization Code Grant Flow or the Client Credentials Grant Flow.
# Note that the Client Credentials Grant Flow will only return an AppAccessToken, which can not be used
# for the majority of the Twitch API or to join a chat room.
var auth : ImplicitGrantFlow = ImplicitGrantFlow.new()
# For the auth to work, we need to poll it regularly.
get_tree().process_frame.connect(auth.poll) # You can also use a timer if you don't want to poll on every frame.
# Next, we actually get our token to authenticate. We want to be able to read and write messages,
# so we request the required scopes. See https://dev.twitch.tv/docs/authentication/scopes/#twitch-access-token-scopes
var token : UserAccessToken = await(auth.login(client_id, ["chat:read", "chat:edit"]))
if (token == null):
# Authentication failed. Abort.
return
# Store the token in the ID connection, create all other connections.
id = TwitchIDConnection.new(token)
irc = TwitchIRCConnection.new(id)
api = TwitchAPIConnection.new(id)
iconloader = TwitchIconDownloader.new(api)
# For everything to work, the id connection has to be polled regularly.
get_tree().process_frame.connect(id.poll)
# Connect to the Twitch chat.
if(!await(irc.connect_to_irc(username))):
# Authentication failed. Abort.
return
# Request the capabilities. By default only twitch.tv/commands and twitch.tv/tags are used.
# Refer to https://dev.twitch.tv/docs/irc/capabilities/ for all available capapbilities.
irc.request_capabilities()
# Join the channel specified in the exported 'channel' variable.
irc.join_channel(channel)
# Add a helloworld command.
cmd_handler.add_command("helloworld", hello)
# The helloworld command can now also be executed with "hello"!
cmd_handler.add_alias("helloworld", "hello")
# Add a list command that accepts between 1 and infinite args.
cmd_handler.add_command("list", list, -1, 1)
# For the cmd handler to receive the messages, we have to forward them.
irc.chat_message.connect(cmd_handler.handle_command)
# If you also want to accept whispers, connect the signal and bind true as the last arg.
irc.whisper_message.connect(cmd_handler.handle_command.bind(true))
# For the chat example to work, we forward the messages received to the put_chat function.
irc.chat_message.connect(put_chat)
# When we press enter on the chat bar or press the send button, we want to execute the send_message
# function.
%LineEdit.text_submitted.connect(send_message.unbind(1))
%Button.pressed.connect(send_message)
# This part of the example only works if GIFT is logged in to your broadcaster account.
# If you are, you can uncomment this to also try receiving follow events.
# eventsub = TwitchEventSubConnection.new(api)
# eventsub.connect_to_eventsub()
# eventsub.event.connect(on_event)
# var user_ids : Dictionary = await(api.get_users_by_name([username]))
# print(user_ids)
# if (user_ids.has("data") && user_ids["data"].size() > 0):
# var user_id : String = user_ids["data"][0]["id"]
# eventsub.subscribe_event("channel.follow", 2, {"broadcaster_user_id": user_id, "moderator_user_id": user_id})
func hello(cmd_info : CommandInfo) -> void:
irc.chat("Hello World!")
func list(cmd_info : CommandInfo, arg_ary : PackedStringArray) -> void:
irc.chat(", ".join(arg_ary))
func on_event(type : String, data : Dictionary) -> void:
match(type):
"channel.follow":
print("%s followed your channel!" % data["user_name"])
func send_message() -> void:
irc.chat(%LineEdit.text)
%LineEdit.text = ""
func put_chat(senderdata : SenderData, msg : String):
var bottom : bool = %ChatScrollContainer.scroll_vertical == %ChatScrollContainer.get_v_scroll_bar().max_value - %ChatScrollContainer.get_v_scroll_bar().get_rect().size.y
var label : RichTextLabel = RichTextLabel.new()
var time = Time.get_time_dict_from_system()
label.fit_content = true
label.selection_enabled = true
label.push_font_size(12)
label.push_color(Color.WEB_GRAY)
label.add_text("%02d:%02d " % [time["hour"], time["minute"]])
label.pop()
label.push_font_size(14)
var badges : Array[Texture2D]
for badge in senderdata.tags["badges"].split(",", false):
label.add_image(await(iconloader.get_badge(badge, senderdata.tags["room-id"])), 0, 0, Color.WHITE, INLINE_ALIGNMENT_CENTER)
label.push_bold()
if (senderdata.tags["color"] != ""):
label.push_color(Color(senderdata.tags["color"]))
label.add_text(" %s" % senderdata.tags["display-name"])
label.push_color(Color.WHITE)
label.push_normal()
label.add_text(": ")
var locations : Array[EmoteLocation] = []
if (senderdata.tags.has("emotes")):
for emote in senderdata.tags["emotes"].split("/", false):
var data : PackedStringArray = emote.split(":")
for d in data[1].split(","):
var start_end = d.split("-")
locations.append(EmoteLocation.new(data[0], int(start_end[0]), int(start_end[1])))
locations.sort_custom(Callable(EmoteLocation, "smaller"))
if (locations.is_empty()):
label.add_text(msg)
else:
var offset = 0
for loc in locations:
label.add_text(msg.substr(offset, loc.start - offset))
label.add_image(await(iconloader.get_emote(loc.id)), 0, 0, Color.WHITE, INLINE_ALIGNMENT_CENTER)
offset = loc.end + 1
%Messages.add_child(label)
await(get_tree().process_frame)
if (bottom):
%ChatScrollContainer.scroll_vertical = %ChatScrollContainer.get_v_scroll_bar().max_value
class EmoteLocation extends RefCounted:
var id : String
var start : int
var end : int
func _init(emote_id, start_idx, end_idx):
self.id = emote_id
self.start = start_idx
self.end = end_idx
static func smaller(a : EmoteLocation, b : EmoteLocation):
return a.start < b.start

23
example/Example.tscn → Example.tscn
View File

@ -1,9 +1,6 @@
[gd_scene load_steps=5 format=3 uid="uid://bculs28gstcxk"]
[gd_scene load_steps=2 format=3 uid="uid://bculs28gstcxk"]
[ext_resource type="Script" path="res://example/Gift.gd" id="1_yfglq"]
[ext_resource type="Script" path="res://example/ChatContainer.gd" id="2_knohk"]
[ext_resource type="Script" path="res://example/LineEdit.gd" id="3_oafvo"]
[ext_resource type="Script" path="res://example/Button.gd" id="4_wrvcq"]
[ext_resource type="Script" path="res://Example.gd" id="1_8267x"]
[node name="Example" type="Control"]
layout_mode = 3
@ -12,18 +9,12 @@ anchor_right = 1.0
anchor_bottom = 1.0
grow_horizontal = 2
grow_vertical = 2
[node name="Gift" type="Node" parent="."]
unique_name_in_owner = true
script = ExtResource("1_yfglq")
scopes = Array[String](["chat:edit", "chat:read", "moderator:read:followers"])
script = ExtResource("1_8267x")
[node name="ChatContainer" type="VBoxContainer" parent="."]
unique_name_in_owner = true
layout_mode = 0
anchor_right = 1.0
anchor_bottom = 1.0
script = ExtResource("2_knohk")
[node name="Chat" type="Panel" parent="ChatContainer"]
show_behind_parent = true
@ -31,13 +22,15 @@ layout_mode = 2
size_flags_horizontal = 3
size_flags_vertical = 3
[node name="ScrollContainer" type="ScrollContainer" parent="ChatContainer/Chat"]
[node name="ChatScrollContainer" type="ScrollContainer" parent="ChatContainer/Chat"]
unique_name_in_owner = true
layout_mode = 0
anchor_right = 1.0
anchor_bottom = 1.0
follow_focus = true
[node name="ChatMessagesContainer" type="VBoxContainer" parent="ChatContainer/Chat/ScrollContainer"]
[node name="Messages" type="VBoxContainer" parent="ChatContainer/Chat/ChatScrollContainer"]
unique_name_in_owner = true
layout_mode = 2
size_flags_horizontal = 3
size_flags_vertical = 3
@ -51,10 +44,8 @@ layout_mode = 2
size_flags_horizontal = 3
size_flags_vertical = 3
caret_blink = true
script = ExtResource("3_oafvo")
[node name="Button" type="Button" parent="ChatContainer/HBoxContainer"]
unique_name_in_owner = true
layout_mode = 2
text = "Send"
script = ExtResource("4_wrvcq")

198
README.md
View File

@ -1,208 +1,16 @@
# GIFT
Godot IRC For Twitch addon
To use this plugin, you need to create a new application on dev.twitch.tv to get a client ID and a client secret. The redirect URL of your App has to be http://localhost:18297.
The example expects an `auth.txt` file in the example folder with 3 lines (client id, client secret, channel to join)
To use this plugin, you need to create a new application on dev.twitch.tv to get a client ID and possibly a client secret (depending on which authentication method you choose). The redirect URL of your App has to be http://localhost:18297 or the URL you specify in the RedirectingFlow constructor.
If you require help, feel free to join my >[Discord Server](https://discord.gg/28DQbuwMM2)< and ask your questions <3
- [Examples](https://github.com/MennoMax/gift#Examples)
- [API](https://github.com/MennoMax/gift#API)
- [Exported Variables](https://github.com/MennoMax/gift#Exported-Variables)
- [Signals](https://github.com/MennoMax/gift#Signals)
- [Functions](https://github.com/MennoMax/gift#Functions)
- [Utility Classes](https://github.com/MennoMax/gift#Utility-Classes)
Below is a working example of this plugin, which is included in this project. A replication of the twitch chat. Most information about the Twitch API can be found in the [official documentation](https://dev.twitch.tv/docs/).
***
Below is a working example of this plugin, which is included in this project. A replication of the twitch chat.
[Example.gd](https://github.com/issork/gift/blob/master/Example.gd)
![image](https://user-images.githubusercontent.com/12477395/119052327-b9fc9980-b9c4-11eb-8f45-a2a8f2d98977.png)
### Examples
The following code is also [included](https://github.com/MennoMax/gift/blob/master/example/Gift.gd) in this repository.
```gdscript
extends Gift
func _ready() -> void:
cmd_no_permission.connect(no_permission)
chat_message.connect(on_chat)
event.connect(on_event)
# I use a file in the working directory to store auth data
# so that I don't accidentally push it to the repository.
# Replace this or create a auth file with 3 lines in your
# project directory:
# <client_id>
# <client_secret>
# <initial channel>
var authfile := FileAccess.open("./auth", FileAccess.READ)
client_id = authfile.get_line()
client_secret = authfile.get_line()
var initial_channel = authfile.get_line()
# When calling this method, a browser will open.
# Log in to the account that should be used.
await(authenticate(client_id, client_secret))
var success = await(connect_to_irc())
if (success):
request_caps()
join_channel(initial_channel)
await(connect_to_eventsub())
# Refer to https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/ for details on
# what events exist, which API versions are available and which conditions are required.
# Make sure your token has all required scopes for the event.
subscribe_event("channel.follow", 2, {"broadcaster_user_id": user_id, "moderator_user_id": user_id})
# Adds a command with a specified permission flag.
# All implementations must take at least one arg for the command info.
# Implementations that recieve args requrires two args,
# the second arg will contain all params in a PackedStringArray
# This command can only be executed by VIPS/MODS/SUBS/STREAMER
add_command("test", command_test, 0, 0, PermissionFlag.NON_REGULAR)
# These two commands can be executed by everyone
add_command("helloworld", hello_world)
add_command("greetme", greet_me)
# This command can only be executed by the streamer
add_command("streamer_only", streamer_only, 0, 0, PermissionFlag.STREAMER)
# Command that requires exactly 1 arg.
add_command("greet", greet, 1, 1)
# Command that prints every arg seperated by a comma (infinite args allowed), at least 2 required
add_command("list", list, -1, 2)
# Adds a command alias
add_alias("test","test1")
add_alias("test","test2")
add_alias("test","test3")
# Or do it in a single line
# add_aliases("test", ["test1", "test2", "test3"])
# Remove a single command
remove_command("test2")
# Now only knows commands "test", "test1" and "test3"
remove_command("test")
# Now only knows commands "test1" and "test3"
# Remove all commands that call the same function as the specified command
purge_command("test1")
# Now no "test" command is known
# Send a chat message to the only connected channel (<channel_name>)
# Fails, if connected to more than one channel.
# chat("TEST")
# Send a chat message to channel <channel_name>
# chat("TEST", initial_channel)
# Send a whisper to target user
# whisper("TEST", initial_channel)
func on_event(type : String, data : Dictionary) -> void:
match(type):
"channel.follow":
print("%s followed your channel!" % data["user_name"])
func on_chat(data : SenderData, msg : String) -> void:
%ChatContainer.put_chat(data, msg)
# Check the CommandInfo class for the available info of the cmd_info.
func command_test(cmd_info : CommandInfo) -> void:
print("A")
func hello_world(cmd_info : CommandInfo) -> void:
chat("HELLO WORLD!")
func streamer_only(cmd_info : CommandInfo) -> void:
chat("Streamer command executed")
func no_permission(cmd_info : CommandInfo) -> void:
chat("NO PERMISSION!")
func greet(cmd_info : CommandInfo, arg_ary : PackedStringArray) -> void:
chat("Greetings, " + arg_ary[0])
func greet_me(cmd_info : CommandInfo) -> void:
chat("Greetings, " + cmd_info.sender_data.tags["display-name"] + "!")
func list(cmd_info : CommandInfo, arg_ary : PackedStringArray) -> void:
var msg = ""
for i in arg_ary.size() - 1:
msg += arg_ary[i]
msg += ", "
msg += arg_ary[arg_ary.size() - 1]
chat(msg)
```
***
## API
### Exported Variables
- **command_prefix**: Array[String] - Prefixes for commands. Every message that starts with one of these will be interpreted as one.
- **chat_timeout** : float - Time to wait before sending the next chat message. Values below ~0.31 will lead to a disconnect at 100 messages in the queue.
- **scopes** : Array[String] - Scopes to request when creating your user token. Check https://dev.twitch.tv/docs/authentication/scopes/ for a list of all available scopes.
- **events** : Array[String] - Events to subscribe to with the EventSub. Full list available at https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/
- **disk_cache** : bool - If true, badges and emotes will be cached on the disk instead of only in RAM.
- **disk_cache_path** : String - Path to the cache folder on the hard drive.
***
### Signals:
|Signal|Params|Description|
|-|-|-|
|twitch_connected|-|The underlying websocket successfully connected to Twitch IRC.|
|twitch_disconnected|-|The connection has been closed. Not emitted if Twitch IRC announced a reconnect.|
|twitch_unavailbale|-|Could not establish a connection to Twitch IRC.|
|twitch_reconnect|-|Twitch IRC requested the client to reconnect. (Will be unavailable until next connect)|
|-|-|-|
|user_token_received|token_data(Dictionary)|User token from Twitch has been fetched.|
|user_token_valid|-|User token has been checked and is valid.|
|user_token_invalid|-|User token has been checked and is invalid.|
|login_attempt|success(bool) - wether or not the login attempt was successful|The client tried to login to Twitch IRC. Returns true if successful, else false.|
|-|-|-|
|chat_message|sender_data(SenderData), message(String)|User sent a message in chat.|
|whisper_message|sender_data(SenderData), message(String)|User sent a whisper message.|
|unhandled message|message(String), tags(Dictionary)|Unhandled message from Twitch.|
|cmd_invalid_argcount|cmd_name(String), sender_data(SenderData), cmd_data(CommandData), arg_ary(PackedStringArray)|A command has been called by a chatter with an invalid amount of args.|
|cmd_no_permission|cmd_name(String), sender_data(SenderData), cmd_data(CommandData), arg_ary(PackedStringArray)|A command has been called by a chatter without having the required permissions.|
|pong|-|A ping from Twitch has been answered with a pong.|
|-|-|-|
|events_connected|-|The underlying websocket sucessfully connected to Twitch EventSub.|
|events_unavailable|-|The connection to Twitch EventSub failed.|
|events_disconnected|-|The underlying websocket disconnected from Twitch EventSub.|
|events_id(id)|id(String))|The id has been received from the welcome message.|
|events_reconnect|-|Twitch directed the bot to reconnect to a different URL.|
|events_revoked|event(String), reason(String)|Twitch revoked a event subscription|
|event|type(String), data(Dictionary)|A subscribed eventsub event omitted data.|
***
### Functions:
|Function|Params|Description|
|-|-|-|
|authenticate|client_id(String), client_secret(String)|Request a OAUTH token from Twitch with your client_id and client_secret|
|connect_to_irc|-|Connect to Twitch IRC. Make sure to authenticate first.|
|connect_to_eventsub|url(String) - only used when Twitch requests a reconnect to a specific URL|Connect to Twitch EventSub. Make sure to authenticate first.|
|request_caps|caps(String) - capabilities to request from twitch|Request capabilities from Twitch.|
|send|text(string) - the UTF8-String that should be sent to Twitch|Sends a UTF8-String to Twitch over the websocket.|
|chat|message(String), channel(String) - DEFAULT: Only connected channel|Sends a chat message to a channel.|
|whisper|message(String), target(String)| Sends a whisper message to the specified user.|
|add_command|cmd_name(String), function(Callable), max_args(int), min_args(int), permission_level(int), where(int)| Registers a command with a function to call on a specified object. You can also set min/max args allowed and where (whisper or chat) the command execution should be allowed to be requested.|
|remove_command|cmd_name(String)|Removes a single command or alias from the command registry.|
|purge_command|cmd_name(String)| Removes all commands that call the same function on the same object as the specified command.|
|add_alias|cmd_name(String), alias(String)|Registers a command alias.|
|add_aliases|cmd_name(String), aliases(PoolStringArray)|Registers all command aliases in the array.|
|join_channel|channel(String)|Joins a channel.|
|leave_channel|channel(String)|Leaves a channel.|
***
### Utility Classes

125
addons/gift/api_connection.gd Normal file
View File

@ -0,0 +1,125 @@
class_name TwitchAPIConnection
extends RefCounted
signal received_response(response)
var id_conn : TwitchIDConnection
var client : HTTPClient = HTTPClient.new()
var client_response : PackedByteArray = []
func _init(id_connection : TwitchIDConnection) -> void:
client.blocking_mode_enabled = true
id_conn = id_connection
id_conn.polled.connect(poll)
client.connect_to_host("https://api.twitch.tv", -1, TLSOptions.client())
func poll() -> void:
client.poll()
if (client.get_status() == HTTPClient.STATUS_BODY):
client_response += client.read_response_body_chunk()
elif (!client_response.is_empty()):
received_response.emit(client_response.get_string_from_utf8())
client_response.clear()
func request(method : int, url : String, headers : PackedStringArray, body : String = "") -> Dictionary:
client.request(method, url, headers)
var response = await(received_response)
match (client.get_response_code()):
401:
id_conn.token_invalid.emit()
return {}
return JSON.parse_string(response)
func get_channel_chat_badges(broadcaster_id : String) -> Dictionary:
var headers : PackedStringArray = [
"Authorization: Bearer %s" % id_conn.last_token.token,
"Client-Id: %s" % id_conn.last_token.last_client_id
]
return await(request(HTTPClient.METHOD_GET,"/helix/chat/badges?broadcaster_id=%s" % broadcaster_id, headers))
func get_global_chat_badges() -> Dictionary:
var headers : PackedStringArray = [
"Authorization: Bearer %s" % id_conn.last_token.token,
"Client-Id: %s" % id_conn.last_token.last_client_id
]
return await(request(HTTPClient.METHOD_GET,"/helix/chat/badges/global", headers))
# Create a eventsub subscription. For the data required, refer to https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/
func create_eventsub_subscription(subscription_data : Dictionary) -> Dictionary:
var headers : PackedStringArray = [
"Authorization: Bearer %s" % id_conn.last_token.token,
"Client-Id: %s" % id_conn.last_token.last_client_id,
"Content-Type: application/json"
]
var response = await(request(HTTPClient.METHOD_POST, "/helix/eventsub/subscriptions", headers, JSON.stringify(subscription_data)))
match (client.get_response_code()):
400:
print("Bad Request! Check the data you specified.")
return {}
403:
print("Forbidden! The access token is missing the required scopes.")
return {}
409:
print("Conflict! A subscription already exists for the specified event type and condition combination.")
return {}
429:
print("Too Many Requests! The request exceeds the number of subscriptions that you may create with the same combination of type and condition values.")
return {}
return response
func get_users_by_id(ids : Array[String]) -> Dictionary:
return await(get_users([], ids))
func get_users_by_name(names : Array[String]) -> Dictionary:
return await(get_users(names, []))
func get_users(names : Array[String], ids : Array[String]) -> Dictionary:
var headers : PackedStringArray = [
"Authorization: Bearer %s" % id_conn.last_token.token,
"Client-Id: %s" % id_conn.last_token.last_client_id
]
if (names.is_empty() && ids.is_empty()):
return {}
var params = "?"
if (names.size() > 0):
params += "login=%s" % names.pop_back()
while(names.size() > 0):
params += "&login=" % names.pop_back()
if (params.length() > 1):
params += "&"
if (ids.size() > 0):
params += "id=%s" % names.pop_back()
while(ids.size() > 0):
params += "&id=" % ids.pop_back()
var response = await(request(HTTPClient.METHOD_GET,"/helix/users/%s" % params, headers))
match (client.get_response_code()):
400:
id_conn.token_invalid.emit()
return {}
return response
# Send a whisper from user_id to target_id with the specified message.
# Returns true on success or if the message was silently dropped, false on failure.
func send_whisper(from_user_id : String, to_user_id : String, message : String) -> bool:
var headers : PackedStringArray = [
"Authorization: Bearer %s" % id_conn.last_token.token,
"Client-Id: %s" % id_conn.last_token.last_client_id,
"Content-Type: application/json"
]
var response = await(request(HTTPClient.METHOD_POST, "/helix/eventsub/whispers?from_user_id=%s&to_user_id=%s", headers, JSON.stringify({"message": message})))
match (client.get_response_code()):
204:
return true
400:
print("Bad Request! Check the data you specified.")
return false
403:
print("Forbidden! The account that's sending the message doesn't allow sending whispers.")
return false
404:
print("Not Found! The ID in to_user_id was not found.")
429:
print("Too Many Requests! The sending user exceeded the number of whisper requests that they may make.")
return false
return false

26
addons/gift/auth/grant_flows/auth_flow.gd Normal file
View File

@ -0,0 +1,26 @@
class_name TwitchOAuthFlow
extends RefCounted
signal token_received(token_data)
var peer : StreamPeerTCP
func _create_peer() -> StreamPeerTCP:
return null
func poll() -> void:
if (!peer):
peer = _create_peer()
if (peer && peer.get_status() == StreamPeerTCP.STATUS_CONNECTED):
_poll_peer()
elif (peer.get_status() == StreamPeerTCP.STATUS_CONNECTED):
_poll_peer()
func _poll_peer() -> void:
peer.poll()
if (peer.get_available_bytes() > 0):
var response = peer.get_utf8_string(peer.get_available_bytes())
_process_response(response)
func _process_response(response : String) -> void:
pass

57
addons/gift/auth/grant_flows/authorization_code_grant_flow.gd Normal file
View File

@ -0,0 +1,57 @@
class_name AuthorizationCodeGrantFlow
extends RedirectingFlow
signal auth_code_received(token)
signal http_connected
var http_client : HTTPClient
var chunks : PackedByteArray = PackedByteArray()
func get_authorization_code(client_id : String, scopes : PackedStringArray, force_verify : bool = false) -> String:
start_tcp_server()
OS.shell_open("https://id.twitch.tv/oauth2/authorize?response_type=code&client_id=%s&scope=%s&redirect_uri=%s&force_verify=%s" % [client_id, " ".join(scopes).uri_encode(), redirect_url, "true" if force_verify else "false"].map(func (a : String): return a.uri_encode()))
print("Waiting for user to login.")
var code : String = await(auth_code_received)
server.stop()
return code
func login(client_id : String, client_secret : String, auth_code : String = "", scopes : PackedStringArray = [], force_verify : bool = false) -> RefreshableUserAccessToken:
if (auth_code == ""):
auth_code = await(get_authorization_code(client_id, scopes, force_verify))
if (http_client == null):
http_client = HTTPClient.new()
http_client.connect_to_host("https://id.twitch.tv", -1, TLSOptions.client())
await(http_connected)
http_client.request(HTTPClient.METHOD_POST, "/oauth2/token", ["Content-Type: application/x-www-form-urlencoded"], "client_id=%s&client_secret=%s&code=%s&grant_type=authorization_code&redirect_uri=%s" % [client_id, client_secret, auth_code, redirect_url])
print("Using auth token to login.")
var token : RefreshableUserAccessToken = RefreshableUserAccessToken.new(await(token_received), client_id, client_secret)
token.fresh = true
return token
func poll() -> void:
if (server != null):
super.poll()
func _process_response(response : String) -> void:
if (response == ""):
print("Empty response. Check if your redirect URL is set to %s." % redirect_url)
return
var start : int = response.find("?")
if (start == -1):
print ("Response from Twitch does not contain the required data.")
else:
response = response.substr(start + 1, response.find(" ", start) - start)
var data : Dictionary = {}
for entry in response.split("&"):
var pair = entry.split("=")
data[pair[0]] = pair[1] if pair.size() > 0 else ""
if (data.has("error")):
var msg = "Error %s: %s" % [data["error"], data["error_description"]]
print(msg)
send_response("400 BAD REQUEST", msg.to_utf8_buffer())
else:
print("Success.")
send_response("200 OK", "<html><head><title>Twitch Login</title></head><body>Success!</body></html>".to_utf8_buffer())
auth_code_received.emit(data["code"])
peer.disconnect_from_host()
peer = null

30
addons/gift/auth/grant_flows/client_credentials_grant_flow.gd Normal file
View File

@ -0,0 +1,30 @@
class_name ClientCredentialsGrantFlow
extends TwitchOAuthFlow
signal http_connected
var http_client : HTTPClient
var chunks : PackedByteArray = PackedByteArray()
func poll() -> void:
if (http_client != null):
http_client.poll()
if (http_client.get_status() == HTTPClient.STATUS_CONNECTED):
http_connected.emit()
if (!chunks.is_empty()):
var response = chunks.get_string_from_utf8()
token_received.emit(JSON.parse_string(response))
chunks.clear()
http_client = null
elif (http_client.get_status() == HTTPClient.STATUS_BODY):
chunks += http_client.read_response_body_chunk()
func login(client_id : String, client_secret : String) -> AppAccessToken:
if (http_client == null):
http_client = HTTPClient.new()
http_client.connect_to_host("https://id.twitch.tv", -1, TLSOptions.client())
await(http_connected)
http_client.request(HTTPClient.METHOD_POST, "/oauth2/token", ["Content-Type: application/x-www-form-urlencoded"], "client_id=%s&client_secret=%s&grant_type=client_credentials" % [client_id, client_secret])
var token : AppAccessToken = AppAccessToken.new(await(token_received), client_id)
token.fresh = true
return token

48
addons/gift/auth/grant_flows/implicit_grant_flow.gd Normal file
View File

@ -0,0 +1,48 @@
class_name ImplicitGrantFlow
extends RedirectingFlow
# Get an OAuth token from Twitch. Returns null if authentication failed.
func login(client_id : String, scopes : PackedStringArray, force_verify : bool = false) -> UserAccessToken:
start_tcp_server()
OS.shell_open("https://id.twitch.tv/oauth2/authorize?response_type=token&client_id=%s&force_verify=%s&redirect_uri=%s&scope=%s" % [client_id, "true" if force_verify else "false", redirect_url, " ".join(scopes)].map(func (a : String): return a.uri_encode()))
print("Waiting for user to login.")
var token_data : Dictionary = await(token_received)
server.stop()
if (token_data != null):
var token : UserAccessToken = UserAccessToken.new(token_data, client_id)
token.fresh = true
return token
return null
func poll() -> void:
if (!peer):
peer = _create_peer()
if (peer && peer.get_status() == StreamPeerTCP.STATUS_CONNECTED):
_poll_peer()
elif (peer.get_status() == StreamPeerTCP.STATUS_CONNECTED):
_poll_peer()
func _process_response(response : String) -> void:
if (response == ""):
print("Empty response. Check if your redirect URL is set to %s." % redirect_url)
return
var start : int = response.find("?")
if (start == -1):
send_response("200 OK", "<html><script>window.location = window.location.toString().replace('#','?');</script><head><title>Twitch Login</title></head></html>".to_utf8_buffer())
else:
response = response.substr(start + 1, response.find(" ", start) - start)
var data : Dictionary = {}
for entry in response.split("&"):
var pair = entry.split("=")
data[pair[0]] = pair[1] if pair.size() > 0 else ""
if (data.has("error")):
var msg = "Error %s: %s" % [data["error"], data["error_description"]]
print(msg)
send_response("400 BAD REQUEST", msg.to_utf8_buffer())
else:
data["scope"] = data["scope"].uri_decode().split(" ")
print("Success.")
send_response("200 OK", "<html><head><title>Twitch Login</title></head><body>Success!</body></html>".to_utf8_buffer())
token_received.emit(data)
peer.disconnect_from_host()
peer = null

29
addons/gift/auth/grant_flows/redirecting_flow.gd Normal file
View File

@ -0,0 +1,29 @@
class_name RedirectingFlow
extends TwitchOAuthFlow
var server : TCPServer
var tcp_port : int
var redirect_url : String
func _init(port : int = 18297, redirect : String = "http://localhost:%s" % port) -> void:
tcp_port = port
redirect_url = redirect
func _create_peer() -> StreamPeerTCP:
return server.take_connection()
func start_tcp_server() -> void:
if (server == null):
server = TCPServer.new()
if (server.listen(tcp_port) != OK):
print("Could not listen to port %d" % tcp_port)
func send_response(response : String, body : PackedByteArray) -> void:
peer.put_data(("HTTP/1.1 %s\r\n" % response).to_utf8_buffer())
peer.put_data("Server: GIFT (Godot Engine)\r\n".to_utf8_buffer())
peer.put_data(("Content-Length: %d\r\n"% body.size()).to_utf8_buffer())
peer.put_data("Connection: close\r\n".to_utf8_buffer())
peer.put_data("Content-Type: text/html; charset=UTF-8\r\n".to_utf8_buffer())
peer.put_data("\r\n".to_utf8_buffer())
peer.put_data(body)

5
addons/gift/auth/tokens/app_token.gd Normal file
View File

@ -0,0 +1,5 @@
class_name AppAccessToken
extends TwitchToken
func _init(data : Dictionary, client_id) -> void:
super._init(data, client_id, data["expires_in"])

10
addons/gift/auth/tokens/refreshable_user_token.gd Normal file
View File

@ -0,0 +1,10 @@
class_name RefreshableUserAccessToken
extends UserAccessToken
var refresh_token : String
var last_client_secret : String
func _init(data : Dictionary, client_id : String, client_secret : String) -> void:
super._init(data, client_id)
refresh_token = data["refresh_token"]
last_client_secret = client_secret

11
addons/gift/auth/tokens/token.gd Normal file
View File

@ -0,0 +1,11 @@
class_name TwitchToken
extends RefCounted
var last_client_id : String = ""
var token : String
var expires_in : int
var fresh : bool = false
func _init(data : Dictionary, client_id : String, expires_in : int = 0) -> void:
token = data["access_token"]
last_client_id = client_id

8
addons/gift/auth/tokens/user_token.gd Normal file
View File

@ -0,0 +1,8 @@
class_name UserAccessToken
extends TwitchToken
var scopes : PackedStringArray
func _init(data : Dictionary, client_id : String) -> void:
super._init(data, client_id)
scopes = data["scope"]

106
addons/gift/command_handler.gd Normal file
View File

@ -0,0 +1,106 @@
class_name GIFTCommandHandler
extends RefCounted
signal cmd_invalid_argcount(command, sender_data, cmd_data, arg_ary)
signal cmd_no_permission(command, sender_data, cmd_data, arg_ary)
# Required permission to execute the command
enum PermissionFlag {
EVERYONE = 0,
VIP = 1,
SUB = 2,
MOD = 4,
STREAMER = 8,
MOD_STREAMER = 12, # Mods and the streamer
NON_REGULAR = 15 # Everyone but regular viewers
}
# Where the command should be accepted
enum WhereFlag {
CHAT = 1,
WHISPER = 2,
ANYWHERE = 3
}
# Messages starting with one of these symbols are handled as commands. '/' will be ignored, reserved by Twitch.
var command_prefixes : Array[String] = ["!"]
# Dictionary of commands, contains <command key> -> <Callable> entries.
var commands : Dictionary = {}
# Registers a command on an object with a func to call, similar to connect(signal, instance, func).
func add_command(cmd_name : String, callable : Callable, max_args : int = 0, min_args : int = 0, permission_level : int = PermissionFlag.EVERYONE, where : int = WhereFlag.CHAT) -> void:
commands[cmd_name] = CommandData.new(callable, 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)
# Add a command alias. The command specified in 'cmd_name' can now also be executed with the
# command specified in 'alias'.
func add_alias(cmd_name : String, alias : String) -> void:
if(commands.has(cmd_name)):
commands[alias] = commands.get(cmd_name)
# Same as add_alias, but for multiple aliases at once.
func add_aliases(cmd_name : String, aliases : PackedStringArray) -> void:
for alias in aliases:
add_alias(cmd_name, alias)
func handle_command(sender_data : SenderData, msg : String, whisper : bool = false) -> void:
if(command_prefixes.has(msg.left(1))):
msg = msg.right(-1)
var split = msg.split(" ", true, 1)
var command : String = split[0]
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 arg_ary : PackedStringArray = PackedStringArray()
if (split.size() > 1):
arg_ary = split[1].split(" ")
if(arg_ary.size() > cmd_data.max_args && cmd_data.max_args != -1 || arg_ary.size() < cmd_data.min_args):
cmd_invalid_argcount.emit(command, sender_data, cmd_data, arg_ary)
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 == 0):
cmd_no_permission.emit(command, sender_data, cmd_data, arg_ary)
return
if(arg_ary.size() == 0):
cmd_data.func_ref.call(CommandInfo.new(sender_data, command, whisper))
else:
cmd_data.func_ref.call(CommandInfo.new(sender_data, command, whisper), arg_ary)
elif (cmd_data.min_args > 0):
cmd_invalid_argcount.emit(command, sender_data, cmd_data, 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

109
addons/gift/eventsub_connection.gd Normal file
View File

@ -0,0 +1,109 @@
class_name TwitchEventSubConnection
extends RefCounted
const TEN_MINUTES_MS : int = 600000
# The id has been received from the welcome message.
signal session_id_received(id)
signal events_revoked(type, status)
signal event(type, event_data)
enum ConnectionState {
DISCONNECTED,
CONNECTED,
CONNECTION_FAILED,
RECONNECTING
}
var connection_state : ConnectionState = ConnectionState.DISCONNECTED
var eventsub_messages : Dictionary = {}
var eventsub_reconnect_url : String = ""
var session_id : String = ""
var keepalive_timeout : int = 0
var last_keepalive : int = 0
var last_cleanup : int = 0
var websocket : WebSocketPeer
var api : TwitchAPIConnection
func _init(twitch_api_connection : TwitchAPIConnection) -> void:
api = twitch_api_connection
api.id_conn.polled.connect(poll)
func connect_to_eventsub(url : String = "wss://eventsub.wss.twitch.tv/ws") -> void:
if (websocket == null):
websocket = WebSocketPeer.new()
websocket.connect_to_url(url)
print("Connecting to Twitch EventSub")
await(session_id_received)
func poll() -> void:
if (websocket != null):
websocket.poll()
var state := websocket.get_ready_state()
match state:
WebSocketPeer.STATE_OPEN:
if (!connection_state == ConnectionState.CONNECTED):
connection_state = ConnectionState.CONNECTED
print("Connected to EventSub.")
else:
while (websocket.get_available_packet_count()):
process_event(websocket.get_packet())
WebSocketPeer.STATE_CLOSED:
if(connection_state != ConnectionState.CONNECTED):
print("Could not connect to EventSub.")
websocket = null
connection_state = ConnectionState.CONNECTION_FAILED
elif(connection_state == ConnectionState.RECONNECTING):
print("Reconnecting to EventSub")
websocket.close()
connect_to_eventsub(eventsub_reconnect_url)
else:
print("Disconnected from EventSub.")
connection_state = ConnectionState.DISCONNECTED
print("Connection closed! [%s]: %s"%[websocket.get_close_code(), websocket.get_close_reason()])
websocket = null
func process_event(data : PackedByteArray) -> void:
var msg : Dictionary = JSON.parse_string(data.get_string_from_utf8())
if (eventsub_messages.has(msg["metadata"]["message_id"]) || msg["metadata"]["message_timestamp"]):
return
eventsub_messages[msg["metadata"]["message_id"]] = Time.get_ticks_msec()
var payload : Dictionary = msg["payload"]
last_keepalive = Time.get_ticks_msec()
match msg["metadata"]["message_type"]:
"session_welcome":
session_id = payload["session"]["id"]
keepalive_timeout = payload["session"]["keepalive_timeout_seconds"]
session_id_received.emit(session_id)
"session_keepalive":
if (payload.has("session")):
keepalive_timeout = payload["session"]["keepalive_timeout_seconds"]
"session_reconnect":
connection_state = ConnectionState.RECONNECTING
eventsub_reconnect_url = payload["session"]["reconnect_url"]
"revocation":
events_revoked.emit(payload["subscription"]["type"], payload["subscription"]["status"])
"notification":
var event_data : Dictionary = payload["event"]
event.emit(payload["subscription"]["type"], event_data)
# Refer to https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/ for details on
# which API versions are available and which conditions are required.
func subscribe_event(event_name : String, version : int, conditions : Dictionary) -> void:
var data : Dictionary = {}
data["type"] = event_name
data["version"] = str(version)
data["condition"] = conditions
data["transport"] = {
"method":"websocket",
"session_id":session_id
}
var response = await(api.create_eventsub_subscription(data))
if (response.has("error")):
print("Subscription failed for event '%s'. Error %s (%s): %s" % [event_name, response["status"], response["error"], response["message"]])
return
print("Now listening to '%s' events." % event_name)

8
addons/gift/gift.gd
View File

@ -1,8 +0,0 @@
@tool
extends EditorPlugin
func _enter_tree() -> void:
add_custom_type("Gift", "Node", preload("gift_node.gd"), preload("icon.png"))
func _exit_tree() -> void:
remove_custom_type("Gift")

710
addons/gift/gift_node.gd
View File

@ -1,710 +0,0 @@
extends Node
class_name Gift
# The underlying websocket sucessfully connected to Twitch IRC.
signal twitch_connected
# The connection has been closed. Not emitted if Twitch IRC announced a reconnect.
signal twitch_disconnected
# The connection to Twitch IRC failed.
signal twitch_unavailable
# Twitch IRC requested the client to reconnect. (Will be unavailable until next connect)
signal twitch_reconnect
# User token from Twitch has been fetched.
signal user_token_received(token_data)
# User token is valid.
signal user_token_valid
# User token is no longer valid.
signal user_token_invalid
# The client tried to login to Twitch IRC. 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)
# Initial channel data received
signal channel_data_received(channel_name)
# 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 IRC ping is about to be answered with a pong.
signal pong
# The underlying websocket sucessfully connected to Twitch EventSub.
signal events_connected
# The connection to Twitch EventSub failed.
signal events_unavailable
# The underlying websocket disconnected from Twitch EventSub.
signal events_disconnected
# The id has been received from the welcome message.
signal events_id(id)
# Twitch directed the bot to reconnect to a different URL
signal events_reconnect
# Twitch revoked a event subscription
signal events_revoked(event, reason)
# Refer to https://dev.twitch.tv/docs/eventsub/eventsub-reference/ data contained in the data dictionary.
signal event(type, data)
@export_category("IRC")
## Messages starting with one of these symbols are handled as commands. '/' will be ignored, reserved by Twitch.
@export var command_prefixes : Array[String] = ["!"]
## Time to wait in msec after each sent chat message. Values below ~310 might lead to a disconnect after 100 messages.
@export var chat_timeout_ms : int = 320
## Scopes to request for the token. Look at https://dev.twitch.tv/docs/authentication/scopes/ for a list of all available scopes.
@export var scopes : Array[String] = ["chat:edit", "chat:read"]
@export_category("Emotes/Badges")
## 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 var disk_cache : bool = false
## Disk Cache has to be enbaled for this to work
@export_file var disk_cache_path : String = "user://gift/cache"
var client_id : String = ""
var client_secret : String = ""
var username : String = ""
var user_id : String = ""
var token : Dictionary = {}
# Twitch disconnects connected clients if too many chat messages are being sent. (At about 100 messages/30s).
# This queue makes sure messages aren't sent too quickly.
var chat_queue : Array[String] = []
var last_msg : int = Time.get_ticks_msec()
# Mapping of channels to their channel info, like available badges.
var channels : Dictionary = {}
# Last Userstate of the bot for channels. Contains <channel_name> -> <userstate_dictionary> entries.
var last_state : Dictionary = {}
# Dictionary of commands, contains <command key> -> <Callable> entries.
var commands : Dictionary = {}
var eventsub : WebSocketPeer
var eventsub_messages : Dictionary = {}
var eventsub_connected : bool = false
var eventsub_restarting : bool = false
var eventsub_reconnect_url : String = ""
var session_id : String = ""
var keepalive_timeout : int = 0
var last_keepalive : int = 0
var websocket : WebSocketPeer
var server : TCPServer = TCPServer.new()
var peer : StreamPeerTCP
var connected : bool = false
var user_regex : RegEx = RegEx.new()
var twitch_restarting : bool = false
const USER_AGENT : String = "User-Agent: GIFT/4.1.5 (Godot Engine)"
enum RequestType {
EMOTE,
BADGE,
BADGE_MAPPING
}
var caches := {
RequestType.EMOTE: {},
RequestType.BADGE: {},
RequestType.BADGE_MAPPING: {}
}
# 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():
user_regex.compile("(?<=!)[\\w]*(?=@)")
if (disk_cache):
for key in RequestType.keys():
if (!DirAccess.dir_exists_absolute(disk_cache_path + "/" + key)):
DirAccess.make_dir_recursive_absolute(disk_cache_path + "/" + key)
# Authenticate to authorize GIFT to use your account to process events and messages.
func authenticate(client_id, client_secret) -> void:
self.client_id = client_id
self.client_secret = client_secret
print("Checking token...")
if (FileAccess.file_exists("user://gift/auth/user_token")):
var file : FileAccess = FileAccess.open_encrypted_with_pass("user://gift/auth/user_token", FileAccess.READ, client_secret)
token = JSON.parse_string(file.get_as_text())
if (token.has("scope") && scopes.size() != 0):
if (scopes.size() != token["scope"].size()):
get_token()
token = await(user_token_received)
else:
for scope in scopes:
if (!token["scope"].has(scope)):
get_token()
token = await(user_token_received)
else:
get_token()
token = await(user_token_received)
username = await(is_token_valid(token["access_token"]))
while (username == ""):
print("Token invalid.")
var refresh : String = token.get("refresh_token", "")
if (refresh != ""):
refresh_access_token(refresh)
else:
get_token()
token = await(user_token_received)
username = await(is_token_valid(token["access_token"]))
print("Token verified.")
user_token_valid.emit()
refresh_token()
func refresh_access_token(refresh : String) -> void:
print("Refreshing access token.")
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://id.twitch.tv/oauth2/token", [USER_AGENT, "Content-Type: application/x-www-form-urlencoded"], HTTPClient.METHOD_POST, "grant_type=refresh_token&refresh_token=%s&client_id=%s&client_secret=%s" % [refresh.uri_encode(), client_id, client_secret])
var reply : Array = await(request.request_completed)
request.queue_free()
var response : Dictionary = JSON.parse_string(reply[3].get_string_from_utf8())
if (response.has("error")):
print("Refresh failed, requesting new token.")
get_token()
else:
token = response
var file : FileAccess = FileAccess.open_encrypted_with_pass("user://gift/auth/user_token", FileAccess.WRITE, client_secret)
file.store_string(reply[3].get_string_from_utf8())
user_token_received.emit(response)
# Gets a new auth token from Twitch.
func get_token() -> void:
print("Fetching new token.")
var scope = ""
for i in scopes.size() - 1:
scope += scopes[i]
scope += " "
if (scopes.size() > 0):
scope += scopes[scopes.size() - 1]
scope = scope.uri_encode()
OS.shell_open("https://id.twitch.tv/oauth2/authorize?response_type=code&client_id=" + client_id +"&redirect_uri=http://localhost:18297&scope=" + scope)
server.listen(18297)
print("Waiting for user to login.")
while(!peer):
peer = server.take_connection()
OS.delay_msec(100)
while(peer.get_status() == peer.STATUS_CONNECTED):
peer.poll()
if (peer.get_available_bytes() > 0):
var response = peer.get_utf8_string(peer.get_available_bytes())
if (response == ""):
print("Empty response. Check if your redirect URL is set to http://localhost:18297.")
return
var start : int = response.find("?")
response = response.substr(start + 1, response.find(" ", start) - start)
var data : Dictionary = {}
for entry in response.split("&"):
var pair = entry.split("=")
data[pair[0]] = pair[1] if pair.size() > 0 else ""
if (data.has("error")):
var msg = "Error %s: %s" % [data["error"], data["error_description"]]
print(msg)
send_response(peer, "400 BAD REQUEST", msg.to_utf8_buffer())
peer.disconnect_from_host()
break
else:
print("Success.")
send_response(peer, "200 OK", "Success!".to_utf8_buffer())
peer.disconnect_from_host()
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://id.twitch.tv/oauth2/token", [USER_AGENT, "Content-Type: application/x-www-form-urlencoded"], HTTPClient.METHOD_POST, "client_id=" + client_id + "&client_secret=" + client_secret + "&code=" + data["code"] + "&grant_type=authorization_code&redirect_uri=http://localhost:18297")
var answer = await(request.request_completed)
if (!DirAccess.dir_exists_absolute("user://gift/auth")):
DirAccess.make_dir_recursive_absolute("user://gift/auth")
var file : FileAccess = FileAccess.open_encrypted_with_pass("user://gift/auth/user_token", FileAccess.WRITE, client_secret)
var token_data = answer[3].get_string_from_utf8()
file.store_string(token_data)
request.queue_free()
user_token_received.emit(JSON.parse_string(token_data))
break
OS.delay_msec(100)
func send_response(peer : StreamPeer, response : String, body : PackedByteArray) -> void:
peer.put_data(("HTTP/1.1 %s\r\n" % response).to_utf8_buffer())
peer.put_data("Server: GIFT (Godot Engine)\r\n".to_utf8_buffer())
peer.put_data(("Content-Length: %d\r\n"% body.size()).to_utf8_buffer())
peer.put_data("Connection: close\r\n".to_utf8_buffer())
peer.put_data("Content-Type: text/plain; charset=UTF-8\r\n".to_utf8_buffer())
peer.put_data("\r\n".to_utf8_buffer())
peer.put_data(body)
# If the token is valid, returns the username of the token bearer. Returns an empty String if the token was invalid.
func is_token_valid(token : String) -> String:
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://id.twitch.tv/oauth2/validate", [USER_AGENT, "Authorization: OAuth " + token])
var data = await(request.request_completed)
request.queue_free()
if (data[1] == 200):
var payload : Dictionary = JSON.parse_string(data[3].get_string_from_utf8())
user_id = payload["user_id"]
return payload["login"]
return ""
func refresh_token() -> void:
await(get_tree().create_timer(3600).timeout)
if (await(is_token_valid(token["access_token"])) == ""):
user_token_invalid.emit()
return
else:
refresh_token()
var to_remove : Array[String] = []
for entry in eventsub_messages.keys():
if (Time.get_ticks_msec() - eventsub_messages[entry] > 600000):
to_remove.append(entry)
for n in to_remove:
eventsub_messages.erase(n)
func _process(delta : float) -> void:
if (websocket):
websocket.poll()
var state := websocket.get_ready_state()
match state:
WebSocketPeer.STATE_OPEN:
if (!connected):
twitch_connected.emit()
connected = true
print_debug("Connected to Twitch.")
else:
while (websocket.get_available_packet_count()):
data_received(websocket.get_packet())
if (!chat_queue.is_empty() && (last_msg + chat_timeout_ms) <= Time.get_ticks_msec()):
send(chat_queue.pop_front())
last_msg = Time.get_ticks_msec()
WebSocketPeer.STATE_CLOSED:
if (!connected):
twitch_unavailable.emit()
print_debug("Could not connect to Twitch.")
websocket = null
elif(twitch_restarting):
print_debug("Reconnecting to Twitch...")
twitch_reconnect.emit()
connect_to_irc()
await(twitch_connected)
for channel in channels.keys():
join_channel(channel)
twitch_restarting = false
else:
print_debug("Disconnected from Twitch.")
twitch_disconnected.emit()
connected = false
print_debug("Connection closed! [%s]: %s"%[websocket.get_close_code(), websocket.get_close_reason()])
if (eventsub):
eventsub.poll()
var state := eventsub.get_ready_state()
match state:
WebSocketPeer.STATE_OPEN:
if (!eventsub_connected):
events_connected.emit()
eventsub_connected = true
print_debug("Connected to EventSub.")
else:
while (eventsub.get_available_packet_count()):
process_event(eventsub.get_packet())
WebSocketPeer.STATE_CLOSED:
if(!eventsub_connected):
print_debug("Could not connect to EventSub.")
events_unavailable.emit()
eventsub = null
elif(eventsub_restarting):
print_debug("Reconnecting to EventSub")
eventsub.close()
connect_to_eventsub(eventsub_reconnect_url)
await(eventsub_connected)
eventsub_restarting = false
else:
print_debug("Disconnected from EventSub.")
events_disconnected.emit()
eventsub_connected = false
print_debug("Connection closed! [%s]: %s"%[websocket.get_close_code(), websocket.get_close_reason()])
func process_event(data : PackedByteArray) -> void:
var msg : Dictionary = JSON.parse_string(data.get_string_from_utf8())
if (eventsub_messages.has(msg["metadata"]["message_id"])):
return
eventsub_messages[msg["metadata"]["message_id"]] = Time.get_ticks_msec()
var payload : Dictionary = msg["payload"]
last_keepalive = Time.get_ticks_msec()
match msg["metadata"]["message_type"]:
"session_welcome":
session_id = payload["session"]["id"]
keepalive_timeout = payload["session"]["keepalive_timeout_seconds"]
events_id.emit(session_id)
"session_keepalive":
if (payload.has("session")):
keepalive_timeout = payload["session"]["keepalive_timeout_seconds"]
"session_reconnect":
eventsub_restarting = true
eventsub_reconnect_url = payload["session"]["reconnect_url"]
events_reconnect.emit()
"revocation":
events_revoked.emit(payload["subscription"]["type"], payload["subscription"]["status"])
"notification":
var event_data : Dictionary = payload["event"]
event.emit(payload["subscription"]["type"], event_data)
# Connect to Twitch IRC. Make sure to authenticate first.
func connect_to_irc() -> bool:
websocket = WebSocketPeer.new()
websocket.connect_to_url("wss://irc-ws.chat.twitch.tv:443")
print("Connecting to Twitch IRC.")
await(twitch_connected)
send("PASS oauth:%s" % [token["access_token"]], true)
send("NICK " + username.to_lower())
var success = await(login_attempt)
if (success):
connected = true
return success
# Connect to Twitch EventSub. Make sure to authenticate first.
func connect_to_eventsub(url : String = "wss://eventsub.wss.twitch.tv/ws") -> void:
eventsub = WebSocketPeer.new()
eventsub.connect_to_url(url)
print("Connecting to Twitch EventSub.")
await(events_id)
events_connected.emit()
# Refer to https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/ for details on
# which API versions are available and which conditions are required.
func subscribe_event(event_name : String, version : int, conditions : Dictionary) -> void:
var data : Dictionary = {}
data["type"] = event_name
data["version"] = str(version)
data["condition"] = conditions
data["transport"] = {
"method":"websocket",
"session_id":session_id
}
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://api.twitch.tv/helix/eventsub/subscriptions", [USER_AGENT, "Authorization: Bearer " + token["access_token"], "Client-Id:" + client_id, "Content-Type: application/json"], HTTPClient.METHOD_POST, JSON.stringify(data))
var reply : Array = await(request.request_completed)
request.queue_free()
var response : Dictionary = JSON.parse_string(reply[3].get_string_from_utf8())
if (response.has("error")):
print("Subscription failed for event '%s'. Error %s (%s): %s" % [event_name, response["status"], response["error"], response["message"]])
return
print("Now listening to '%s' events." % event_name)
# Request capabilities from twitch.
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.send_text(text)
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 != ""):
if (channel.begins_with("#")):
channel = channel.right(-1)
chat_queue.append("PRIVMSG #" + channel + " :" + message + "\r\n")
chat_message.emit(SenderData.new(last_state[channels.keys()[0]]["display-name"], channel, last_state[channels.keys()[0]]), message)
elif(keys.size() == 1):
chat_queue.append("PRIVMSG #" + channels.keys()[0] + " :" + message + "\r\n")
chat_message.emit(SenderData.new(last_state[channels.keys()[0]]["display-name"], channels.keys()[0], last_state[channels.keys()[0]]), message)
else:
print_debug("No channel specified.")
# Send a whisper message to a user by username. Returns a empty dictionary on success. If it failed, "status" will be present in the Dictionary.
func whisper(message : String, target : String) -> Dictionary:
var user_data : Dictionary = await(user_data_by_name(target))
if (user_data.has("status")):
return user_data
var response : int = await(whisper_by_uid(message, user_data["id"]))
if (response != HTTPClient.RESPONSE_NO_CONTENT):
return {"status": response}
return {}
# Send a whisper message to a user by UID. Returns the response code.
func whisper_by_uid(message : String, target_id : String) -> int:
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://api.twitch.tv/helix/whispers", [USER_AGENT, "Authorization: Bearer " + token["access_token"], "Client-Id:" + client_id, "Content-Type: application/json"], HTTPClient.METHOD_POST, JSON.stringify({"from_user_id": user_id, "to_user_id": target_id, "message": message}))
var reply : Array = await(request.request_completed)
request.queue_free()
if (reply[1] != HTTPClient.RESPONSE_NO_CONTENT):
print("Error sending the whisper: " + reply[3].get_string_from_utf8())
return reply[0]
# Returns the response as Dictionary. If it failed, "error" will be present in the Dictionary.
func user_data_by_name(username : String) -> Dictionary:
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://api.twitch.tv/helix/users?login=" + username, [USER_AGENT, "Authorization: Bearer " + token["access_token"], "Client-Id:" + client_id, "Content-Type: application/json"], HTTPClient.METHOD_GET)
var reply : Array = await(request.request_completed)
var response : Dictionary = JSON.parse_string(reply[3].get_string_from_utf8())
request.queue_free()
if (response.has("error")):
print("Error fetching user data: " + reply[3].get_string_from_utf8())
return response
else:
return response["data"][0]
func get_emote(emote_id : String, scale : String = "1.0") -> Texture2D:
var texture : Texture2D
var cachename : String = emote_id + "_" + scale
var filename : String = disk_cache_path + "/" + RequestType.keys()[RequestType.EMOTE] + "/" + cachename + ".png"
if !caches[RequestType.EMOTE].has(cachename):
if (disk_cache && FileAccess.file_exists(filename)):
texture = ImageTexture.new()
var img : Image = Image.new()
img.load_png_from_buffer(FileAccess.get_file_as_bytes(filename))
texture.create_from_image(img)
else:
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://static-cdn.jtvnw.net/emoticons/v1/" + emote_id + "/" + scale, [USER_AGENT,"Accept: */*"])
var data = await(request.request_completed)
request.queue_free()
var img : Image = Image.new()
img.load_png_from_buffer(data[3])
texture = ImageTexture.create_from_image(img)
texture.take_over_path(filename)
if (disk_cache):
DirAccess.make_dir_recursive_absolute(filename.get_base_dir())
texture.get_image().save_png(filename)
caches[RequestType.EMOTE][cachename] = texture
return caches[RequestType.EMOTE][cachename]
func get_badge(badge_name : String, channel_id : String = "_global", scale : String = "1") -> Texture2D:
var badge_data : PackedStringArray = badge_name.split("/", true, 1)
var texture : Texture2D
var cachename = badge_data[0] + "_" + badge_data[1] + "_" + scale
var filename : String = disk_cache_path + "/" + RequestType.keys()[RequestType.BADGE] + "/" + channel_id + "/" + cachename + ".png"
if (!caches[RequestType.BADGE].has(channel_id)):
caches[RequestType.BADGE][channel_id] = {}
if (!caches[RequestType.BADGE][channel_id].has(cachename)):
if (disk_cache && FileAccess.file_exists(filename)):
var img : Image = Image.new()
img.load_png_from_buffer(FileAccess.get_file_as_bytes(filename))
texture = ImageTexture.create_from_image(img)
texture.take_over_path(filename)
else:
var map : Dictionary = caches[RequestType.BADGE_MAPPING].get(channel_id, await(get_badge_mapping(channel_id)))
if (!map.is_empty()):
if(map.has(badge_data[0])):
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request(map[badge_data[0]]["versions"][badge_data[1]]["image_url_" + scale + "x"], [USER_AGENT,"Accept: */*"])
var data = await(request.request_completed)
var img : Image = Image.new()
img.load_png_from_buffer(data[3])
texture = ImageTexture.create_from_image(img)
texture.take_over_path(filename)
request.queue_free()
elif channel_id != "_global":
return await(get_badge(badge_name, "_global", scale))
elif (channel_id != "_global"):
return await(get_badge(badge_name, "_global", scale))
if (disk_cache):
DirAccess.make_dir_recursive_absolute(filename.get_base_dir())
texture.get_image().save_png(filename)
texture.take_over_path(filename)
caches[RequestType.BADGE][channel_id][cachename] = texture
return caches[RequestType.BADGE][channel_id][cachename]
func get_badge_mapping(channel_id : String = "_global") -> Dictionary:
if caches[RequestType.BADGE_MAPPING].has(channel_id):
return caches[RequestType.BADGE_MAPPING][channel_id]
var filename : String = disk_cache_path + "/" + RequestType.keys()[RequestType.BADGE_MAPPING] + "/" + channel_id + ".json"
if (disk_cache && FileAccess.file_exists(filename)):
var cache = JSON.parse_string(FileAccess.get_file_as_string(filename))
if "badge_sets" in cache:
return cache["badge_sets"]
var request : HTTPRequest = HTTPRequest.new()
add_child(request)
request.request("https://api.twitch.tv/helix/chat/badges" + ("/global" if channel_id == "_global" else "?broadcaster_id=" + channel_id), [USER_AGENT, "Authorization: Bearer " + token["access_token"], "Client-Id:" + client_id, "Content-Type: application/json"], HTTPClient.METHOD_GET)
var reply : Array = await(request.request_completed)
var response : Dictionary = JSON.parse_string(reply[3].get_string_from_utf8())
var mappings : Dictionary = {}
for entry in response["data"]:
if (!mappings.has(entry["set_id"])):
mappings[entry["set_id"]] = {"versions": {}}
for version in entry["versions"]:
mappings[entry["set_id"]]["versions"][version["id"]] = version
request.queue_free()
if (reply[1] == HTTPClient.RESPONSE_OK):
caches[RequestType.BADGE_MAPPING][channel_id] = mappings
if (disk_cache):
DirAccess.make_dir_recursive_absolute(filename.get_base_dir())
var file : FileAccess = FileAccess.open(filename, FileAccess.WRITE)
file.store_string(JSON.stringify(mappings))
else:
print("Could not retrieve badge mapping for channel_id " + channel_id + ".")
return {}
return caches[RequestType.BADGE_MAPPING][channel_id]
func data_received(data : PackedByteArray) -> void:
var messages : PackedStringArray = data.get_string_from_utf8().strip_edges(false).split("\r\n")
var tags = {}
for message in messages:
if(message.begins_with("@")):
var msg : PackedStringArray = 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, callable : Callable, max_args : int = 0, min_args : int = 0, permission_level : int = PermissionFlag.EVERYONE, where : int = WhereFlag.CHAT) -> void:
commands[cmd_name] = CommandData.new(callable, 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 : PackedStringArray) -> void:
for alias in aliases:
add_alias(cmd_name, alias)
func handle_message(message : String, tags : Dictionary) -> void:
if(message == "PING :tmi.twitch.tv"):
send("PONG :tmi.twitch.tv")
pong.emit()
return
var msg : PackedStringArray = message.split(" ", true, 3)
match msg[1]:
"NOTICE":
var info : String = msg[3].right(-1)
if (info == "Login authentication failed" || info == "Login unsuccessful"):
print_debug("Authentication failed.")
login_attempt.emit(false)
elif (info == "You don't have permission to perform that action"):
print_debug("No permission. Check if access token is still valid. Aborting.")
user_token_invalid.emit()
set_process(false)
else:
unhandled_message.emit(message, tags)
"001":
print_debug("Authentication successful.")
login_attempt.emit(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))
chat_message.emit(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)
whisper_message.emit(sender_data, msg[3].right(-1))
"RECONNECT":
twitch_restarting = true
"USERSTATE", "ROOMSTATE":
var room = msg[2].right(-1)
if (!last_state.has(room)):
last_state[room] = tags
channel_data_received.emit(room)
else:
for key in tags:
last_state[room][key] = tags[key]
_:
unhandled_message.emit(message, tags)
func handle_command(sender_data : SenderData, msg : PackedStringArray, 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 : PackedStringArray = PackedStringArray() 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):
cmd_invalid_argcount.emit(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 == 0):
cmd_no_permission.emit(command, sender_data, cmd_data, arg_ary)
print_debug("No Permission for command!")
return
if(arg_ary.size() == 0):
cmd_data.func_ref.call(CommandInfo.new(sender_data, command, whisper))
else:
cmd_data.func_ref.call(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()
channels[lower_channel] = {}
send("JOIN #" + lower_channel)
func leave_channel(channel : String) -> void:
var lower_channel : String = channel.to_lower()
send("PART #" + lower_channel)
channels.erase(lower_channel)

82
addons/gift/icon_downloader.gd Normal file
View File

@ -0,0 +1,82 @@
class_name TwitchIconDownloader
extends RefCounted
signal fetched(texture)
var api : TwitchAPIConnection
const JTVNW_URL : String = "https://static-cdn.jtvnw.net"
var jtvnw_client : HTTPClient = HTTPClient.new()
var jtvnw_response : PackedByteArray = []
var jtvnw_queue : Array[String] = []
var cached_badges : Dictionary = {}
var disk_cache : bool
func _init(twitch_api : TwitchAPIConnection, disk_cache_enabled : bool = false) -> void:
api = twitch_api
api.id_conn.polled.connect(poll)
disk_cache = disk_cache_enabled
jtvnw_client.connect_to_host(JTVNW_URL)
func poll() -> void:
jtvnw_client.poll()
if (jtvnw_client.get_status() == HTTPClient.STATUS_BODY):
jtvnw_response += jtvnw_client.read_response_body_chunk()
elif (!jtvnw_response.is_empty()):
var img := Image.new()
img.load_png_from_buffer(jtvnw_response)
jtvnw_response.clear()
var path = jtvnw_queue.pop_front()
var texture : ImageTexture = ImageTexture.new()
texture.set_image(img)
texture.take_over_path(path)
fetched.emit(texture)
elif (jtvnw_client.get_status() == HTTPClient.STATUS_CONNECTED && !jtvnw_queue.is_empty()):
jtvnw_client.request(HTTPClient.METHOD_GET, jtvnw_queue.front(), ["Accept: image/png"])
func get_badge(badge_id : String, channel_id : String = "_global", scale : String = "1x") -> Texture2D:
var badge_data : PackedStringArray = badge_id.split("/", true, 1)
if (!cached_badges.has(channel_id)):
if (channel_id == "_global"):
cache_badges(await(api.get_global_chat_badges()), channel_id)
else:
cache_badges(await(api.get_channel_chat_badges(channel_id)), channel_id)
if (channel_id != "_global" && !cached_badges[channel_id].has(badge_data[0])):
return await(get_badge(badge_id, "_global", scale))
var path : String = cached_badges[channel_id][badge_data[0]]["versions"][badge_data[1]]["image_url_%s" % scale].substr(JTVNW_URL.length())
if ResourceLoader.has_cached(path):
return load(path)
else:
jtvnw_queue.append(path)
var filepath : String = "user://badges/%s/%s_%s_%s.png" % [channel_id, badge_data[0], badge_data[1], scale]
return await(wait_for_fetched(path, filepath))
func get_emote(emote_id : String, dark : bool = true, scale : String = "1.0") -> Texture2D:
var path : String = "/emoticons/v2/%s/static/%s/%s" % [emote_id, "dark" if dark else "light", scale]
if ResourceLoader.has_cached(path):
return load(path)
else:
var filepath : String = "user://emotes/%s.png" % emote_id
jtvnw_queue.append(path)
return await(wait_for_fetched(path, filepath))
func cache_badges(result, channel_id) -> void:
cached_badges[channel_id] = result
var mappings : Dictionary = {}
var badges : Array = cached_badges[channel_id]["data"]
for entry in badges:
if (!mappings.has(entry["set_id"])):
mappings[entry["set_id"]] = {"versions" : {}}
for version in entry["versions"]:
mappings[entry["set_id"]]["versions"][version["id"]] = version
cached_badges[channel_id] = mappings
func wait_for_fetched(path : String, filepath : String) -> ImageTexture:
var last_fetched : ImageTexture = null
while (last_fetched == null || last_fetched.resource_path != path):
last_fetched = await(fetched)
last_fetched.take_over_path(filepath)
return load(filepath)

66
addons/gift/id_connection.gd Normal file
View File

@ -0,0 +1,66 @@
class_name TwitchIDConnection
extends RefCounted
signal polled
signal token_invalid
signal token_refreshed(success)
const ONE_HOUR_MS = 3600000
var last_token : TwitchToken
var id_client : HTTPClient = HTTPClient.new()
var id_client_response : PackedByteArray = []
var next_check : int = 0
func _init(token : TwitchToken) -> void:
last_token = token
if (last_token.fresh):
next_check += ONE_HOUR_MS
id_client.connect_to_host("https://id.twitch.tv", -1, TLSOptions.client())
func poll() -> void:
if (id_client != null):
id_client.poll()
if (id_client.get_status() == HTTPClient.STATUS_CONNECTED):
if (!id_client_response.is_empty()):
var response = JSON.parse_string(id_client_response.get_string_from_utf8())
if (response.has("status") && (response["status"] == 401 || response["status"] == 400)):
print("Token is invalid. Aborting.")
token_invalid.emit()
token_refreshed.emit(false)
else:
last_token.token = response.get("access_token", last_token.token)
last_token.expires_in = response.get("expires_in", last_token.expires_in)
if last_token is RefreshableUserAccessToken:
last_token.refresh_token = response.get("refresh_token", last_token.refresh_token)
token_refreshed.emit(true)
if last_token is AppAccessToken:
token_refreshed.emit(true)
id_client_response.clear()
if (next_check <= Time.get_ticks_msec()):
check_token()
next_check += ONE_HOUR_MS
elif (id_client.get_status() == HTTPClient.STATUS_BODY):
id_client_response += id_client.read_response_body_chunk()
polled.emit()
func check_token() -> void:
id_client.request(HTTPClient.METHOD_GET, "/oauth2/validate", ["Authorization: OAuth %s" % last_token.token])
print("Validating token...")
func refresh_token() -> void:
if (last_token is RefreshableUserAccessToken):
id_client.request(HTTPClient.METHOD_GET, "/oauth2/token", ["Content-Type: application/x-www-form-urlencoded"], "grant_type=refresh_token&refresh_token=%s&client_id=%s&client_secret=%s" % [last_token.refresh_token, last_token.last_client_id, last_token.last_client_secret])
elif (last_token is UserAccessToken):
var auth : ImplicitGrantFlow = ImplicitGrantFlow.new()
polled.connect(auth.poll)
var last_token = await(auth.login(last_token.last_client_id, last_token.scopes))
token_refreshed.emit(true)
else:
id_client.request(HTTPClient.METHOD_POST, "/oauth2/token", ["Content-Type: application/x-www-form-urlencoded"], "client_id=%s&client_secret=%s&grant_type=client_credentials" % [last_token.client_id, last_token.client_secret])
if (last_token == null):
print("Please check if you have all required scopes.")
token_refreshed.emit(false)

192
addons/gift/irc_connection.gd Normal file
View File

@ -0,0 +1,192 @@
class_name TwitchIRCConnection
extends RefCounted
signal connection_state_changed(state)
signal chat_message(sender_data, message)
signal whisper_message(sender_data, message)
signal channel_data_received(room)
signal login_attempt(success)
signal unhandled_message(message, tags)
enum ConnectionState {
DISCONNECTED,
CONNECTED,
CONNECTION_FAILED,
RECONNECTING
}
var connection_state : ConnectionState = ConnectionState.DISCONNECTED:
set(new_state):
connection_state = new_state
connection_state_changed.emit(new_state)
var websocket : WebSocketPeer
# Timestamp of the last message sent.
var last_msg : int = Time.get_ticks_msec()
# Time to wait in msec after each sent chat message. Values below ~310 might lead to a disconnect after 100 messages.
var chat_timeout_ms : int = 320
# Twitch disconnects connected clients if too many chat messages are being sent. (At about 100 messages/30s).
# This queue makes sure messages aren't sent too quickly.
var chat_queue : Array[String] = []
# Mapping of channels to their channel info, like available badges.
var channels : Dictionary = {}
# Last Userstate of the bot for channels. Contains <channel_name> -> <userstate_dictionary> entries.
var last_state : Dictionary = {}
var user_regex : RegEx = RegEx.create_from_string("(?<=!)[\\w]*(?=@)")
var id : TwitchIDConnection
var last_username : String
var last_token : UserAccessToken
var last_caps : PackedStringArray
func _init(twitch_id_connection : TwitchIDConnection) -> void:
id = twitch_id_connection
id.polled.connect(poll)
# Connect to Twitch IRC. Returns true on success, false if connection fails.
func connect_to_irc(username : String) -> bool:
last_username = username
websocket = WebSocketPeer.new()
websocket.connect_to_url("wss://irc-ws.chat.twitch.tv:443")
print("Connecting to Twitch IRC.")
if (await(connection_state_changed) != ConnectionState.CONNECTED):
return false
send("PASS oauth:%s" % id.last_token.token, true)
send("NICK " + username.to_lower())
if (await(login_attempt)):
print("Connected.")
return true
return false
func poll() -> void:
if (websocket != null && connection_state != ConnectionState.CONNECTION_FAILED && connection_state != ConnectionState.RECONNECTING):
websocket.poll()
var state := websocket.get_ready_state()
match state:
WebSocketPeer.STATE_OPEN:
if (connection_state == ConnectionState.DISCONNECTED):
connection_state = ConnectionState.CONNECTED
print("Connected to Twitch.")
else:
while (websocket.get_available_packet_count()):
data_received(websocket.get_packet())
if (!chat_queue.is_empty() && (last_msg + chat_timeout_ms) <= Time.get_ticks_msec()):
send(chat_queue.pop_front())
last_msg = Time.get_ticks_msec()
WebSocketPeer.STATE_CLOSED:
if (connection_state == ConnectionState.DISCONNECTED):
print("Could not connect to Twitch.")
connection_state = ConnectionState.CONNECTION_FAILED
elif(connection_state == ConnectionState.RECONNECTING):
print("Reconnecting to Twitch...")
await(reconnect())
else:
connection_state = ConnectionState.DISCONNECTED
print("Disconnected from Twitch. [%s]: %s"%[websocket.get_close_code(), websocket.get_close_reason()])
func data_received(data : PackedByteArray) -> void:
var messages : PackedStringArray = data.get_string_from_utf8().strip_edges(false).split("\r\n")
var tags = {}
for message in messages:
if(message.begins_with("@")):
var msg : PackedStringArray = 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)
# Sends a String to Twitch.
func send(text : String, token : bool = false) -> void:
websocket.send_text(text)
if(OS.is_debug_build()):
if(!token):
print("< " + text.strip_edges(false))
else:
print("< PASS oauth:******************************")
# Request capabilities from twitch.
func request_capabilities(caps : PackedStringArray = ["twitch.tv/commands", "twitch.tv/tags"]) -> void:
last_caps = caps
send("CAP REQ :" + " ".join(caps))
# 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 != ""):
if (channel.begins_with("#")):
channel = channel.right(-1)
chat_queue.append("PRIVMSG #" + channel + " :" + message + "\r\n")
if (last_state.has(channel)):
chat_message.emit(SenderData.new(last_state[channel]["display-name"], channel, last_state[channels.keys()[0]]), message)
elif(keys.size() == 1):
chat_queue.append("PRIVMSG #" + channels.keys()[0] + " :" + message + "\r\n")
if (last_state.has(channels.keys()[0])):
chat_message.emit(SenderData.new(last_state[channels.keys()[0]]["display-name"], channels.keys()[0], last_state[channels.keys()[0]]), message)
else:
print("No channel specified.")
func handle_message(message : String, tags : Dictionary) -> void:
if(message == "PING :tmi.twitch.tv"):
send("PONG :tmi.twitch.tv")
return
var msg : PackedStringArray = message.split(" ", true, 3)
match msg[1]:
"NOTICE":
var info : String = msg[3].right(-1)
if (info == "Login authentication failed" || info == "Login unsuccessful"):
print("Authentication failed.")
login_attempt.emit(false)
elif (info == "You don't have permission to perform that action"):
print("No permission. Attempting to obtain new token.")
id.refresh_token()
var success : bool = await(id.token_refreshed)
if (!success):
print("Please check if you have all required scopes.")
websocket.close(1000, "Token became invalid.")
return
connection_state = ConnectionState.RECONNECTING
else:
unhandled_message.emit(message, tags)
"001":
print("Authentication successful.")
login_attempt.emit(true)
"PRIVMSG":
var sender_data : SenderData = SenderData.new(user_regex.search(msg[0]).get_string(), msg[2], tags)
chat_message.emit(sender_data, msg[3].right(-1))
"WHISPER":
var sender_data : SenderData = SenderData.new(user_regex.search(msg[0]).get_string(), msg[2], tags)
whisper_message.emit(sender_data, msg[3].right(-1))
"RECONNECT":
connection_state = ConnectionState.RECONNECTING
"USERSTATE", "ROOMSTATE":
var room = msg[2].right(-1)
if (!last_state.has(room)):
last_state[room] = tags
channel_data_received.emit(room)
else:
for key in tags:
last_state[room][key] = tags[key]
_:
unhandled_message.emit(message, tags)
func join_channel(channel : String) -> void:
var lower_channel : String = channel.to_lower()
channels[lower_channel] = {}
send("JOIN #" + lower_channel)
func leave_channel(channel : String) -> void:
var lower_channel : String = channel.to_lower()
send("PART #" + lower_channel)
channels.erase(lower_channel)
func reconnect() -> void:
if(await(connect_to_irc(last_username))):
request_capabilities(last_caps)
for channel in channels.keys():
join_channel(channel)
connection_state = ConnectionState.CONNECTED

7
addons/gift/plugin.cfg
View File

@ -1,7 +0,0 @@
[plugin]
name="Godot IRC For Twitch"
description="Godot websocket implementation for Twitch IRC."
author="issork"
version="4.1.5"
script="gift.gd"

3
addons/gift/util/cmd_data.gd
View File

@ -1,5 +1,5 @@
extends RefCounted
class_name CommandData
extends RefCounted
var func_ref : Callable
var permission_level : int
@ -13,4 +13,3 @@ func _init(f_ref : Callable, perm_lvl : int, mx_args : int, mn_args : int, whr :
max_args = mx_args
min_args = mn_args
where = whr

5
addons/gift/util/cmd_info.gd
View File

@ -1,12 +1,11 @@
extends RefCounted
class_name CommandInfo
extends RefCounted
var sender_data : SenderData
var command : String
var whisper : bool
func _init(sndr_dt, cmd, whspr):
func _init(sndr_dt : SenderData, cmd : String, whspr : bool):
sender_data = sndr_dt
command = cmd
whisper = whspr

2
addons/gift/util/sender_data.gd
View File

@ -1,5 +1,5 @@
extends RefCounted
class_name SenderData
extends RefCounted
var user : String
var channel : String

7
example/Button.gd
View File

@ -1,7 +0,0 @@
extends Button
func _pressed():
%Gift.chat(%LineEdit.text)
var channel : String = %Gift.channels.keys()[0]
%Gift.handle_command(SenderData.new(%Gift.username, channel, %Gift.last_state[channel]), (":" + %LineEdit.text).split(" ", true, 1))
%LineEdit.text = ""

42
example/ChatContainer.gd
View File

@ -1,42 +0,0 @@
extends VBoxContainer
func put_chat(senderdata : SenderData, msg : String):
var msgnode : Control = preload("res://example/ChatMessage.tscn").instantiate()
var time = Time.get_time_dict_from_system()
var badges : String = ""
for badge in senderdata.tags["badges"].split(",", false):
var result = await(%Gift.get_badge(badge, senderdata.tags["room-id"]))
badges += "[img=center]" + result.resource_path + "[/img] "
var locations : Array = []
if (senderdata.tags.has("emotes")):
for emote in senderdata.tags["emotes"].split("/", false):
var data : Array = emote.split(":")
for d in data[1].split(","):
var start_end = d.split("-")
locations.append(EmoteLocation.new(data[0], int(start_end[0]), int(start_end[1])))
locations.sort_custom(Callable(EmoteLocation, "smaller"))
var offset = 0
for loc in locations:
var result = await(%Gift.get_emote(loc.id))
var emote_string = "[img=center]" + result.resource_path +"[/img]"
msg = msg.substr(0, loc.start + offset) + emote_string + msg.substr(loc.end + offset + 1)
offset += emote_string.length() + loc.start - loc.end - 1
var bottom : bool = $Chat/ScrollContainer.scroll_vertical == $Chat/ScrollContainer.get_v_scroll_bar().max_value - $Chat/ScrollContainer.get_v_scroll_bar().get_rect().size.y
msgnode.set_msg("%02d:%02d" % [time["hour"], time["minute"]], senderdata, msg, badges)
$Chat/ScrollContainer/ChatMessagesContainer.add_child(msgnode)
await(get_tree().process_frame)
if (bottom):
$Chat/ScrollContainer.scroll_vertical = $Chat/ScrollContainer.get_v_scroll_bar().max_value
class EmoteLocation extends RefCounted:
var id : String
var start : int
var end : int
func _init(emote_id, start_idx, end_idx):
self.id = emote_id
self.start = start_idx
self.end = end_idx
static func smaller(a : EmoteLocation, b : EmoteLocation):
return a.start < b.start

5
example/ChatMessage.gd
View File

@ -1,5 +0,0 @@
extends HBoxContainer
func set_msg(stamp : String, data : SenderData, msg : String, badges : String) -> void:
$RichTextLabel.text = stamp + " " + badges + "[b][color="+ data.tags["color"] + "]" + data.tags["display-name"] +"[/color][/b]: " + msg
queue_sort()

16
example/ChatMessage.tscn
View File

@ -1,16 +0,0 @@
[gd_scene load_steps=2 format=3 uid="uid://g4ajgul65cwi"]
[ext_resource type="Script" path="res://example/ChatMessage.gd" id="1"]
[node name="ChatMessage" type="HBoxContainer"]
size_flags_horizontal = 3
script = ExtResource("1")
[node name="RichTextLabel" type="RichTextLabel" parent="."]
layout_mode = 2
size_flags_horizontal = 3
focus_mode = 2
bbcode_enabled = true
fit_content = true
scroll_active = false
selection_enabled = true

115
example/Gift.gd
View File

@ -1,115 +0,0 @@
extends Gift
func _ready() -> void:
cmd_no_permission.connect(no_permission)
chat_message.connect(on_chat)
event.connect(on_event)
# I use a file in the working directory to store auth data
# so that I don't accidentally push it to the repository.
# Replace this or create a auth file with 3 lines in your
# project directory:
# <client_id>
# <client_secret>
# <initial channel>
var authfile := FileAccess.open("./example/auth.txt", FileAccess.READ)
client_id = authfile.get_line()
client_secret = authfile.get_line()
var initial_channel = authfile.get_line()
# When calling this method, a browser will open.
# Log in to the account that should be used.
await(authenticate(client_id, client_secret))
var success = await(connect_to_irc())
if (success):
request_caps()
join_channel(initial_channel)
await(channel_data_received)
await(connect_to_eventsub()) # Only required if you want to receive EventSub events.
# Refer to https://dev.twitch.tv/docs/eventsub/eventsub-subscription-types/ for details on
# what events exist, which API versions are available and which conditions are required.
# Make sure your token has all required scopes for the event.
subscribe_event("channel.follow", 2, {"broadcaster_user_id": user_id, "moderator_user_id": user_id})
# Adds a command with a specified permission flag.
# All implementations must take at least one arg for the command info.
# Implementations that recieve args requrires two args,
# the second arg will contain all params in a PackedStringArray
# This command can only be executed by VIPS/MODS/SUBS/STREAMER
add_command("test", command_test, 0, 0, PermissionFlag.NON_REGULAR)
# These two commands can be executed by everyone
add_command("helloworld", hello_world)
add_command("greetme", greet_me)
# This command can only be executed by the streamer
add_command("streamer_only", streamer_only, 0, 0, PermissionFlag.STREAMER)
# Command that requires exactly 1 arg.
add_command("greet", greet, 1, 1)
# Command that prints every arg seperated by a comma (infinite args allowed), at least 2 required
add_command("list", list, -1, 2)
# Adds a command alias
add_alias("test","test1")
add_alias("test","test2")
add_alias("test","test3")
# Or do it in a single line
# add_aliases("test", ["test1", "test2", "test3"])
# Remove a single command
remove_command("test2")
# Now only knows commands "test", "test1" and "test3"
remove_command("test")
# Now only knows commands "test1" and "test3"
# Remove all commands that call the same function as the specified command
purge_command("test1")
# Now no "test" command is known
# Send a chat message to the only connected channel (<channel_name>)
# Fails, if connected to more than one channel.
# chat("TEST")
# Send a chat message to channel <channel_name>
# chat("TEST", initial_channel)
# Send a whisper to target user (requires user:manage:whispers scope)
# whisper("TEST", initial_channel)
func on_event(type : String, data : Dictionary) -> void:
match(type):
"channel.follow":
print("%s followed your channel!" % data["user_name"])
func on_chat(data : SenderData, msg : String) -> void:
%ChatContainer.put_chat(data, msg)
# Check the CommandInfo class for the available info of the cmd_info.
func command_test(cmd_info : CommandInfo) -> void:
print("A")
func hello_world(cmd_info : CommandInfo) -> void:
chat("HELLO WORLD!")
func streamer_only(cmd_info : CommandInfo) -> void:
chat("Streamer command executed")
func no_permission(cmd_info : CommandInfo) -> void:
chat("NO PERMISSION!")
func greet(cmd_info : CommandInfo, arg_ary : PackedStringArray) -> void:
chat("Greetings, " + arg_ary[0])
func greet_me(cmd_info : CommandInfo) -> void:
chat("Greetings, " + cmd_info.sender_data.tags["display-name"] + "!")
func list(cmd_info : CommandInfo, arg_ary : PackedStringArray) -> void:
var msg = ""
for i in arg_ary.size() - 1:
msg += arg_ary[i]
msg += ", "
msg += arg_ary[arg_ary.size() - 1]
chat(msg)

6
example/LineEdit.gd
View File

@ -1,6 +0,0 @@
extends LineEdit
func _input(event : InputEvent):
if (event is InputEventKey):
if (event.pressed && event.keycode == KEY_ENTER):
%Button._pressed()

7
example/default_env.tres
View File

@ -1,7 +0,0 @@
[gd_resource type="Environment" load_steps=2 format=2]
[sub_resource type="ProceduralSky" id=1]
[resource]
background_mode = 2
background_sky = SubResource( 1 )

BIN
example/icon.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 271 B

34
example/icon.png.import
View File

@ -1,34 +0,0 @@
[remap]
importer="texture"
type="CompressedTexture2D"
uid="uid://ck2181giqo3ep"
path="res://.godot/imported/icon.png-5ad2e6e2e39e89ee29d5171fb300a340.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://example/icon.png"
dest_files=["res://.godot/imported/icon.png-5ad2e6e2e39e89ee29d5171fb300a340.ctex"]
[params]
compress/mode=0
compress/high_quality=false
compress/lossy_quality=0.7
compress/hdr_compression=1
compress/normal_map=0
compress/channel_pack=0
mipmaps/generate=false
mipmaps/limit=-1
roughness/mode=0
roughness/src_normal=""
process/fix_alpha_border=true
process/premult_alpha=false
process/normal_map_invert_y=false
process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1

0
addons/gift/icon.png → icon.png
View File

Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 188 B

After

Width:  |  Height:  |  Size: 188 B

6
addons/gift/icon.png.import → icon.png.import
View File

@ -3,15 +3,15 @@
importer="texture"
type="CompressedTexture2D"
uid="uid://rkm6ge1nohu1"
path="res://.godot/imported/icon.png-b5cf707f4ba91fefa5df60a746e02900.ctex"
path="res://.godot/imported/icon.png-487276ed1e3a0c39cad0279d744ee560.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://addons/gift/icon.png"
dest_files=["res://.godot/imported/icon.png-b5cf707f4ba91fefa5df60a746e02900.ctex"]
source_file="res://icon.png"
dest_files=["res://.godot/imported/icon.png-487276ed1e3a0c39cad0279d744ee560.ctex"]
[params]

3
project.godot
View File

@ -11,9 +11,8 @@ config_version=5
[application]
config/name="GIFT"
run/main_scene="res://example/Example.tscn"
run/main_scene="res://Example.tscn"
config/features=PackedStringArray("4.1")
config/icon="res://example/icon.png"
[debug]