Working mod

.gitignore

···
+.idea
+bin
+obj

Atproto.sln

···
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Atproto", "Atproto\Atproto.csproj", "{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+EndGlobal

Atproto/Atproto.csproj

···
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <TargetFramework>net8.0</TargetFramework>
+        <ImplicitUsings>enable</ImplicitUsings>
+        <Nullable>enable</Nullable>
+        <AssemblySearchPaths>$(AssemblySearchPaths);$(GDWeavePath)/core</AssemblySearchPaths>
+        <Version>1.0.0.0</Version>
+        <RootNamespace>Atproto</RootNamespace>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <Reference Include="GDWeave" Private="false"/>
+        <Reference Include="Serilog" Private="false"/>
+    </ItemGroup>
+
+    <ItemGroup>
+        <None Include="manifest.json" CopyToOutputDirectory="PreserveNewest"/>
+    </ItemGroup>
+
+    <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(GDWeavePath)' != ''">
+        <ItemGroup>
+            <_SourceFiles Include="$(OutDir)\**\*.*"/>
+        </ItemGroup>
+
+        <Copy
+                SourceFiles="@(_SourceFiles)"
+                DestinationFolder="$(GDWeavePath)/mods/$(AssemblyName)"
+        />
+    </Target>
+</Project>

Atproto/CalicoUtils/LexicalTransformer/TransformationPatternFactory.cs

···
+using GDWeave.Godot;
+using Teemaw.Calico.Util;
+using static GDWeave.Godot.TokenType;
+
+namespace Teemaw.Calico.LexicalTransformer;
+
+using MultiTokenPattern = Func<Token, bool>[];
+
+public static class TransformationPatternFactory
+{
+    /// <summary>
+    /// Creates a new pattern array which matches `extends &lt;Identifier&gt;\n`. Useful for patching into the global
+    /// scope.
+    /// </summary>
+    /// <returns></returns>
+    public static MultiTokenPattern CreateGlobalsPattern()
+    {
+        return
+        [
+            t => t.Type is PrExtends,
+            t => t.Type is Identifier,
+            t => t.Type is Newline
+        ];
+    }
+
+    /// <summary>
+    /// Creates a new pattern array which matches a function definition. This will not match the preceding or trailing
+    /// Newline tokens.
+    /// </summary>
+    /// <param name="name">The name of the function to match.</param>
+    /// <param name="args">
+    /// An array of the names of arguments of the function to match. If null or empty, the returned checks will only
+    /// match a function which does not accept arguments.
+    /// </param>
+    /// <returns></returns>
+    public static MultiTokenPattern CreateFunctionDefinitionPattern(string name, string[]? args = null)
+    {
+        var checks = new List<Func<Token, bool>>();
+
+        checks.Add(t => t.Type is PrFunction);
+        checks.Add(t => t is IdentifierToken token && token.Name == name);
+        checks.Add(t => t.Type is ParenthesisOpen);
+        if (args is { Length: > 0 })
+        {
+            foreach (var arg in args)
+            {
+                checks.Add(t => t is IdentifierToken token && token.Name == arg);
+                checks.Add(t => t.Type is Comma);
+            }
+
+            checks.RemoveAt(checks.Count - 1);
+        }
+
+        checks.Add(t => t.Type is ParenthesisClose);
+        checks.Add(t => t.Type is Colon);
+
+        return checks.ToArray();
+    }
+
+    /// <summary>
+    /// Creates a new pattern array which matches the provided GDScript snippet.
+    /// </summary>
+    /// <param name="snippet">A GDScript snippet to match.</param>
+    /// <param name="indent">The base indent of the snippet.</param>
+    /// <returns></returns>
+    public static MultiTokenPattern CreateGdSnippetPattern(string snippet, uint indent = 0)
+    {
+        var tokens = ScriptTokenizer.Tokenize(snippet, indent);
+
+        return tokens.Select(snippetToken => (Func<Token, bool>)(t =>
+        {
+            if (t.Type == Identifier)
+            {
+                return snippetToken is IdentifierToken snippetIdentifier && t is IdentifierToken identifier &&
+                       snippetIdentifier.Name == identifier.Name;
+            }
+
+            if (t.Type == Constant)
+            {
+                return snippetToken is ConstantToken snippetConstant && t is ConstantToken constant &&
+                       snippetConstant.Value.Equals(constant.Value);
+            }
+
+            return t.Type == snippetToken.Type;
+        })).ToArray();
+    }
+}

Atproto/CalicoUtils/LexicalTransformer/TransformationRule.cs

···
+using GDWeave.Godot;
+using GDWeave.Modding;
+using ScriptTokenizer = Teemaw.Calico.Util.ScriptTokenizer;
+
+namespace Teemaw.Calico.LexicalTransformer;
+
+using MultiTokenPattern = Func<Token, bool>[];
+
+public enum Operation
+{
+    /// <summary>
+    /// Do not patch.
+    /// </summary>
+    None,
+
+    /// <summary>
+    /// Replace all tokens of the waiter. This is a buffered operation. Buffered rules do not support overlapping token
+    /// patterns with other buffered rules.
+    /// </summary>
+    ReplaceAll,
+
+    /// <summary>
+    /// Replace the final token of the waiter.
+    /// </summary>
+    ReplaceLast,
+
+    /// <summary>
+    /// Appends after the final token of the waiter.
+    /// </summary>
+    Append,
+
+    /// <summary>
+    /// Prepends before the first token of the waiter. This is a buffered operation. Buffered rules do not support
+    /// overlapping token patterns with other buffered rules.
+    /// </summary>
+    Prepend,
+}
+
+public static class OperationExtensions
+{
+    public static bool RequiresBuffer(this Operation operation)
+    {
+        return operation is Operation.ReplaceAll or Operation.Prepend;
+    }
+
+    public static bool YieldTokenBeforeOperation(this Operation operation)
+    {
+        return operation is Operation.Append or Operation.None;
+    }
+
+    public static bool YieldTokenAfterOperation(this Operation operation)
+    {
+        return !operation.RequiresBuffer() && !operation.YieldTokenBeforeOperation() &&
+               operation != Operation.ReplaceLast;
+    }
+}
+
+/// <summary>
+/// This holds the information required to perform a patch at a single locus.
+/// </summary>
+/// <param name="Name">The name of this descriptor. Used for logging.</param>
+/// <param name="Pattern">A list of checks to be used in a MultiTokenWaiter.</param>
+/// <param name="ScopePattern">A list of checks to be used in a MultiTokenWaiter marking the .</param>
+/// <param name="Tokens">A list of GDScript tokens which will be patched in.</param>
+/// <param name="Operation">The type of patch.</param>
+/// <param name="Times">The number of times this rule is expected to match.</param>
+/// <param name="Predicate">A predicate which must return true for the rule to match.</param>
+public record TransformationRule(
+    string Name,
+    MultiTokenPattern Pattern,
+    MultiTokenPattern ScopePattern,
+    IEnumerable<Token> Tokens,
+    Operation Operation,
+    uint Times,
+    Func<bool> Predicate)
+{
+
+    public MultiTokenWaiter CreateMultiTokenWaiter() => new(Pattern);
+    
+    public MultiTokenWaiter CreateMultiTokenWaiterForScope() => new(ScopePattern);
+}
+
+/// <summary>
+/// Builder for TransformationRule. Times defaults to 1. Operation defaults to <see cref="Operation.Append"/>.
+/// </summary>
+public class TransformationRuleBuilder
+{
+    private string? _name;
+    private MultiTokenPattern? _pattern;
+    private MultiTokenPattern _scopePattern = [];
+    private IEnumerable<Token>? _tokens;
+    private uint _times = 1;
+    private Operation _operation = Operation.Append;
+    private Func<bool> _predicate = () => true;
+
+    /// <summary>
+    /// Sets the name for the TransformationRule. Used for logging.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder Named(string name)
+    {
+        _name = name;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the token pattern which will be matched by the TransformationRule.
+    /// </summary>
+    /// <param name="pattern"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder Matching(MultiTokenPattern pattern)
+    {
+        _pattern = pattern;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the token content which will be patched in for the TransformationRule.
+    /// </summary>
+    /// <param name="tokens"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder With(IEnumerable<Token> tokens)
+    {
+        _tokens = tokens;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the token content which will be patched in for the TransformationRule.
+    /// </summary>
+    /// <param name="token"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder With(Token token)
+    {
+        _tokens = [token];
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the token content which will be patched in for the TransformationRule with a GDScript snippet.
+    /// </summary>
+    /// <param name="snippet"></param>
+    /// <param name="indent">The base indentation level for the tokenizer.</param>
+    /// <returns></returns>
+    public TransformationRuleBuilder With(string snippet, uint indent = 0)
+    {
+        _tokens = ScriptTokenizer.Tokenize(snippet, indent);
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the <see cref="Operation"/> of the TransformationRule.
+    /// </summary>
+    /// <param name="operation"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder Do(Operation operation)
+    {
+        _operation = operation;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the number of times the rule is expected to match.
+    /// </summary>
+    /// <param name="times"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder ExpectTimes(uint times)
+    {
+        _times = times;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the scope of this rule.
+    /// </summary>
+    /// <param name="scopePattern"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder ScopedTo(MultiTokenPattern scopePattern)
+    {
+        _scopePattern = scopePattern;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the predicate function whose return value will decide if this rule will be checked.
+    /// </summary>
+    /// <param name="predicate"></param>
+    /// <returns></returns>
+    public TransformationRuleBuilder When(Func<bool> predicate)
+    {
+        _predicate = predicate;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets a value which will decide if this rule will be checked.
+    /// </summary>
+    /// <param name="eligible">If true, this rule will be checked.</param>
+    /// <returns></returns>
+    public TransformationRuleBuilder When(bool eligible)
+    {
+        _predicate = () => eligible;
+        return this;
+    }
+
+    /// <summary>
+    /// Builds the TransformationRule.
+    /// </summary>
+    /// <returns></returns>
+    /// <exception cref="ArgumentNullException">Thrown if any required fields were not set.</exception>
+    public TransformationRule Build()
+    {
+        if (string.IsNullOrEmpty(_name))
+        {
+            throw new ArgumentNullException(nameof(_name), "Name cannot be null or empty");
+        }
+
+        if (_pattern == null)
+        {
+            throw new ArgumentNullException(nameof(_pattern), "Pattern cannot be null");
+        }
+
+        if (_tokens == null)
+        {
+            throw new ArgumentNullException(nameof(_tokens), "Tokens cannot be null");
+        }
+
+        return new TransformationRule(_name, _pattern, _scopePattern, _tokens, _operation, _times, _predicate);
+    }
+}

Atproto/CalicoUtils/LexicalTransformer/TransformationRuleScriptMod.cs

···
+using GDWeave;
+using GDWeave.Godot;
+using GDWeave.Modding;
+using static Teemaw.Calico.LexicalTransformer.Operation;
+
+namespace Teemaw.Calico.LexicalTransformer;
+
+/// <summary>
+/// An IScriptMod implementation that handles patching through the provided list of TransformationRules.
+/// </summary>
+/// <param name="mod">IModInterface of the current mod.</param>
+/// <param name="name">The name of this script mod. Used for logging.</param>
+/// <param name="scriptPath">The GD res:// path of the script which will be patched.</param>
+/// <param name="rules">A list of patches to perform. Multiple descriptors with overlapping checks is not supported.</param>
+public class TransformationRuleScriptMod(
+    IModInterface mod,
+    string name,
+    string scriptPath,
+    Func<bool> predicate,
+    TransformationRule[] rules)
+    : IScriptMod
+{
+    public bool ShouldRun(string path)
+    {
+        if (path != scriptPath) return false;
+        if (!predicate.Invoke())
+        {
+            mod.Logger.Information($"[{name}] Predicate failed, not patching.");
+            return false;
+        }
+
+        return true;
+    }
+
+    public IEnumerable<Token> Modify(string path, IEnumerable<Token> tokens)
+    {
+        var eligibleRules = rules.Where(rule =>
+        {
+            var eligible = rule.Predicate();
+            if (!eligible)
+            {
+                mod.Logger.Information($"[{name}] Skipping patch {rule.Name}...");
+            }
+
+            return eligible;
+        }).ToList();
+        var transformers = eligibleRules.Select(rule =>
+                (Rule: rule, Waiter: rule.CreateMultiTokenWaiter(), Buffer: new List<Token>()))
+            .ToList();
+        mod.Logger.Information($"[{name}] Patching {path}");
+
+        var patchOccurrences =
+            eligibleRules.ToDictionary(r => r.Name, r => (Occurred: 0, Expected: r.Times));
+        var bufferAfterChecks = true;
+        var stagingBuffer = new List<Token>();
+        stagingBuffer.AddRange(tokens);
+        var transformedBuffer = new List<Token>();
+
+        foreach (var transformer in transformers)
+        {
+            var hasScopePattern = transformer.Rule.ScopePattern.Length > 0;
+            var inScope = !hasScopePattern;
+            uint? scopeIndent = null;
+            var scopeWaiter = transformer.Rule.CreateMultiTokenWaiterForScope();
+
+            foreach (var token in stagingBuffer)
+            {
+                if (inScope && hasScopePattern)
+                {
+                    // Try to find the scope's base indentation
+                    if (scopeIndent == null && token.Type == TokenType.Newline)
+                    {
+                        scopeIndent = token.AssociatedData ?? 0;
+                    }
+                    // Check if we should leave the scope
+                    else if (scopeIndent != null && token.Type == TokenType.Newline)
+                    {
+                        inScope = (token.AssociatedData ?? 0) >= scopeIndent;
+                    }
+                }
+                else if (hasScopePattern)
+                {
+                    // We should never reach this case if the scope pattern has Length = 0.
+                    if (scopeWaiter.Check(token))
+                    {
+                        scopeWaiter.Reset();
+                        // Latch inScope to true if we match the scope pattern.
+                        inScope = true;
+                    }
+                }
+
+                if (!inScope)
+                {
+                    transformedBuffer.Add(token);
+                    continue;
+                }
+
+                transformer.Waiter.Check(token);
+                if (transformer.Waiter.Step == 0)
+                {
+                    transformedBuffer.AddRange(transformer.Buffer);
+                    transformer.Buffer.Clear();
+                }
+                else
+                {
+                    if (transformer.Rule.Operation.RequiresBuffer())
+                    {
+                        transformer.Buffer.Add(token);
+                        bufferAfterChecks = false;
+                    }
+
+                    if (transformer.Waiter.Matched)
+                    {
+                        transformer.Waiter.Reset();
+
+                        if (transformer.Rule.Operation.YieldTokenBeforeOperation())
+                        {
+                            transformedBuffer.Add(token);
+                            bufferAfterChecks = false;
+                        }
+                        else
+                        {
+                            bufferAfterChecks =
+                                transformer.Rule.Operation.YieldTokenAfterOperation();
+                        }
+
+                        switch (transformer.Rule.Operation)
+                        {
+                            case Prepend:
+                                transformedBuffer.AddRange(transformer.Rule.Tokens);
+                                transformedBuffer.AddRange(transformer.Buffer);
+                                transformer.Buffer.Clear();
+                                break;
+                            case ReplaceLast:
+                            case Append:
+                            case ReplaceAll:
+                                transformer.Buffer.Clear();
+                                transformedBuffer.AddRange(transformer.Rule.Tokens);
+                                break;
+                            case None:
+                            default:
+                                break;
+                        }
+
+                        mod.Logger.Information(
+                            $"[{name}] Patch {transformer.Rule.Name} OK!");
+                        patchOccurrences[transformer.Rule.Name] =
+                            patchOccurrences[transformer.Rule.Name] with
+                            {
+                                Occurred = patchOccurrences[transformer.Rule.Name].Occurred + 1
+                            };
+                    }
+                }
+
+                if (bufferAfterChecks)
+                {
+                    transformedBuffer.Add(token);
+                }
+                else
+                {
+                    bufferAfterChecks = true;
+                }
+            }
+
+            stagingBuffer.Clear();
+            stagingBuffer.AddRange(transformedBuffer);
+            transformedBuffer.Clear();
+        }
+
+        foreach (var result in patchOccurrences.Where(result =>
+                     result.Value.Occurred != result.Value.Expected))
+        {
+            mod.Logger.Error(
+                $"[{name}] Patch {result.Key} FAILED! Times expected={result.Value.Expected}, actual={result.Value.Occurred}");
+        }
+
+        return stagingBuffer;
+    }
+}

Atproto/CalicoUtils/LexicalTransformer/TransformationRuleScriptModBuilder.cs

···
+using GDWeave;
+
+namespace Teemaw.Calico.LexicalTransformer;
+
+public class TransformationRuleScriptModBuilder
+{
+    private IModInterface? _mod;
+    private string? _name;
+    private string? _scriptPath;
+    private Func<bool> _predicate = () => true;
+    private List<TransformationRule> _rules = [];
+
+    /// <summary>
+    /// Sets the IModInterface to be used by the ScriptMod.
+    /// </summary>
+    /// <param name="mod"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder ForMod(IModInterface mod)
+    {
+        _mod = mod;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the predicate which must return true for this ScriptMod to run. Config options MUST be
+    /// evaluated at patch-time since the environment is not fully known at load-time. Currently,
+    /// this affects mod conflict detection, but there may be other affected features in the future.
+    /// </summary>
+    /// <param name="predicate"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder When(Func<bool> predicate)
+    {
+        _predicate = predicate;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the name of the ScriptMod. Used for logging.
+    /// </summary>
+    /// <param name="name"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder Named(string name)
+    {
+        _name = name;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the Godot resource path of the script to be patched.
+    /// </summary>
+    /// <param name="scriptPath"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder Patching(string scriptPath)
+    {
+        _scriptPath = scriptPath;
+        return this;
+    }
+
+    /// <summary>
+    /// Adds a TransformationRule to the TransformationRuleScriptMod.
+    /// </summary>
+    /// <param name="rule"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder AddRule(TransformationRule rule)
+    {
+        if (_rules.Select(r => r.Name).Contains(rule.Name))
+        {
+            throw new InvalidOperationException(
+                $"Another rule with the name '{rule.Name}' already exists!");
+        }
+
+        _rules.Add(rule);
+        return this;
+    }
+
+    /// <summary>
+    /// Adds the TransformationRule built by calling Build() on the provided builder to the TransformationRuleScriptMod.
+    /// </summary>
+    /// <param name="rule"></param>
+    /// <returns></returns>
+    public TransformationRuleScriptModBuilder AddRule(TransformationRuleBuilder rule)
+    {
+        return AddRule(rule.Build());
+    }
+
+    /// <summary>
+    /// Build the TransformationRuleScriptMod.
+    /// </summary>
+    /// <returns></returns>
+    /// <exception cref="ArgumentNullException">Thrown if any required fields were not set.</exception>
+    public TransformationRuleScriptMod Build()
+    {
+        if (_mod == null)
+        {
+            throw new ArgumentNullException(nameof(_mod), "Mod cannot be null");
+        }
+
+        if (string.IsNullOrEmpty(_name))
+        {
+            throw new ArgumentNullException(nameof(_name), "Name cannot be null or empty");
+        }
+
+        if (string.IsNullOrEmpty(_scriptPath))
+        {
+            throw new ArgumentNullException(nameof(_scriptPath),
+                "Script path cannot be null or empty");
+        }
+
+        return new TransformationRuleScriptMod(_mod, _name, _scriptPath, _predicate,
+            _rules.ToArray());
+    }
+}

Atproto/CalicoUtils/Util/ScriptTokenizer.cs

···
+// MIT License
+//
+// Copyright (c) 2024 NotNite
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+using System.Text;
+using GDWeave.Godot;
+using GDWeave.Godot.Variants;
+
+namespace Teemaw.Calico.Util;
+
+/**
+ * This is copied from https://github.com/NotNite/GDWeave/blob/main/GDWeave/Script/ScriptTokenizer.cs since this class
+ * was not made visible. Minor modifications have been made to make it more ergonomic to tokenize snippets.
+ */
+public static class ScriptTokenizer {
+    private static readonly Dictionary<string, TokenType> Tokens = new() {
+        {"continue", TokenType.CfContinue},
+        {"return", TokenType.CfReturn},
+        {"break", TokenType.CfBreak},
+        {"match", TokenType.CfMatch},
+        {"while", TokenType.CfWhile},
+        {"elif", TokenType.CfElif},
+        {"else", TokenType.CfElse},
+        {"pass", TokenType.CfPass},
+        {"for", TokenType.CfFor},
+        {"if", TokenType.CfIf},
+        {"const", TokenType.PrConst},
+        {"var", TokenType.PrVar},
+        {"func", TokenType.PrFunction},
+        {"class", TokenType.PrClass},
+        {"extends", TokenType.PrExtends},
+        {"is", TokenType.PrIs},
+        {"as", TokenType.PrAs},
+        {"@onready", TokenType.PrOnready},
+        {"@tool", TokenType.PrTool},
+        {"@export", TokenType.PrExport},
+        // CALICO:
+        {"yield", TokenType.PrYield},
+
+        {"setget", TokenType.PrSetget},
+        {"static", TokenType.PrStatic},
+
+        {"void", TokenType.PrVoid},
+        {"enum", TokenType.PrEnum},
+        {"preload", TokenType.PrPreload},
+        {"assert", TokenType.PrAssert},
+
+        {"signal", TokenType.PrSignal},
+        {"breakpoint", TokenType.PrBreakpoint},
+
+        {"sync", TokenType.PrSync},
+        {"remote", TokenType.PrRemote},
+        {"master", TokenType.PrMaster},
+        {"slave", TokenType.PrSlave},
+        {"puppet", TokenType.PrPuppet},
+
+        {"remotesync", TokenType.PrRemotesync},
+        {"mastersync", TokenType.PrMastersync},
+        {"puppetsync", TokenType.PrPuppetsync},
+
+        {"\n", TokenType.Newline},
+
+        {"PI", TokenType.ConstPi},
+        {"TAU", TokenType.ConstTau},
+        {"INF", TokenType.ConstInf},
+        {"NAN", TokenType.ConstNan},
+
+        {"error", TokenType.Error},
+        {"cursor", TokenType.Cursor},
+
+        {"self", TokenType.Self},
+
+        {"in", TokenType.OpIn},
+
+        {"_", TokenType.Wildcard},
+
+        {"[", TokenType.BracketOpen},
+        {"]", TokenType.BracketClose},
+        {"{", TokenType.CurlyBracketOpen},
+        {"}", TokenType.CurlyBracketClose},
+
+        {"(", TokenType.ParenthesisOpen},
+        {")", TokenType.ParenthesisClose},
+
+        {",", TokenType.Comma},
+        {";", TokenType.Semicolon},
+        {".", TokenType.Period},
+        {"?", TokenType.QuestionMark},
+        {":", TokenType.Colon},
+        {"$", TokenType.Dollar},
+        {"->", TokenType.ForwardArrow},
+
+        {">>=", TokenType.OpAssignShiftRight},
+        {"<<=", TokenType.OpAssignShiftLeft},
+
+        {">>", TokenType.OpShiftRight},
+        {"<<", TokenType.OpShiftLeft},
+
+        {"==", TokenType.OpEqual},
+        {"!=", TokenType.OpNotEqual},
+        {"&&", TokenType.OpAnd},
+        {"||", TokenType.OpOr},
+        {"!", TokenType.OpNot},
+
+        {"+=", TokenType.OpAssignAdd},
+        {"-=", TokenType.OpAssignSub},
+        {"*=", TokenType.OpAssignMul},
+        {"/=", TokenType.OpAssignDiv},
+        {"%=", TokenType.OpAssignMod},
+        {"&=", TokenType.OpAssignBitAnd},
+        {"|=", TokenType.OpAssignBitOr},
+        {"^=", TokenType.OpAssignBitXor},
+
+        {"+", TokenType.OpAdd},
+        {"-", TokenType.OpSub},
+        {"*", TokenType.OpMul},
+        {"/", TokenType.OpDiv},
+        {"%", TokenType.OpMod},
+
+        {"~", TokenType.OpBitInvert},
+        {"&", TokenType.OpBitAnd},
+        {"|", TokenType.OpBitOr},
+        {"^", TokenType.OpBitXor},
+
+        {"<=", TokenType.OpLessEqual},
+        {">=", TokenType.OpGreaterEqual},
+        {"<", TokenType.OpLess},
+        {">", TokenType.OpGreater},
+
+        {"=", TokenType.OpAssign},
+    };
+
+    private static readonly HashSet<string> Symbols = new() {
+        "->",
+
+        ">>=",
+        "<<=",
+
+        ">>",
+        "<<",
+
+        "==",
+        "!=",
+        "&&",
+        "||",
+        "!",
+
+        "+=",
+        "-=",
+        "*=",
+        "/=",
+        "%=",
+       "&=",
+        "|=",
+        "^=",
+
+        "_",
+
+        "[",
+        "]",
+
+        "{",
+        "}",
+
+        "(",
+        ")",
+
+        ",",
+        ";",
+        ".",
+        "?",
+        ":",
+        "$",
+        "+",
+        "-",
+        "*",
+        "/",
+        "%",
+
+        "~",
+        "&",
+        "|",
+        "^",
+
+        "<=",
+        ">=",
+        "<",
+        ">",
+
+        "=",
+    };
+
+    private static readonly List<string> BuiltinFunctions = Enum.GetNames<BuiltinFunction>().ToList();
+
+    private static void InsertNewLine(IEnumerator<string> enumerator, uint baseIndent, List<Token> toFlush) {
+        if (!enumerator.MoveNext()) {
+            return;
+        }
+
+        var tabCount = uint.Parse(enumerator.Current);
+        toFlush.Add(new Token(TokenType.Newline, tabCount + baseIndent));
+    }
+
+    private static void BuildIdentifierName(IEnumerator<string> enumerator, List<Token> toFlush, out string? found) {
+        found = string.Empty;
+        if (!enumerator.MoveNext()) {
+            return;
+        }
+
+        if (enumerator.Current == ":") {
+            toFlush.Add(new Token(TokenType.Wildcard));
+            toFlush.Add(new Token(TokenType.Semicolon));
+            return;
+        }
+
+        found = "_" + enumerator.Current;
+    }
+
+    private static void BuildNumber(IEnumerator<string> enumerator, List<Token> toFlush, out bool foundFull) {
+        foundFull = true;
+        int sign = 1;
+
+        if (enumerator.Current == "-") {
+            sign = -1;
+            if (!enumerator.MoveNext()) return;
+        }
+
+        if (!long.TryParse(enumerator.Current, out long upper)) {
+            toFlush.Add(new Token(TokenType.OpSub));
+            foundFull = false;
+            return;
+        }
+
+        if (!enumerator.MoveNext()) return;
+
+        if (enumerator.Current != ".") {
+            toFlush.Add(new ConstantToken(new IntVariant(upper * sign)));
+            foundFull = false;
+            return;
+        }
+
+        if (!enumerator.MoveNext()) return;
+
+        if (!long.TryParse(enumerator.Current, out long lower)) {
+            // I dont think there is really a proper return for here.
+            // You'd have a number that looks like this "1000."
+            // No following decimal
+            // Comment if you had ideas
+            return;
+        }
+
+        var result = upper + (lower / Math.Pow(10, lower.ToString().Length));
+        toFlush.Add(new ConstantToken(new RealVariant(result * sign)));
+    }
+
+    public static IEnumerable<Token> Tokenize(string gdScript, uint baseIndent = 0) {
+        var finalTokens = new List<Token>();
+        var tokens = SanitizeInput(TokenizeString(gdScript + " "));
+
+        var previous = string.Empty;
+        var idName = string.Empty;
+
+        var toFlush = new List<Token>(2);
+        // CALICO: We don't need this since we're dealing with snippets
+        //finalTokens.Add(new Token(TokenType.Newline, baseIndent));
+        var enumerator = tokens.GetEnumerator();
+        var reparse = false;
+        while (reparse ? true : enumerator.MoveNext()) {
+            reparse = false;
+
+            if (enumerator.Current == "\n") {
+                InsertNewLine(enumerator, baseIndent, toFlush);
+                endAndFlushId();
+                continue;
+            }
+
+            if (enumerator.Current == "_") {
+                BuildIdentifierName(enumerator, toFlush, out string? found);
+                if (found == string.Empty) {
+                    endAndFlushId();
+                    continue;
+                }
+
+                idName += found;
+
+                end();
+                continue;
+            }
+
+            //if (enumerator.Current == "-" || char.IsDigit(enumerator.Current[0])) {
+            if (char.IsDigit(enumerator.Current[0])) {
+                BuildNumber(enumerator, toFlush, out bool foundFull);
+                reparse = !foundFull;
+                endAndFlushId();
+                continue;
+            }
+
+            if (BuiltinFunctions.Contains(enumerator.Current)) {
+                toFlush.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunctions.IndexOf(enumerator.Current)));
+                endAndFlushId();
+                continue;
+            }
+
+            if (Tokens.TryGetValue(enumerator.Current, out var type)) {
+                toFlush.Add(new Token(type));
+                endAndFlushId();
+                continue;
+            }
+
+            if (enumerator.Current.StartsWith('"')) {
+                var current = enumerator.Current;
+                toFlush.Add(new ConstantToken(new StringVariant(current.Substring(1, current.Length - 2))));
+                endAndFlushId();
+                continue;
+            }
+
+            if (bool.TryParse(enumerator.Current, out var resultB)) {
+                toFlush.Add(new ConstantToken(new BoolVariant(resultB)));
+                endAndFlushId();
+                continue;
+            }
+
+            idName += enumerator.Current;
+
+            end();
+
+            void end() {
+                previous = enumerator.Current;
+                finalTokens.AddRange(toFlush);
+                toFlush.Clear();
+            }
+
+            void endAndFlushId() {
+                if (idName != string.Empty) {
+                    if (idName.Trim() == "return")
+                    {
+                        // CALICO: Hack to handle `return` being the last token of a line
+                        finalTokens.Add(new Token(TokenType.CfReturn));
+                    }
+                    else if (idName.Trim() == "self")
+                    {
+                        // CALICO: Hack to handle `self` being the last token of a line
+                        finalTokens.Add(new Token(TokenType.Self));
+                    }
+                    else switch (idName.Trim())
+                    {
+                        // TODO: CALICO: clean up this hack
+                        case "print":
+                            // CALICO: Without this, `print` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.TextPrint));
+                            break;
+                        case "min":
+                            // CALICO: Without this, `min` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.LogicMin));
+                            break;
+                        case "null":
+                            // CALICO: Without this, `null` is tokenized as an identifier.
+                            finalTokens.Add(new ConstantToken(new NilVariant()));
+                            break;
+                        case "break":
+                            // CALICO: Without this, `break` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.CfBreak));
+                            break;
+                        case "match":
+                            // CALICO: Without this, `match` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.CfMatch));
+                            break;
+                        case "Color":
+                            // CALICO: Without this, `Color` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.BuiltInType, 14));
+                            break;
+                        case "Vector3":
+                            // CALICO: Without this, `Vector3` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.BuiltInType, 7));
+                            break;
+                        case "lerp_angle":
+                            // CALICO: Without this, `lerp_angle` is tokenized as an identifier.
+                            finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathLerpAngle));
+                            break;
+                        case "int":
+                            // CALICO: https://docs.godotengine.org/en/3.5/tutorials/io/binary_serialization_api.html
+                            finalTokens.Add(new Token(TokenType.BuiltInType, 2));
+                            break;
+                        case "pow":
+                            // CALICO:
+                            finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathPow));
+                            break;
+                        case "abs":
+                            // CALICO:
+                            finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathAbs));
+                            break;
+                        default:
+                            // CALICO: We change this to trim the idName, otherwise the whitespace messes with the token
+                            finalTokens.Add(new IdentifierToken(idName.Trim()));
+                            break;
+                    }
+                    idName = string.Empty;
+                }
+
+                end();
+            }
+        }
+
+        // CALICO: We don't need this since we're dealing with snippets
+        //finalTokens.Add(new(TokenType.Newline, baseIndent));
+
+        foreach (var t in finalTokens) yield return t;
+    }
+
+    private static IEnumerable<string> SanitizeInput(IEnumerable<string> tokens) {
+        foreach (var token in tokens) {
+            if (token != "\n" && string.IsNullOrWhiteSpace(token)) {
+                continue;
+            }
+
+            yield return token;
+        }
+    }
+
+    private static IEnumerable<string> TokenizeString(string text) {
+        StringBuilder builder = new(20);
+        for (var i = 0; i < text.Length; i++) {
+            switch (text[i]) {
+                case '"': {
+                    yield return ClearBuilder();
+                    builder.Append('"');
+                    i++;
+                    for (; i < text.Length; i++) {
+                        builder.Append(text[i]);
+                        if (text[i] == '"') {
+                            break;
+                        }
+                    }
+
+                    yield return ClearBuilder();
+                    continue;
+                }
+
+                // This is stupid and awful
+                case '\n': {
+                    yield return ClearBuilder();
+                    var start = i;
+                    i++;
+                    for (; i < text.Length && text[i] == '\t'; i++) ;
+                    i--;
+                    yield return "\n";
+                    yield return $"{i - start}";
+                    continue;
+                }
+            }
+
+            var matched = false;
+            foreach (var delimiter in Symbols) {
+                if (Match(text, i, delimiter)) {
+                    yield return ClearBuilder();
+                    yield return delimiter;
+                    i += delimiter.Length - 1;
+                    matched = true;
+                    break;
+                }
+            }
+
+            if (matched) continue;
+
+            if (text[i] == ' ') {
+                yield return ClearBuilder();
+                continue;
+            }
+
+            builder.Append(text[i]);
+        }
+
+        yield return "\n";
+
+        string ClearBuilder() {
+            var built = builder.ToString();
+            builder.Clear();
+            return built;
+        }
+    }
+
+    private static bool Match(string text, int index, string match) {
+        if (index + match.Length > text.Length) return false;
+        for (var i = 0; i < match.Length; i++) {
+            if (text[index + i] != match[i]) return false;
+        }
+        return true;
+    }
+}

Atproto/CalicoUtils/Util/TokenUtil.cs

···
+using GDWeave.Godot;
+using GDWeave.Godot.Variants;
+using static GDWeave.Godot.TokenType;
+
+namespace Teemaw.Calico.Util;
+
+public static class TokenUtil
+{
+    public static IEnumerable<Token> ReplaceAssignmentsAsDeferred(IEnumerable<Token> tokens,
+        HashSet<string>? ignoredIdentifiers = null)
+    {
+        Token? lastToken = null;
+        var inAssignmentStatement = false;
+        var skipLine = false;
+        foreach (var t in tokens)
+        {
+            switch (t)
+            {
+                case { Type: Newline }:
+                    skipLine = false;
+                    break;
+                case { Type: PrVar }:
+                    skipLine = true;
+                    break;
+                default:
+                {
+                    if (lastToken is IdentifierToken identifier &&
+                        (ignoredIdentifiers == null || !ignoredIdentifiers.Contains(identifier.Name)) &&
+                        t is { Type: OpAssign } && !skipLine)
+                    {
+                        inAssignmentStatement = true;
+                        yield return new IdentifierToken("set_deferred");
+                        yield return new Token(ParenthesisOpen);
+                        yield return new ConstantToken(new StringVariant(identifier.Name));
+                        yield return new Token(Comma);
+                        // Don't return the last token or current token
+                        lastToken = null;
+                        continue;
+                    }
+
+                    break;
+                }
+            }
+
+            if (t.Type == Newline && inAssignmentStatement)
+            {
+                inAssignmentStatement = false;
+                if (lastToken != null)
+                    yield return lastToken;
+                // Close out the set_deferred call...
+                yield return new Token(ParenthesisClose);
+                // ...before the Newline token.
+                yield return t;
+            }
+            else if (lastToken != null)
+                yield return lastToken;
+
+            lastToken = inAssignmentStatement && t is { Type: Identifier } ? StripAssociatedData(t) : t;
+        }
+
+        if (lastToken != null)
+            yield return lastToken;
+    }
+    
+    public static Token ReplaceToken(Token cursor, Token target, Token replacement)
+    {
+        return TokenEquals(cursor, target) ? replacement : cursor;
+    }
+
+    public static IEnumerable<Token> ReplaceTokens(IEnumerable<Token> haystack, IEnumerable<Token> needle,
+        IEnumerable<Token> replacements)
+    {
+        var haystackList = haystack.ToList();
+        var needleList = needle.ToList();
+        var replacementsList = replacements.ToList();
+
+        if (needleList.Count == 0) return haystackList;
+
+        var result = new List<Token>();
+        var i = 0;
+
+        while (i < haystackList.Count)
+        {
+            if (IsMatch(haystackList, needleList, i))
+            {
+                result.AddRange(replacementsList);
+                i += needleList.Count;
+            }
+            else
+            {
+                result.Add(haystackList[i]);
+                i++;
+            }
+        }
+
+        return result;
+    }
+
+    private static bool IsMatch(List<Token> haystack, List<Token> needle, int startIndex)
+    {
+        if (startIndex + needle.Count > haystack.Count)
+            return false;
+
+        for (int i = 0; i < needle.Count; i++)
+        {
+            if (!TokenEquals(haystack[startIndex + i], needle[i]))
+                return false;
+        }
+
+        return true;
+    }
+
+    private static bool TokenEquals(Token token, Token token1)
+    {
+        if (token is IdentifierToken id && token1 is IdentifierToken id1)
+        {
+            return id.Name == id1.Name;
+        }
+        if (token is ConstantToken constant && token1 is ConstantToken constant1)
+        {
+            return constant.Value.Equals(constant1.Value);
+        }
+        return token.Type == token1.Type && token.AssociatedData == token1.AssociatedData;
+    }
+
+    private static Token StripAssociatedData(Token token)
+    {
+        token.AssociatedData = null;
+        return token;
+    }
+}

Atproto/CalicoUtils/Util/WeaveUtil.cs

···
+using GDWeave;
+
+namespace Teemaw.Calico.Util;
+
+public static class WeaveUtil
+{
+    public static bool IsModLoaded(IModInterface modInterface, string modName) =>
+        modInterface.LoadedMods.Contains(modName);
+}

Atproto/CatchFishFactory.cs

···
+using GDWeave;
+using GDWeave.Modding;
+using Teemaw.Calico.LexicalTransformer;
+
+namespace Atproto;
+
+public static class CatchFishFactory
+{
+    public static IScriptMod Create(IModInterface mod)
+    {
+        return new TransformationRuleScriptModBuilder()
+            .ForMod(mod)
+            .Named("CatchFish")
+            .Patching("res://Scenes/Entities/Player/player.gdc")
+            .AddRule(new TransformationRuleBuilder()
+                .Named("create_fish_record")
+                .Matching(TransformationPatternFactory.CreateGdSnippetPattern(
+                    "PlayerData._log_item(fish_roll, size, quality)\n", 3))
+                .Do(Operation.Append)
+                .With("$\"/root/Atproto\".AtProtoClient.catch_fish(fish_roll, size, quality)\n", 3)).Build();
+    }
+}

Atproto/CatptureFishFactory.cs

···
+using GDWeave;
+using GDWeave.Modding;
+using Teemaw.Calico.LexicalTransformer;
+
+namespace Atproto;
+
+public static class CatptureFishFactory
+{
+    public static IScriptMod Create(IModInterface mod)
+    {
+        return new TransformationRuleScriptModBuilder()
+            .ForMod(mod)
+            .Named("CaptureFish")
+            .Patching("res://Scenes/Entities/Props/fish_trap.gdc")
+            .AddRule(new TransformationRuleBuilder()
+                .Named("create_fish_record")
+                .Matching(TransformationPatternFactory.CreateGdSnippetPattern(
+                    "PlayerData._log_item(fish_roll, size, quality)\n", 1))
+                .Do(Operation.Append)
+                .With("$\"/root/Atproto\".AtProtoClient.catch_fish(fish_roll, size, quality)\n", 1)).Build();
+    }
+}

Atproto/Config.cs

···
+using System.Text.Json.Serialization;
+
+namespace Atproto;
+
+public class Config {
+    [JsonInclude] public string Handle = "";
+    [JsonInclude] public string Password = "";
+}

Atproto/Mod.cs

···
+using GDWeave;
+
+namespace Atproto;
+
+public class Mod : IMod {
+    public Config Config;
+
+    public Mod(IModInterface modInterface) {
+        Config = modInterface.ReadConfig<Config>();
+        modInterface.RegisterScriptMod(CatchFishFactory.Create(modInterface));
+        modInterface.RegisterScriptMod(CatptureFishFactory.Create(modInterface));
+    }
+
+    public void Dispose() {
+        // Cleanup anything you do here
+    }
+}

Atproto/manifest.json

···
+{
+  "Id": "Atproto",
+  "AssemblyPath": "Atproto.dll",
+  "Metadata": {
+    "Name": "Atproto Webfishing",
+    "Author": "Estym",
+    "Version": "1.0.0",
+    "Description": "This is a sample mod."
+  },
+  "PackPath": "atproto.pck",
+  "Dependencies": [
+    "TackleBox"
+  ]
+}

README.md

···
+# ATProto Webfishing
+
+A Webfishing mod that send data to your PDS
+
+## Requirements
+- [GDWeave](https://thunderstore.io/c/webfishing/p/NotNet/GDWeave/)
+- [TackleBox](https://thunderstore.io/c/webfishing/p/PuppyGirl/TackleBox/)
+
+## Configuration
+In game using the TackleBox mod menu, you can input your AtProto Handle as well as an App Password to login
+After it's done, simply save and quit the game, you'll be connected on the next startup
+
+## Credits
+
+- Thanks to [Tiany Ma](https://github.com/tma02) for its utils 

gdscript/.import/.gdignore

···
-

gdscript/mods/AtProto/atproto.gd gdscript/mods/Atproto/atproto_client.gd

···
 extends Node
-class_name AtProto
 
 # AtProto
 var did
 var pds
-
 var accessJwt
 var refreshJwt
 
···
 var requester: HTTPRequest
 
 func _enter_tree():
-	var root = get_tree().get_root()
-	var instance = root.get_node("AtProto")
-	self.name = "AtProto"
-	if instance == null:
-		root.add_child(self, true)
-		self.requester = HTTPRequest.new()
-		self.add_child(self.requester, true)
+	self.requester = HTTPRequest.new()
+	self.add_child(self.requester, true)
 
 func is_token_expired() -> bool:
 	var json = Marshalls.base64_to_utf8(self.accessJwt.split(".")[1])
···
 
 
 ######################
-#    STATIC CALLS    #
+#    Method Calls    #
 ######################
 
-static func catch_fish(node, fish, size, quality):
-	# var fish_data = Globals.item_data[fish]["file"]
-	# var record = {
-	# 	at_type = "dev.regnault.webfishing.fish",
-	# 	id = fish,
-	# 	name = fish_data.item_name,
-	# 	size = str(size),
-	# 	quality = quality
-	# }
-	# node.get_tree().get_root().get_node("AtProto").create_record(record)
-	pass
+func catch_fish(fish, size, quality):
+	var fish_data = Globals.item_data[fish]["file"]
+	var record = {
+		at_type = "dev.regnault.webfishing.fish",
+		id = fish,
+		name = fish_data.item_name,
+		size = str(size),
+		quality = quality
+	}
+	create_record(record)

gdscript/mods/AtProto/main.gd

···
-extends Node
-
-func _enter_tree():
-    var at_proto = AtProto.new()
-    get_tree().root.add_node(at_proto)

gdscript/mods/Atproto/main.gd

···
+extends Node
+
+var config: Dictionary
+var default_config: Dictionary = {}
+
+onready var TackleBox := $"/root/TackleBox"
+const AtProtoClient_t := preload("res://mods/Atproto/atproto_client.gd")
+var AtProtoClient: AtProtoClient_t
+
+func _enter_tree():
+	AtProtoClient = AtProtoClient_t.new()
+	add_child(AtProtoClient)
+	
+func _ready() -> void:
+	TackleBox.connect("mod_config_updated", self, "_on_config_update")
+	_init_config()
+
+func _init_config():
+	var saved_config = TackleBox.get_mod_config(name)
+	for key in default_config.keys():
+		if not saved_config[key]:
+			saved_config[key] = default_config[key]
+	config = saved_config
+	TackleBox.set_mod_config(name, config)
+	if config.Handle != "" and config.Password != "":
+		AtProtoClient.login(config.Handle, config.Password)
+
+
+func _on_config_update(mod_id: String, new_config: Dictionary) -> void:
+	if mod_id != name:
+		return
+	if config.hash() == new_config.hash():
+		return
+	config = new_config
+	if config.Handle != "" and config.Password != "":
+		AtProtoClient.login(config.Handle, config.Password)

gdscript/project.godot

···
 
 config_version=4
 
-_global_script_classes=[ {
-"base": "Node",
-"class": "AtProto",
-"language": "GDScript",
-"path": "res://mods/AtProto/atproto.gd"
-} ]
-_global_script_class_icons={
-"AtProto": ""
-}
-
 [application]
 
-config/name="Webfishing AtProto"
+config/name="AtProto Webfishing"
 
 [gui]