+3

.gitignore

··· 1 1 + .idea 2 2 + bin 3 3 + obj

+16

Atproto.sln

··· 1 1 +  2 2 + Microsoft Visual Studio Solution File, Format Version 12.00 3 3 + Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Atproto", "Atproto\Atproto.csproj", "{1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}" 4 4 + EndProject 5 5 + Global 6 6 + GlobalSection(SolutionConfigurationPlatforms) = preSolution 7 7 + Debug|Any CPU = Debug|Any CPU 8 8 + Release|Any CPU = Release|Any CPU 9 9 + EndGlobalSection 10 10 + GlobalSection(ProjectConfigurationPlatforms) = postSolution 11 11 + {1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU 12 12 + {1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Debug|Any CPU.Build.0 = Debug|Any CPU 13 13 + {1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Release|Any CPU.ActiveCfg = Release|Any CPU 14 14 + {1A273855-C2D0-40BB-B22C-CE17AA4D0A9B}.Release|Any CPU.Build.0 = Release|Any CPU 15 15 + EndGlobalSection 16 16 + EndGlobal

+30

Atproto/Atproto.csproj

··· 1 1 + <Project Sdk="Microsoft.NET.Sdk"> 2 2 + <PropertyGroup> 3 3 + <TargetFramework>net8.0</TargetFramework> 4 4 + <ImplicitUsings>enable</ImplicitUsings> 5 5 + <Nullable>enable</Nullable> 6 6 + <AssemblySearchPaths>$(AssemblySearchPaths);$(GDWeavePath)/core</AssemblySearchPaths> 7 7 + <Version>1.0.0.0</Version> 8 8 + <RootNamespace>Atproto</RootNamespace> 9 9 + </PropertyGroup> 10 10 + 11 11 + <ItemGroup> 12 12 + <Reference Include="GDWeave" Private="false"/> 13 13 + <Reference Include="Serilog" Private="false"/> 14 14 + </ItemGroup> 15 15 + 16 16 + <ItemGroup> 17 17 + <None Include="manifest.json" CopyToOutputDirectory="PreserveNewest"/> 18 18 + </ItemGroup> 19 19 + 20 20 + <Target Name="PostBuild" AfterTargets="PostBuildEvent" Condition="'$(GDWeavePath)' != ''"> 21 21 + <ItemGroup> 22 22 + <_SourceFiles Include="$(OutDir)\**\*.*"/> 23 23 + </ItemGroup> 24 24 + 25 25 + <Copy 26 26 + SourceFiles="@(_SourceFiles)" 27 27 + DestinationFolder="$(GDWeavePath)/mods/$(AssemblyName)" 28 28 + /> 29 29 + </Target> 30 30 + </Project>

+87

Atproto/CalicoUtils/LexicalTransformer/TransformationPatternFactory.cs

··· 1 1 + using GDWeave.Godot; 2 2 + using Teemaw.Calico.Util; 3 3 + using static GDWeave.Godot.TokenType; 4 4 + 5 5 + namespace Teemaw.Calico.LexicalTransformer; 6 6 + 7 7 + using MultiTokenPattern = Func<Token, bool>[]; 8 8 + 9 9 + public static class TransformationPatternFactory 10 10 + { 11 11 + /// <summary> 12 12 + /// Creates a new pattern array which matches `extends &lt;Identifier&gt;\n`. Useful for patching into the global 13 13 + /// scope. 14 14 + /// </summary> 15 15 + /// <returns></returns> 16 16 + public static MultiTokenPattern CreateGlobalsPattern() 17 17 + { 18 18 + return 19 19 + [ 20 20 + t => t.Type is PrExtends, 21 21 + t => t.Type is Identifier, 22 22 + t => t.Type is Newline 23 23 + ]; 24 24 + } 25 25 + 26 26 + /// <summary> 27 27 + /// Creates a new pattern array which matches a function definition. This will not match the preceding or trailing 28 28 + /// Newline tokens. 29 29 + /// </summary> 30 30 + /// <param name="name">The name of the function to match.</param> 31 31 + /// <param name="args"> 32 32 + /// An array of the names of arguments of the function to match. If null or empty, the returned checks will only 33 33 + /// match a function which does not accept arguments. 34 34 + /// </param> 35 35 + /// <returns></returns> 36 36 + public static MultiTokenPattern CreateFunctionDefinitionPattern(string name, string[]? args = null) 37 37 + { 38 38 + var checks = new List<Func<Token, bool>>(); 39 39 + 40 40 + checks.Add(t => t.Type is PrFunction); 41 41 + checks.Add(t => t is IdentifierToken token && token.Name == name); 42 42 + checks.Add(t => t.Type is ParenthesisOpen); 43 43 + if (args is { Length: > 0 }) 44 44 + { 45 45 + foreach (var arg in args) 46 46 + { 47 47 + checks.Add(t => t is IdentifierToken token && token.Name == arg); 48 48 + checks.Add(t => t.Type is Comma); 49 49 + } 50 50 + 51 51 + checks.RemoveAt(checks.Count - 1); 52 52 + } 53 53 + 54 54 + checks.Add(t => t.Type is ParenthesisClose); 55 55 + checks.Add(t => t.Type is Colon); 56 56 + 57 57 + return checks.ToArray(); 58 58 + } 59 59 + 60 60 + /// <summary> 61 61 + /// Creates a new pattern array which matches the provided GDScript snippet. 62 62 + /// </summary> 63 63 + /// <param name="snippet">A GDScript snippet to match.</param> 64 64 + /// <param name="indent">The base indent of the snippet.</param> 65 65 + /// <returns></returns> 66 66 + public static MultiTokenPattern CreateGdSnippetPattern(string snippet, uint indent = 0) 67 67 + { 68 68 + var tokens = ScriptTokenizer.Tokenize(snippet, indent); 69 69 + 70 70 + return tokens.Select(snippetToken => (Func<Token, bool>)(t => 71 71 + { 72 72 + if (t.Type == Identifier) 73 73 + { 74 74 + return snippetToken is IdentifierToken snippetIdentifier && t is IdentifierToken identifier && 75 75 + snippetIdentifier.Name == identifier.Name; 76 76 + } 77 77 + 78 78 + if (t.Type == Constant) 79 79 + { 80 80 + return snippetToken is ConstantToken snippetConstant && t is ConstantToken constant && 81 81 + snippetConstant.Value.Equals(constant.Value); 82 82 + } 83 83 + 84 84 + return t.Type == snippetToken.Type; 85 85 + })).ToArray(); 86 86 + } 87 87 + }

+231

Atproto/CalicoUtils/LexicalTransformer/TransformationRule.cs

··· 1 1 + using GDWeave.Godot; 2 2 + using GDWeave.Modding; 3 3 + using ScriptTokenizer = Teemaw.Calico.Util.ScriptTokenizer; 4 4 + 5 5 + namespace Teemaw.Calico.LexicalTransformer; 6 6 + 7 7 + using MultiTokenPattern = Func<Token, bool>[]; 8 8 + 9 9 + public enum Operation 10 10 + { 11 11 + /// <summary> 12 12 + /// Do not patch. 13 13 + /// </summary> 14 14 + None, 15 15 + 16 16 + /// <summary> 17 17 + /// Replace all tokens of the waiter. This is a buffered operation. Buffered rules do not support overlapping token 18 18 + /// patterns with other buffered rules. 19 19 + /// </summary> 20 20 + ReplaceAll, 21 21 + 22 22 + /// <summary> 23 23 + /// Replace the final token of the waiter. 24 24 + /// </summary> 25 25 + ReplaceLast, 26 26 + 27 27 + /// <summary> 28 28 + /// Appends after the final token of the waiter. 29 29 + /// </summary> 30 30 + Append, 31 31 + 32 32 + /// <summary> 33 33 + /// Prepends before the first token of the waiter. This is a buffered operation. Buffered rules do not support 34 34 + /// overlapping token patterns with other buffered rules. 35 35 + /// </summary> 36 36 + Prepend, 37 37 + } 38 38 + 39 39 + public static class OperationExtensions 40 40 + { 41 41 + public static bool RequiresBuffer(this Operation operation) 42 42 + { 43 43 + return operation is Operation.ReplaceAll or Operation.Prepend; 44 44 + } 45 45 + 46 46 + public static bool YieldTokenBeforeOperation(this Operation operation) 47 47 + { 48 48 + return operation is Operation.Append or Operation.None; 49 49 + } 50 50 + 51 51 + public static bool YieldTokenAfterOperation(this Operation operation) 52 52 + { 53 53 + return !operation.RequiresBuffer() && !operation.YieldTokenBeforeOperation() && 54 54 + operation != Operation.ReplaceLast; 55 55 + } 56 56 + } 57 57 + 58 58 + /// <summary> 59 59 + /// This holds the information required to perform a patch at a single locus. 60 60 + /// </summary> 61 61 + /// <param name="Name">The name of this descriptor. Used for logging.</param> 62 62 + /// <param name="Pattern">A list of checks to be used in a MultiTokenWaiter.</param> 63 63 + /// <param name="ScopePattern">A list of checks to be used in a MultiTokenWaiter marking the .</param> 64 64 + /// <param name="Tokens">A list of GDScript tokens which will be patched in.</param> 65 65 + /// <param name="Operation">The type of patch.</param> 66 66 + /// <param name="Times">The number of times this rule is expected to match.</param> 67 67 + /// <param name="Predicate">A predicate which must return true for the rule to match.</param> 68 68 + public record TransformationRule( 69 69 + string Name, 70 70 + MultiTokenPattern Pattern, 71 71 + MultiTokenPattern ScopePattern, 72 72 + IEnumerable<Token> Tokens, 73 73 + Operation Operation, 74 74 + uint Times, 75 75 + Func<bool> Predicate) 76 76 + { 77 77 + 78 78 + public MultiTokenWaiter CreateMultiTokenWaiter() => new(Pattern); 79 79 + 80 80 + public MultiTokenWaiter CreateMultiTokenWaiterForScope() => new(ScopePattern); 81 81 + } 82 82 + 83 83 + /// <summary> 84 84 + /// Builder for TransformationRule. Times defaults to 1. Operation defaults to <see cref="Operation.Append"/>. 85 85 + /// </summary> 86 86 + public class TransformationRuleBuilder 87 87 + { 88 88 + private string? _name; 89 89 + private MultiTokenPattern? _pattern; 90 90 + private MultiTokenPattern _scopePattern = []; 91 91 + private IEnumerable<Token>? _tokens; 92 92 + private uint _times = 1; 93 93 + private Operation _operation = Operation.Append; 94 94 + private Func<bool> _predicate = () => true; 95 95 + 96 96 + /// <summary> 97 97 + /// Sets the name for the TransformationRule. Used for logging. 98 98 + /// </summary> 99 99 + /// <param name="name"></param> 100 100 + /// <returns></returns> 101 101 + public TransformationRuleBuilder Named(string name) 102 102 + { 103 103 + _name = name; 104 104 + return this; 105 105 + } 106 106 + 107 107 + /// <summary> 108 108 + /// Sets the token pattern which will be matched by the TransformationRule. 109 109 + /// </summary> 110 110 + /// <param name="pattern"></param> 111 111 + /// <returns></returns> 112 112 + public TransformationRuleBuilder Matching(MultiTokenPattern pattern) 113 113 + { 114 114 + _pattern = pattern; 115 115 + return this; 116 116 + } 117 117 + 118 118 + /// <summary> 119 119 + /// Sets the token content which will be patched in for the TransformationRule. 120 120 + /// </summary> 121 121 + /// <param name="tokens"></param> 122 122 + /// <returns></returns> 123 123 + public TransformationRuleBuilder With(IEnumerable<Token> tokens) 124 124 + { 125 125 + _tokens = tokens; 126 126 + return this; 127 127 + } 128 128 + 129 129 + /// <summary> 130 130 + /// Sets the token content which will be patched in for the TransformationRule. 131 131 + /// </summary> 132 132 + /// <param name="token"></param> 133 133 + /// <returns></returns> 134 134 + public TransformationRuleBuilder With(Token token) 135 135 + { 136 136 + _tokens = [token]; 137 137 + return this; 138 138 + } 139 139 + 140 140 + /// <summary> 141 141 + /// Sets the token content which will be patched in for the TransformationRule with a GDScript snippet. 142 142 + /// </summary> 143 143 + /// <param name="snippet"></param> 144 144 + /// <param name="indent">The base indentation level for the tokenizer.</param> 145 145 + /// <returns></returns> 146 146 + public TransformationRuleBuilder With(string snippet, uint indent = 0) 147 147 + { 148 148 + _tokens = ScriptTokenizer.Tokenize(snippet, indent); 149 149 + return this; 150 150 + } 151 151 + 152 152 + /// <summary> 153 153 + /// Sets the <see cref="Operation"/> of the TransformationRule. 154 154 + /// </summary> 155 155 + /// <param name="operation"></param> 156 156 + /// <returns></returns> 157 157 + public TransformationRuleBuilder Do(Operation operation) 158 158 + { 159 159 + _operation = operation; 160 160 + return this; 161 161 + } 162 162 + 163 163 + /// <summary> 164 164 + /// Sets the number of times the rule is expected to match. 165 165 + /// </summary> 166 166 + /// <param name="times"></param> 167 167 + /// <returns></returns> 168 168 + public TransformationRuleBuilder ExpectTimes(uint times) 169 169 + { 170 170 + _times = times; 171 171 + return this; 172 172 + } 173 173 + 174 174 + /// <summary> 175 175 + /// Sets the scope of this rule. 176 176 + /// </summary> 177 177 + /// <param name="scopePattern"></param> 178 178 + /// <returns></returns> 179 179 + public TransformationRuleBuilder ScopedTo(MultiTokenPattern scopePattern) 180 180 + { 181 181 + _scopePattern = scopePattern; 182 182 + return this; 183 183 + } 184 184 + 185 185 + /// <summary> 186 186 + /// Sets the predicate function whose return value will decide if this rule will be checked. 187 187 + /// </summary> 188 188 + /// <param name="predicate"></param> 189 189 + /// <returns></returns> 190 190 + public TransformationRuleBuilder When(Func<bool> predicate) 191 191 + { 192 192 + _predicate = predicate; 193 193 + return this; 194 194 + } 195 195 + 196 196 + /// <summary> 197 197 + /// Sets a value which will decide if this rule will be checked. 198 198 + /// </summary> 199 199 + /// <param name="eligible">If true, this rule will be checked.</param> 200 200 + /// <returns></returns> 201 201 + public TransformationRuleBuilder When(bool eligible) 202 202 + { 203 203 + _predicate = () => eligible; 204 204 + return this; 205 205 + } 206 206 + 207 207 + /// <summary> 208 208 + /// Builds the TransformationRule. 209 209 + /// </summary> 210 210 + /// <returns></returns> 211 211 + /// <exception cref="ArgumentNullException">Thrown if any required fields were not set.</exception> 212 212 + public TransformationRule Build() 213 213 + { 214 214 + if (string.IsNullOrEmpty(_name)) 215 215 + { 216 216 + throw new ArgumentNullException(nameof(_name), "Name cannot be null or empty"); 217 217 + } 218 218 + 219 219 + if (_pattern == null) 220 220 + { 221 221 + throw new ArgumentNullException(nameof(_pattern), "Pattern cannot be null"); 222 222 + } 223 223 + 224 224 + if (_tokens == null) 225 225 + { 226 226 + throw new ArgumentNullException(nameof(_tokens), "Tokens cannot be null"); 227 227 + } 228 228 + 229 229 + return new TransformationRule(_name, _pattern, _scopePattern, _tokens, _operation, _times, _predicate); 230 230 + } 231 231 + }

+179

Atproto/CalicoUtils/LexicalTransformer/TransformationRuleScriptMod.cs

··· 1 1 + using GDWeave; 2 2 + using GDWeave.Godot; 3 3 + using GDWeave.Modding; 4 4 + using static Teemaw.Calico.LexicalTransformer.Operation; 5 5 + 6 6 + namespace Teemaw.Calico.LexicalTransformer; 7 7 + 8 8 + /// <summary> 9 9 + /// An IScriptMod implementation that handles patching through the provided list of TransformationRules. 10 10 + /// </summary> 11 11 + /// <param name="mod">IModInterface of the current mod.</param> 12 12 + /// <param name="name">The name of this script mod. Used for logging.</param> 13 13 + /// <param name="scriptPath">The GD res:// path of the script which will be patched.</param> 14 14 + /// <param name="rules">A list of patches to perform. Multiple descriptors with overlapping checks is not supported.</param> 15 15 + public class TransformationRuleScriptMod( 16 16 + IModInterface mod, 17 17 + string name, 18 18 + string scriptPath, 19 19 + Func<bool> predicate, 20 20 + TransformationRule[] rules) 21 21 + : IScriptMod 22 22 + { 23 23 + public bool ShouldRun(string path) 24 24 + { 25 25 + if (path != scriptPath) return false; 26 26 + if (!predicate.Invoke()) 27 27 + { 28 28 + mod.Logger.Information($"[{name}] Predicate failed, not patching."); 29 29 + return false; 30 30 + } 31 31 + 32 32 + return true; 33 33 + } 34 34 + 35 35 + public IEnumerable<Token> Modify(string path, IEnumerable<Token> tokens) 36 36 + { 37 37 + var eligibleRules = rules.Where(rule => 38 38 + { 39 39 + var eligible = rule.Predicate(); 40 40 + if (!eligible) 41 41 + { 42 42 + mod.Logger.Information($"[{name}] Skipping patch {rule.Name}..."); 43 43 + } 44 44 + 45 45 + return eligible; 46 46 + }).ToList(); 47 47 + var transformers = eligibleRules.Select(rule => 48 48 + (Rule: rule, Waiter: rule.CreateMultiTokenWaiter(), Buffer: new List<Token>())) 49 49 + .ToList(); 50 50 + mod.Logger.Information($"[{name}] Patching {path}"); 51 51 + 52 52 + var patchOccurrences = 53 53 + eligibleRules.ToDictionary(r => r.Name, r => (Occurred: 0, Expected: r.Times)); 54 54 + var bufferAfterChecks = true; 55 55 + var stagingBuffer = new List<Token>(); 56 56 + stagingBuffer.AddRange(tokens); 57 57 + var transformedBuffer = new List<Token>(); 58 58 + 59 59 + foreach (var transformer in transformers) 60 60 + { 61 61 + var hasScopePattern = transformer.Rule.ScopePattern.Length > 0; 62 62 + var inScope = !hasScopePattern; 63 63 + uint? scopeIndent = null; 64 64 + var scopeWaiter = transformer.Rule.CreateMultiTokenWaiterForScope(); 65 65 + 66 66 + foreach (var token in stagingBuffer) 67 67 + { 68 68 + if (inScope && hasScopePattern) 69 69 + { 70 70 + // Try to find the scope's base indentation 71 71 + if (scopeIndent == null && token.Type == TokenType.Newline) 72 72 + { 73 73 + scopeIndent = token.AssociatedData ?? 0; 74 74 + } 75 75 + // Check if we should leave the scope 76 76 + else if (scopeIndent != null && token.Type == TokenType.Newline) 77 77 + { 78 78 + inScope = (token.AssociatedData ?? 0) >= scopeIndent; 79 79 + } 80 80 + } 81 81 + else if (hasScopePattern) 82 82 + { 83 83 + // We should never reach this case if the scope pattern has Length = 0. 84 84 + if (scopeWaiter.Check(token)) 85 85 + { 86 86 + scopeWaiter.Reset(); 87 87 + // Latch inScope to true if we match the scope pattern. 88 88 + inScope = true; 89 89 + } 90 90 + } 91 91 + 92 92 + if (!inScope) 93 93 + { 94 94 + transformedBuffer.Add(token); 95 95 + continue; 96 96 + } 97 97 + 98 98 + transformer.Waiter.Check(token); 99 99 + if (transformer.Waiter.Step == 0) 100 100 + { 101 101 + transformedBuffer.AddRange(transformer.Buffer); 102 102 + transformer.Buffer.Clear(); 103 103 + } 104 104 + else 105 105 + { 106 106 + if (transformer.Rule.Operation.RequiresBuffer()) 107 107 + { 108 108 + transformer.Buffer.Add(token); 109 109 + bufferAfterChecks = false; 110 110 + } 111 111 + 112 112 + if (transformer.Waiter.Matched) 113 113 + { 114 114 + transformer.Waiter.Reset(); 115 115 + 116 116 + if (transformer.Rule.Operation.YieldTokenBeforeOperation()) 117 117 + { 118 118 + transformedBuffer.Add(token); 119 119 + bufferAfterChecks = false; 120 120 + } 121 121 + else 122 122 + { 123 123 + bufferAfterChecks = 124 124 + transformer.Rule.Operation.YieldTokenAfterOperation(); 125 125 + } 126 126 + 127 127 + switch (transformer.Rule.Operation) 128 128 + { 129 129 + case Prepend: 130 130 + transformedBuffer.AddRange(transformer.Rule.Tokens); 131 131 + transformedBuffer.AddRange(transformer.Buffer); 132 132 + transformer.Buffer.Clear(); 133 133 + break; 134 134 + case ReplaceLast: 135 135 + case Append: 136 136 + case ReplaceAll: 137 137 + transformer.Buffer.Clear(); 138 138 + transformedBuffer.AddRange(transformer.Rule.Tokens); 139 139 + break; 140 140 + case None: 141 141 + default: 142 142 + break; 143 143 + } 144 144 + 145 145 + mod.Logger.Information( 146 146 + $"[{name}] Patch {transformer.Rule.Name} OK!"); 147 147 + patchOccurrences[transformer.Rule.Name] = 148 148 + patchOccurrences[transformer.Rule.Name] with 149 149 + { 150 150 + Occurred = patchOccurrences[transformer.Rule.Name].Occurred + 1 151 151 + }; 152 152 + } 153 153 + } 154 154 + 155 155 + if (bufferAfterChecks) 156 156 + { 157 157 + transformedBuffer.Add(token); 158 158 + } 159 159 + else 160 160 + { 161 161 + bufferAfterChecks = true; 162 162 + } 163 163 + } 164 164 + 165 165 + stagingBuffer.Clear(); 166 166 + stagingBuffer.AddRange(transformedBuffer); 167 167 + transformedBuffer.Clear(); 168 168 + } 169 169 + 170 170 + foreach (var result in patchOccurrences.Where(result => 171 171 + result.Value.Occurred != result.Value.Expected)) 172 172 + { 173 173 + mod.Logger.Error( 174 174 + $"[{name}] Patch {result.Key} FAILED! Times expected={result.Value.Expected}, actual={result.Value.Occurred}"); 175 175 + } 176 176 + 177 177 + return stagingBuffer; 178 178 + } 179 179 + }

+112

Atproto/CalicoUtils/LexicalTransformer/TransformationRuleScriptModBuilder.cs

··· 1 1 + using GDWeave; 2 2 + 3 3 + namespace Teemaw.Calico.LexicalTransformer; 4 4 + 5 5 + public class TransformationRuleScriptModBuilder 6 6 + { 7 7 + private IModInterface? _mod; 8 8 + private string? _name; 9 9 + private string? _scriptPath; 10 10 + private Func<bool> _predicate = () => true; 11 11 + private List<TransformationRule> _rules = []; 12 12 + 13 13 + /// <summary> 14 14 + /// Sets the IModInterface to be used by the ScriptMod. 15 15 + /// </summary> 16 16 + /// <param name="mod"></param> 17 17 + /// <returns></returns> 18 18 + public TransformationRuleScriptModBuilder ForMod(IModInterface mod) 19 19 + { 20 20 + _mod = mod; 21 21 + return this; 22 22 + } 23 23 + 24 24 + /// <summary> 25 25 + /// Sets the predicate which must return true for this ScriptMod to run. Config options MUST be 26 26 + /// evaluated at patch-time since the environment is not fully known at load-time. Currently, 27 27 + /// this affects mod conflict detection, but there may be other affected features in the future. 28 28 + /// </summary> 29 29 + /// <param name="predicate"></param> 30 30 + /// <returns></returns> 31 31 + public TransformationRuleScriptModBuilder When(Func<bool> predicate) 32 32 + { 33 33 + _predicate = predicate; 34 34 + return this; 35 35 + } 36 36 + 37 37 + /// <summary> 38 38 + /// Sets the name of the ScriptMod. Used for logging. 39 39 + /// </summary> 40 40 + /// <param name="name"></param> 41 41 + /// <returns></returns> 42 42 + public TransformationRuleScriptModBuilder Named(string name) 43 43 + { 44 44 + _name = name; 45 45 + return this; 46 46 + } 47 47 + 48 48 + /// <summary> 49 49 + /// Sets the Godot resource path of the script to be patched. 50 50 + /// </summary> 51 51 + /// <param name="scriptPath"></param> 52 52 + /// <returns></returns> 53 53 + public TransformationRuleScriptModBuilder Patching(string scriptPath) 54 54 + { 55 55 + _scriptPath = scriptPath; 56 56 + return this; 57 57 + } 58 58 + 59 59 + /// <summary> 60 60 + /// Adds a TransformationRule to the TransformationRuleScriptMod. 61 61 + /// </summary> 62 62 + /// <param name="rule"></param> 63 63 + /// <returns></returns> 64 64 + public TransformationRuleScriptModBuilder AddRule(TransformationRule rule) 65 65 + { 66 66 + if (_rules.Select(r => r.Name).Contains(rule.Name)) 67 67 + { 68 68 + throw new InvalidOperationException( 69 69 + $"Another rule with the name '{rule.Name}' already exists!"); 70 70 + } 71 71 + 72 72 + _rules.Add(rule); 73 73 + return this; 74 74 + } 75 75 + 76 76 + /// <summary> 77 77 + /// Adds the TransformationRule built by calling Build() on the provided builder to the TransformationRuleScriptMod. 78 78 + /// </summary> 79 79 + /// <param name="rule"></param> 80 80 + /// <returns></returns> 81 81 + public TransformationRuleScriptModBuilder AddRule(TransformationRuleBuilder rule) 82 82 + { 83 83 + return AddRule(rule.Build()); 84 84 + } 85 85 + 86 86 + /// <summary> 87 87 + /// Build the TransformationRuleScriptMod. 88 88 + /// </summary> 89 89 + /// <returns></returns> 90 90 + /// <exception cref="ArgumentNullException">Thrown if any required fields were not set.</exception> 91 91 + public TransformationRuleScriptMod Build() 92 92 + { 93 93 + if (_mod == null) 94 94 + { 95 95 + throw new ArgumentNullException(nameof(_mod), "Mod cannot be null"); 96 96 + } 97 97 + 98 98 + if (string.IsNullOrEmpty(_name)) 99 99 + { 100 100 + throw new ArgumentNullException(nameof(_name), "Name cannot be null or empty"); 101 101 + } 102 102 + 103 103 + if (string.IsNullOrEmpty(_scriptPath)) 104 104 + { 105 105 + throw new ArgumentNullException(nameof(_scriptPath), 106 106 + "Script path cannot be null or empty"); 107 107 + } 108 108 + 109 109 + return new TransformationRuleScriptMod(_mod, _name, _scriptPath, _predicate, 110 110 + _rules.ToArray()); 111 111 + } 112 112 + }

+507

Atproto/CalicoUtils/Util/ScriptTokenizer.cs

··· 1 1 + // MIT License 2 2 + // 3 3 + // Copyright (c) 2024 NotNite 4 4 + // 5 5 + // Permission is hereby granted, free of charge, to any person obtaining a copy 6 6 + // of this software and associated documentation files (the "Software"), to deal 7 7 + // in the Software without restriction, including without limitation the rights 8 8 + // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 9 + // copies of the Software, and to permit persons to whom the Software is 10 10 + // furnished to do so, subject to the following conditions: 11 11 + // 12 12 + // The above copyright notice and this permission notice shall be included in all 13 13 + // copies or substantial portions of the Software. 14 14 + // 15 15 + // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 16 + // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 17 + // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 18 + // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 19 + // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 20 + // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 21 + // SOFTWARE. 22 22 + 23 23 + using System.Text; 24 24 + using GDWeave.Godot; 25 25 + using GDWeave.Godot.Variants; 26 26 + 27 27 + namespace Teemaw.Calico.Util; 28 28 + 29 29 + /** 30 30 + * This is copied from https://github.com/NotNite/GDWeave/blob/main/GDWeave/Script/ScriptTokenizer.cs since this class 31 31 + * was not made visible. Minor modifications have been made to make it more ergonomic to tokenize snippets. 32 32 + */ 33 33 + public static class ScriptTokenizer { 34 34 + private static readonly Dictionary<string, TokenType> Tokens = new() { 35 35 + {"continue", TokenType.CfContinue}, 36 36 + {"return", TokenType.CfReturn}, 37 37 + {"break", TokenType.CfBreak}, 38 38 + {"match", TokenType.CfMatch}, 39 39 + {"while", TokenType.CfWhile}, 40 40 + {"elif", TokenType.CfElif}, 41 41 + {"else", TokenType.CfElse}, 42 42 + {"pass", TokenType.CfPass}, 43 43 + {"for", TokenType.CfFor}, 44 44 + {"if", TokenType.CfIf}, 45 45 + {"const", TokenType.PrConst}, 46 46 + {"var", TokenType.PrVar}, 47 47 + {"func", TokenType.PrFunction}, 48 48 + {"class", TokenType.PrClass}, 49 49 + {"extends", TokenType.PrExtends}, 50 50 + {"is", TokenType.PrIs}, 51 51 + {"as", TokenType.PrAs}, 52 52 + {"@onready", TokenType.PrOnready}, 53 53 + {"@tool", TokenType.PrTool}, 54 54 + {"@export", TokenType.PrExport}, 55 55 + // CALICO: 56 56 + {"yield", TokenType.PrYield}, 57 57 + 58 58 + {"setget", TokenType.PrSetget}, 59 59 + {"static", TokenType.PrStatic}, 60 60 + 61 61 + {"void", TokenType.PrVoid}, 62 62 + {"enum", TokenType.PrEnum}, 63 63 + {"preload", TokenType.PrPreload}, 64 64 + {"assert", TokenType.PrAssert}, 65 65 + 66 66 + {"signal", TokenType.PrSignal}, 67 67 + {"breakpoint", TokenType.PrBreakpoint}, 68 68 + 69 69 + {"sync", TokenType.PrSync}, 70 70 + {"remote", TokenType.PrRemote}, 71 71 + {"master", TokenType.PrMaster}, 72 72 + {"slave", TokenType.PrSlave}, 73 73 + {"puppet", TokenType.PrPuppet}, 74 74 + 75 75 + {"remotesync", TokenType.PrRemotesync}, 76 76 + {"mastersync", TokenType.PrMastersync}, 77 77 + {"puppetsync", TokenType.PrPuppetsync}, 78 78 + 79 79 + {"\n", TokenType.Newline}, 80 80 + 81 81 + {"PI", TokenType.ConstPi}, 82 82 + {"TAU", TokenType.ConstTau}, 83 83 + {"INF", TokenType.ConstInf}, 84 84 + {"NAN", TokenType.ConstNan}, 85 85 + 86 86 + {"error", TokenType.Error}, 87 87 + {"cursor", TokenType.Cursor}, 88 88 + 89 89 + {"self", TokenType.Self}, 90 90 + 91 91 + {"in", TokenType.OpIn}, 92 92 + 93 93 + {"_", TokenType.Wildcard}, 94 94 + 95 95 + {"[", TokenType.BracketOpen}, 96 96 + {"]", TokenType.BracketClose}, 97 97 + {"{", TokenType.CurlyBracketOpen}, 98 98 + {"}", TokenType.CurlyBracketClose}, 99 99 + 100 100 + {"(", TokenType.ParenthesisOpen}, 101 101 + {")", TokenType.ParenthesisClose}, 102 102 + 103 103 + {",", TokenType.Comma}, 104 104 + {";", TokenType.Semicolon}, 105 105 + {".", TokenType.Period}, 106 106 + {"?", TokenType.QuestionMark}, 107 107 + {":", TokenType.Colon}, 108 108 + {"$", TokenType.Dollar}, 109 109 + {"->", TokenType.ForwardArrow}, 110 110 + 111 111 + {">>=", TokenType.OpAssignShiftRight}, 112 112 + {"<<=", TokenType.OpAssignShiftLeft}, 113 113 + 114 114 + {">>", TokenType.OpShiftRight}, 115 115 + {"<<", TokenType.OpShiftLeft}, 116 116 + 117 117 + {"==", TokenType.OpEqual}, 118 118 + {"!=", TokenType.OpNotEqual}, 119 119 + {"&&", TokenType.OpAnd}, 120 120 + {"||", TokenType.OpOr}, 121 121 + {"!", TokenType.OpNot}, 122 122 + 123 123 + {"+=", TokenType.OpAssignAdd}, 124 124 + {"-=", TokenType.OpAssignSub}, 125 125 + {"*=", TokenType.OpAssignMul}, 126 126 + {"/=", TokenType.OpAssignDiv}, 127 127 + {"%=", TokenType.OpAssignMod}, 128 128 + {"&=", TokenType.OpAssignBitAnd}, 129 129 + {"|=", TokenType.OpAssignBitOr}, 130 130 + {"^=", TokenType.OpAssignBitXor}, 131 131 + 132 132 + {"+", TokenType.OpAdd}, 133 133 + {"-", TokenType.OpSub}, 134 134 + {"*", TokenType.OpMul}, 135 135 + {"/", TokenType.OpDiv}, 136 136 + {"%", TokenType.OpMod}, 137 137 + 138 138 + {"~", TokenType.OpBitInvert}, 139 139 + {"&", TokenType.OpBitAnd}, 140 140 + {"|", TokenType.OpBitOr}, 141 141 + {"^", TokenType.OpBitXor}, 142 142 + 143 143 + {"<=", TokenType.OpLessEqual}, 144 144 + {">=", TokenType.OpGreaterEqual}, 145 145 + {"<", TokenType.OpLess}, 146 146 + {">", TokenType.OpGreater}, 147 147 + 148 148 + {"=", TokenType.OpAssign}, 149 149 + }; 150 150 + 151 151 + private static readonly HashSet<string> Symbols = new() { 152 152 + "->", 153 153 + 154 154 + ">>=", 155 155 + "<<=", 156 156 + 157 157 + ">>", 158 158 + "<<", 159 159 + 160 160 + "==", 161 161 + "!=", 162 162 + "&&", 163 163 + "||", 164 164 + "!", 165 165 + 166 166 + "+=", 167 167 + "-=", 168 168 + "*=", 169 169 + "/=", 170 170 + "%=", 171 171 + "&=", 172 172 + "|=", 173 173 + "^=", 174 174 + 175 175 + "_", 176 176 + 177 177 + "[", 178 178 + "]", 179 179 + 180 180 + "{", 181 181 + "}", 182 182 + 183 183 + "(", 184 184 + ")", 185 185 + 186 186 + ",", 187 187 + ";", 188 188 + ".", 189 189 + "?", 190 190 + ":", 191 191 + "$", 192 192 + "+", 193 193 + "-", 194 194 + "*", 195 195 + "/", 196 196 + "%", 197 197 + 198 198 + "~", 199 199 + "&", 200 200 + "|", 201 201 + "^", 202 202 + 203 203 + "<=", 204 204 + ">=", 205 205 + "<", 206 206 + ">", 207 207 + 208 208 + "=", 209 209 + }; 210 210 + 211 211 + private static readonly List<string> BuiltinFunctions = Enum.GetNames<BuiltinFunction>().ToList(); 212 212 + 213 213 + private static void InsertNewLine(IEnumerator<string> enumerator, uint baseIndent, List<Token> toFlush) { 214 214 + if (!enumerator.MoveNext()) { 215 215 + return; 216 216 + } 217 217 + 218 218 + var tabCount = uint.Parse(enumerator.Current); 219 219 + toFlush.Add(new Token(TokenType.Newline, tabCount + baseIndent)); 220 220 + } 221 221 + 222 222 + private static void BuildIdentifierName(IEnumerator<string> enumerator, List<Token> toFlush, out string? found) { 223 223 + found = string.Empty; 224 224 + if (!enumerator.MoveNext()) { 225 225 + return; 226 226 + } 227 227 + 228 228 + if (enumerator.Current == ":") { 229 229 + toFlush.Add(new Token(TokenType.Wildcard)); 230 230 + toFlush.Add(new Token(TokenType.Semicolon)); 231 231 + return; 232 232 + } 233 233 + 234 234 + found = "_" + enumerator.Current; 235 235 + } 236 236 + 237 237 + private static void BuildNumber(IEnumerator<string> enumerator, List<Token> toFlush, out bool foundFull) { 238 238 + foundFull = true; 239 239 + int sign = 1; 240 240 + 241 241 + if (enumerator.Current == "-") { 242 242 + sign = -1; 243 243 + if (!enumerator.MoveNext()) return; 244 244 + } 245 245 + 246 246 + if (!long.TryParse(enumerator.Current, out long upper)) { 247 247 + toFlush.Add(new Token(TokenType.OpSub)); 248 248 + foundFull = false; 249 249 + return; 250 250 + } 251 251 + 252 252 + if (!enumerator.MoveNext()) return; 253 253 + 254 254 + if (enumerator.Current != ".") { 255 255 + toFlush.Add(new ConstantToken(new IntVariant(upper * sign))); 256 256 + foundFull = false; 257 257 + return; 258 258 + } 259 259 + 260 260 + if (!enumerator.MoveNext()) return; 261 261 + 262 262 + if (!long.TryParse(enumerator.Current, out long lower)) { 263 263 + // I dont think there is really a proper return for here. 264 264 + // You'd have a number that looks like this "1000." 265 265 + // No following decimal 266 266 + // Comment if you had ideas 267 267 + return; 268 268 + } 269 269 + 270 270 + var result = upper + (lower / Math.Pow(10, lower.ToString().Length)); 271 271 + toFlush.Add(new ConstantToken(new RealVariant(result * sign))); 272 272 + } 273 273 + 274 274 + public static IEnumerable<Token> Tokenize(string gdScript, uint baseIndent = 0) { 275 275 + var finalTokens = new List<Token>(); 276 276 + var tokens = SanitizeInput(TokenizeString(gdScript + " ")); 277 277 + 278 278 + var previous = string.Empty; 279 279 + var idName = string.Empty; 280 280 + 281 281 + var toFlush = new List<Token>(2); 282 282 + // CALICO: We don't need this since we're dealing with snippets 283 283 + //finalTokens.Add(new Token(TokenType.Newline, baseIndent)); 284 284 + var enumerator = tokens.GetEnumerator(); 285 285 + var reparse = false; 286 286 + while (reparse ? true : enumerator.MoveNext()) { 287 287 + reparse = false; 288 288 + 289 289 + if (enumerator.Current == "\n") { 290 290 + InsertNewLine(enumerator, baseIndent, toFlush); 291 291 + endAndFlushId(); 292 292 + continue; 293 293 + } 294 294 + 295 295 + if (enumerator.Current == "_") { 296 296 + BuildIdentifierName(enumerator, toFlush, out string? found); 297 297 + if (found == string.Empty) { 298 298 + endAndFlushId(); 299 299 + continue; 300 300 + } 301 301 + 302 302 + idName += found; 303 303 + 304 304 + end(); 305 305 + continue; 306 306 + } 307 307 + 308 308 + //if (enumerator.Current == "-" || char.IsDigit(enumerator.Current[0])) { 309 309 + if (char.IsDigit(enumerator.Current[0])) { 310 310 + BuildNumber(enumerator, toFlush, out bool foundFull); 311 311 + reparse = !foundFull; 312 312 + endAndFlushId(); 313 313 + continue; 314 314 + } 315 315 + 316 316 + if (BuiltinFunctions.Contains(enumerator.Current)) { 317 317 + toFlush.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunctions.IndexOf(enumerator.Current))); 318 318 + endAndFlushId(); 319 319 + continue; 320 320 + } 321 321 + 322 322 + if (Tokens.TryGetValue(enumerator.Current, out var type)) { 323 323 + toFlush.Add(new Token(type)); 324 324 + endAndFlushId(); 325 325 + continue; 326 326 + } 327 327 + 328 328 + if (enumerator.Current.StartsWith('"')) { 329 329 + var current = enumerator.Current; 330 330 + toFlush.Add(new ConstantToken(new StringVariant(current.Substring(1, current.Length - 2)))); 331 331 + endAndFlushId(); 332 332 + continue; 333 333 + } 334 334 + 335 335 + if (bool.TryParse(enumerator.Current, out var resultB)) { 336 336 + toFlush.Add(new ConstantToken(new BoolVariant(resultB))); 337 337 + endAndFlushId(); 338 338 + continue; 339 339 + } 340 340 + 341 341 + idName += enumerator.Current; 342 342 + 343 343 + end(); 344 344 + 345 345 + void end() { 346 346 + previous = enumerator.Current; 347 347 + finalTokens.AddRange(toFlush); 348 348 + toFlush.Clear(); 349 349 + } 350 350 + 351 351 + void endAndFlushId() { 352 352 + if (idName != string.Empty) { 353 353 + if (idName.Trim() == "return") 354 354 + { 355 355 + // CALICO: Hack to handle `return` being the last token of a line 356 356 + finalTokens.Add(new Token(TokenType.CfReturn)); 357 357 + } 358 358 + else if (idName.Trim() == "self") 359 359 + { 360 360 + // CALICO: Hack to handle `self` being the last token of a line 361 361 + finalTokens.Add(new Token(TokenType.Self)); 362 362 + } 363 363 + else switch (idName.Trim()) 364 364 + { 365 365 + // TODO: CALICO: clean up this hack 366 366 + case "print": 367 367 + // CALICO: Without this, `print` is tokenized as an identifier. 368 368 + finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.TextPrint)); 369 369 + break; 370 370 + case "min": 371 371 + // CALICO: Without this, `min` is tokenized as an identifier. 372 372 + finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.LogicMin)); 373 373 + break; 374 374 + case "null": 375 375 + // CALICO: Without this, `null` is tokenized as an identifier. 376 376 + finalTokens.Add(new ConstantToken(new NilVariant())); 377 377 + break; 378 378 + case "break": 379 379 + // CALICO: Without this, `break` is tokenized as an identifier. 380 380 + finalTokens.Add(new Token(TokenType.CfBreak)); 381 381 + break; 382 382 + case "match": 383 383 + // CALICO: Without this, `match` is tokenized as an identifier. 384 384 + finalTokens.Add(new Token(TokenType.CfMatch)); 385 385 + break; 386 386 + case "Color": 387 387 + // CALICO: Without this, `Color` is tokenized as an identifier. 388 388 + finalTokens.Add(new Token(TokenType.BuiltInType, 14)); 389 389 + break; 390 390 + case "Vector3": 391 391 + // CALICO: Without this, `Vector3` is tokenized as an identifier. 392 392 + finalTokens.Add(new Token(TokenType.BuiltInType, 7)); 393 393 + break; 394 394 + case "lerp_angle": 395 395 + // CALICO: Without this, `lerp_angle` is tokenized as an identifier. 396 396 + finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathLerpAngle)); 397 397 + break; 398 398 + case "int": 399 399 + // CALICO: https://docs.godotengine.org/en/3.5/tutorials/io/binary_serialization_api.html 400 400 + finalTokens.Add(new Token(TokenType.BuiltInType, 2)); 401 401 + break; 402 402 + case "pow": 403 403 + // CALICO: 404 404 + finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathPow)); 405 405 + break; 406 406 + case "abs": 407 407 + // CALICO: 408 408 + finalTokens.Add(new Token(TokenType.BuiltInFunc, (uint?) BuiltinFunction.MathAbs)); 409 409 + break; 410 410 + default: 411 411 + // CALICO: We change this to trim the idName, otherwise the whitespace messes with the token 412 412 + finalTokens.Add(new IdentifierToken(idName.Trim())); 413 413 + break; 414 414 + } 415 415 + idName = string.Empty; 416 416 + } 417 417 + 418 418 + end(); 419 419 + } 420 420 + } 421 421 + 422 422 + // CALICO: We don't need this since we're dealing with snippets 423 423 + //finalTokens.Add(new(TokenType.Newline, baseIndent)); 424 424 + 425 425 + foreach (var t in finalTokens) yield return t; 426 426 + } 427 427 + 428 428 + private static IEnumerable<string> SanitizeInput(IEnumerable<string> tokens) { 429 429 + foreach (var token in tokens) { 430 430 + if (token != "\n" && string.IsNullOrWhiteSpace(token)) { 431 431 + continue; 432 432 + } 433 433 + 434 434 + yield return token; 435 435 + } 436 436 + } 437 437 + 438 438 + private static IEnumerable<string> TokenizeString(string text) { 439 439 + StringBuilder builder = new(20); 440 440 + for (var i = 0; i < text.Length; i++) { 441 441 + switch (text[i]) { 442 442 + case '"': { 443 443 + yield return ClearBuilder(); 444 444 + builder.Append('"'); 445 445 + i++; 446 446 + for (; i < text.Length; i++) { 447 447 + builder.Append(text[i]); 448 448 + if (text[i] == '"') { 449 449 + break; 450 450 + } 451 451 + } 452 452 + 453 453 + yield return ClearBuilder(); 454 454 + continue; 455 455 + } 456 456 + 457 457 + // This is stupid and awful 458 458 + case '\n': { 459 459 + yield return ClearBuilder(); 460 460 + var start = i; 461 461 + i++; 462 462 + for (; i < text.Length && text[i] == '\t'; i++) ; 463 463 + i--; 464 464 + yield return "\n"; 465 465 + yield return $"{i - start}"; 466 466 + continue; 467 467 + } 468 468 + } 469 469 + 470 470 + var matched = false; 471 471 + foreach (var delimiter in Symbols) { 472 472 + if (Match(text, i, delimiter)) { 473 473 + yield return ClearBuilder(); 474 474 + yield return delimiter; 475 475 + i += delimiter.Length - 1; 476 476 + matched = true; 477 477 + break; 478 478 + } 479 479 + } 480 480 + 481 481 + if (matched) continue; 482 482 + 483 483 + if (text[i] == ' ') { 484 484 + yield return ClearBuilder(); 485 485 + continue; 486 486 + } 487 487 + 488 488 + builder.Append(text[i]); 489 489 + } 490 490 + 491 491 + yield return "\n"; 492 492 + 493 493 + string ClearBuilder() { 494 494 + var built = builder.ToString(); 495 495 + builder.Clear(); 496 496 + return built; 497 497 + } 498 498 + } 499 499 + 500 500 + private static bool Match(string text, int index, string match) { 501 501 + if (index + match.Length > text.Length) return false; 502 502 + for (var i = 0; i < match.Length; i++) { 503 503 + if (text[index + i] != match[i]) return false; 504 504 + } 505 505 + return true; 506 506 + } 507 507 + }

+131

Atproto/CalicoUtils/Util/TokenUtil.cs

··· 1 1 + using GDWeave.Godot; 2 2 + using GDWeave.Godot.Variants; 3 3 + using static GDWeave.Godot.TokenType; 4 4 + 5 5 + namespace Teemaw.Calico.Util; 6 6 + 7 7 + public static class TokenUtil 8 8 + { 9 9 + public static IEnumerable<Token> ReplaceAssignmentsAsDeferred(IEnumerable<Token> tokens, 10 10 + HashSet<string>? ignoredIdentifiers = null) 11 11 + { 12 12 + Token? lastToken = null; 13 13 + var inAssignmentStatement = false; 14 14 + var skipLine = false; 15 15 + foreach (var t in tokens) 16 16 + { 17 17 + switch (t) 18 18 + { 19 19 + case { Type: Newline }: 20 20 + skipLine = false; 21 21 + break; 22 22 + case { Type: PrVar }: 23 23 + skipLine = true; 24 24 + break; 25 25 + default: 26 26 + { 27 27 + if (lastToken is IdentifierToken identifier && 28 28 + (ignoredIdentifiers == null || !ignoredIdentifiers.Contains(identifier.Name)) && 29 29 + t is { Type: OpAssign } && !skipLine) 30 30 + { 31 31 + inAssignmentStatement = true; 32 32 + yield return new IdentifierToken("set_deferred"); 33 33 + yield return new Token(ParenthesisOpen); 34 34 + yield return new ConstantToken(new StringVariant(identifier.Name)); 35 35 + yield return new Token(Comma); 36 36 + // Don't return the last token or current token 37 37 + lastToken = null; 38 38 + continue; 39 39 + } 40 40 + 41 41 + break; 42 42 + } 43 43 + } 44 44 + 45 45 + if (t.Type == Newline && inAssignmentStatement) 46 46 + { 47 47 + inAssignmentStatement = false; 48 48 + if (lastToken != null) 49 49 + yield return lastToken; 50 50 + // Close out the set_deferred call... 51 51 + yield return new Token(ParenthesisClose); 52 52 + // ...before the Newline token. 53 53 + yield return t; 54 54 + } 55 55 + else if (lastToken != null) 56 56 + yield return lastToken; 57 57 + 58 58 + lastToken = inAssignmentStatement && t is { Type: Identifier } ? StripAssociatedData(t) : t; 59 59 + } 60 60 + 61 61 + if (lastToken != null) 62 62 + yield return lastToken; 63 63 + } 64 64 + 65 65 + public static Token ReplaceToken(Token cursor, Token target, Token replacement) 66 66 + { 67 67 + return TokenEquals(cursor, target) ? replacement : cursor; 68 68 + } 69 69 + 70 70 + public static IEnumerable<Token> ReplaceTokens(IEnumerable<Token> haystack, IEnumerable<Token> needle, 71 71 + IEnumerable<Token> replacements) 72 72 + { 73 73 + var haystackList = haystack.ToList(); 74 74 + var needleList = needle.ToList(); 75 75 + var replacementsList = replacements.ToList(); 76 76 + 77 77 + if (needleList.Count == 0) return haystackList; 78 78 + 79 79 + var result = new List<Token>(); 80 80 + var i = 0; 81 81 + 82 82 + while (i < haystackList.Count) 83 83 + { 84 84 + if (IsMatch(haystackList, needleList, i)) 85 85 + { 86 86 + result.AddRange(replacementsList); 87 87 + i += needleList.Count; 88 88 + } 89 89 + else 90 90 + { 91 91 + result.Add(haystackList[i]); 92 92 + i++; 93 93 + } 94 94 + } 95 95 + 96 96 + return result; 97 97 + } 98 98 + 99 99 + private static bool IsMatch(List<Token> haystack, List<Token> needle, int startIndex) 100 100 + { 101 101 + if (startIndex + needle.Count > haystack.Count) 102 102 + return false; 103 103 + 104 104 + for (int i = 0; i < needle.Count; i++) 105 105 + { 106 106 + if (!TokenEquals(haystack[startIndex + i], needle[i])) 107 107 + return false; 108 108 + } 109 109 + 110 110 + return true; 111 111 + } 112 112 + 113 113 + private static bool TokenEquals(Token token, Token token1) 114 114 + { 115 115 + if (token is IdentifierToken id && token1 is IdentifierToken id1) 116 116 + { 117 117 + return id.Name == id1.Name; 118 118 + } 119 119 + if (token is ConstantToken constant && token1 is ConstantToken constant1) 120 120 + { 121 121 + return constant.Value.Equals(constant1.Value); 122 122 + } 123 123 + return token.Type == token1.Type && token.AssociatedData == token1.AssociatedData; 124 124 + } 125 125 + 126 126 + private static Token StripAssociatedData(Token token) 127 127 + { 128 128 + token.AssociatedData = null; 129 129 + return token; 130 130 + } 131 131 + }

+9

Atproto/CalicoUtils/Util/WeaveUtil.cs

··· 1 1 + using GDWeave; 2 2 + 3 3 + namespace Teemaw.Calico.Util; 4 4 + 5 5 + public static class WeaveUtil 6 6 + { 7 7 + public static bool IsModLoaded(IModInterface modInterface, string modName) => 8 8 + modInterface.LoadedMods.Contains(modName); 9 9 + }

+22

Atproto/CatchFishFactory.cs

··· 1 1 + using GDWeave; 2 2 + using GDWeave.Modding; 3 3 + using Teemaw.Calico.LexicalTransformer; 4 4 + 5 5 + namespace Atproto; 6 6 + 7 7 + public static class CatchFishFactory 8 8 + { 9 9 + public static IScriptMod Create(IModInterface mod) 10 10 + { 11 11 + return new TransformationRuleScriptModBuilder() 12 12 + .ForMod(mod) 13 13 + .Named("CatchFish") 14 14 + .Patching("res://Scenes/Entities/Player/player.gdc") 15 15 + .AddRule(new TransformationRuleBuilder() 16 16 + .Named("create_fish_record") 17 17 + .Matching(TransformationPatternFactory.CreateGdSnippetPattern( 18 18 + "PlayerData._log_item(fish_roll, size, quality)\n", 3)) 19 19 + .Do(Operation.Append) 20 20 + .With("$\"/root/Atproto\".AtProtoClient.catch_fish(fish_roll, size, quality)\n", 3)).Build(); 21 21 + } 22 22 + }

+22

Atproto/CatptureFishFactory.cs

··· 1 1 + using GDWeave; 2 2 + using GDWeave.Modding; 3 3 + using Teemaw.Calico.LexicalTransformer; 4 4 + 5 5 + namespace Atproto; 6 6 + 7 7 + public static class CatptureFishFactory 8 8 + { 9 9 + public static IScriptMod Create(IModInterface mod) 10 10 + { 11 11 + return new TransformationRuleScriptModBuilder() 12 12 + .ForMod(mod) 13 13 + .Named("CaptureFish") 14 14 + .Patching("res://Scenes/Entities/Props/fish_trap.gdc") 15 15 + .AddRule(new TransformationRuleBuilder() 16 16 + .Named("create_fish_record") 17 17 + .Matching(TransformationPatternFactory.CreateGdSnippetPattern( 18 18 + "PlayerData._log_item(fish_roll, size, quality)\n", 1)) 19 19 + .Do(Operation.Append) 20 20 + .With("$\"/root/Atproto\".AtProtoClient.catch_fish(fish_roll, size, quality)\n", 1)).Build(); 21 21 + } 22 22 + }

+8

Atproto/Config.cs

··· 1 1 + using System.Text.Json.Serialization; 2 2 + 3 3 + namespace Atproto; 4 4 + 5 5 + public class Config { 6 6 + [JsonInclude] public string Handle = ""; 7 7 + [JsonInclude] public string Password = ""; 8 8 + }

+17

Atproto/Mod.cs

··· 1 1 + using GDWeave; 2 2 + 3 3 + namespace Atproto; 4 4 + 5 5 + public class Mod : IMod { 6 6 + public Config Config; 7 7 + 8 8 + public Mod(IModInterface modInterface) { 9 9 + Config = modInterface.ReadConfig<Config>(); 10 10 + modInterface.RegisterScriptMod(CatchFishFactory.Create(modInterface)); 11 11 + modInterface.RegisterScriptMod(CatptureFishFactory.Create(modInterface)); 12 12 + } 13 13 + 14 14 + public void Dispose() { 15 15 + // Cleanup anything you do here 16 16 + } 17 17 + }

+14

Atproto/manifest.json

··· 1 1 + { 2 2 + "Id": "Atproto", 3 3 + "AssemblyPath": "Atproto.dll", 4 4 + "Metadata": { 5 5 + "Name": "Atproto Webfishing", 6 6 + "Author": "Estym", 7 7 + "Version": "1.0.0", 8 8 + "Description": "This is a sample mod." 9 9 + }, 10 10 + "PackPath": "atproto.pck", 11 11 + "Dependencies": [ 12 12 + "TackleBox" 13 13 + ] 14 14 + }

+15

README.md

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

-1

gdscript/.import/.gdignore

··· 1 1 -

+13 -21

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

··· 1 1 extends Node 2 2 - class_name AtProto 3 2 4 3 # AtProto 5 4 var did 6 5 var pds 7 7 - 8 6 var accessJwt 9 7 var refreshJwt 10 8 ··· 13 11 var requester: HTTPRequest 14 12 15 13 func _enter_tree(): 16 16 - var root = get_tree().get_root() 17 17 - var instance = root.get_node("AtProto") 18 18 - self.name = "AtProto" 19 19 - if instance == null: 20 20 - root.add_child(self, true) 21 21 - self.requester = HTTPRequest.new() 22 22 - self.add_child(self.requester, true) 14 14 + self.requester = HTTPRequest.new() 15 15 + self.add_child(self.requester, true) 23 16 24 17 func is_token_expired() -> bool: 25 18 var json = Marshalls.base64_to_utf8(self.accessJwt.split(".")[1]) ··· 127 120 128 121 129 122 ###################### 130 130 - # STATIC CALLS # 123 123 + # Method Calls # 131 124 ###################### 132 125 133 133 - static func catch_fish(node, fish, size, quality): 134 134 - # var fish_data = Globals.item_data[fish]["file"] 135 135 - # var record = { 136 136 - # at_type = "dev.regnault.webfishing.fish", 137 137 - # id = fish, 138 138 - # name = fish_data.item_name, 139 139 - # size = str(size), 140 140 - # quality = quality 141 141 - # } 142 142 - # node.get_tree().get_root().get_node("AtProto").create_record(record) 143 143 - pass 126 126 + func catch_fish(fish, size, quality): 127 127 + var fish_data = Globals.item_data[fish]["file"] 128 128 + var record = { 129 129 + at_type = "dev.regnault.webfishing.fish", 130 130 + id = fish, 131 131 + name = fish_data.item_name, 132 132 + size = str(size), 133 133 + quality = quality 134 134 + } 135 135 + create_record(record)

-5

gdscript/mods/AtProto/main.gd

··· 1 1 - extends Node 2 2 - 3 3 - func _enter_tree(): 4 4 - var at_proto = AtProto.new() 5 5 - get_tree().root.add_node(at_proto)

+36

gdscript/mods/Atproto/main.gd

··· 1 1 + extends Node 2 2 + 3 3 + var config: Dictionary 4 4 + var default_config: Dictionary = {} 5 5 + 6 6 + onready var TackleBox := $"/root/TackleBox" 7 7 + const AtProtoClient_t := preload("res://mods/Atproto/atproto_client.gd") 8 8 + var AtProtoClient: AtProtoClient_t 9 9 + 10 10 + func _enter_tree(): 11 11 + AtProtoClient = AtProtoClient_t.new() 12 12 + add_child(AtProtoClient) 13 13 + 14 14 + func _ready() -> void: 15 15 + TackleBox.connect("mod_config_updated", self, "_on_config_update") 16 16 + _init_config() 17 17 + 18 18 + func _init_config(): 19 19 + var saved_config = TackleBox.get_mod_config(name) 20 20 + for key in default_config.keys(): 21 21 + if not saved_config[key]: 22 22 + saved_config[key] = default_config[key] 23 23 + config = saved_config 24 24 + TackleBox.set_mod_config(name, config) 25 25 + if config.Handle != "" and config.Password != "": 26 26 + AtProtoClient.login(config.Handle, config.Password) 27 27 + 28 28 + 29 29 + func _on_config_update(mod_id: String, new_config: Dictionary) -> void: 30 30 + if mod_id != name: 31 31 + return 32 32 + if config.hash() == new_config.hash(): 33 33 + return 34 34 + config = new_config 35 35 + if config.Handle != "" and config.Password != "": 36 36 + AtProtoClient.login(config.Handle, config.Password)

+1 -11

gdscript/project.godot

··· 8 8 9 9 config_version=4 10 10 11 11 - _global_script_classes=[ { 12 12 - "base": "Node", 13 13 - "class": "AtProto", 14 14 - "language": "GDScript", 15 15 - "path": "res://mods/AtProto/atproto.gd" 16 16 - } ] 17 17 - _global_script_class_icons={ 18 18 - "AtProto": "" 19 19 - } 20 20 - 21 11 [application] 22 12 23 23 - config/name="Webfishing AtProto" 13 13 + config/name="AtProto Webfishing" 24 14 25 15 [gui] 26 16