Remove UdonToolkit dependency; upgrade CI/CD and VPM environment; add udonsharp-lint CI

.config/dotnet-tools.json

@@ -0,0 +1,12 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "tktco.udonsharplinter": {
+      "version": "0.3.1",
+      "commands": [
+        "udonsharp-lint"
+      ]
+    }
+  }
+}

.github/workflows/check.yml

@@ -0,0 +1,39 @@
+name: Check
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  static-checks:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "22"
+      - uses: reviewdog/action-actionlint@v1
+        with:
+          fail_level: error
+      - name: Run static checks
+        run: bash scripts/run-static-checks.sh
+
+  udonsharp-lint:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: |
+            8.0.x
+            6.0.x
+      - name: Restore dotnet tools
+        run: dotnet tool restore
+      - name: Run UdonSharp Linter
+        run: dotnet tool run udonsharp-lint Packages

.github/workflows/release.yml

@@ -4,8 +4,8 @@ jobs:
   release:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: lts/*
       - run: npm ci

.github/workflows/udonsharp-lint.yml

@@ -0,0 +1,26 @@
+name: UdonSharp Lint
+on:
+  push:
+    paths:
+      - "Packages/**/*.cs"
+      - ".config/dotnet-tools.json"
+      - ".github/workflows/udonsharp-lint.yml"
+  pull_request:
+    paths:
+      - "Packages/**/*.cs"
+      - ".config/dotnet-tools.json"
+      - ".github/workflows/udonsharp-lint.yml"
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v4
+        with:
+          dotnet-version: "6.x"
+      - name: Restore dotnet tools
+        run: dotnet tool restore
+      - name: Run UdonSharp Linter
+        run: dotnet tool run udonsharp-lint Packages

.releaserc.yml

@@ -1,5 +1,12 @@
+branches:
+  - main
+  - master
+  - name: alpha
+    prerelease: true
+
 plugins:
   - semantic-release-gitmoji
-  - "@semantic-release/npm"
+  - - "@semantic-release/npm"
+    - npmPublish: false
   - "@semantic-release/github"
   - "@semantic-release/git"

Packages/jp.virtualaviation.virtual-cns/ATIS/Scripts/ATISGenerator.cs

@@ -1,7 +1,6 @@
 
 using System;
 using UdonSharp;
-using UdonToolkit;
 using UnityEngine;
 using VRC.Udon;
 
@@ -15,8 +14,7 @@ public class ATISGenerator : UdonSharpBehaviour
         readonly private char[] trimChars = new[] { '[', ']', ',', '.', ' ' };
 
         [TextArea] public string template = "AERODROME information [{0}] [{1}] [Z]. {2}. wind {3}. visibility 10 kilometers, sky clear. temperature [25], dewpoint [20], qnh [2992]. advise you have information [{0}]";
-        [ListView("Runway Operations")] public float[] windHeadings = { 0.0f, 180.0f };
-        [ListView("Runway Operations")]
+        public float[] windHeadings = { 0.0f, 180.0f };
         public string[] runwayTemplates = {
             "ils runway [36] approach. using runway [36]",
             "ils runway [18] approach. using runway [18]",
@@ -26,14 +24,14 @@ public class ATISGenerator : UdonSharpBehaviour
         public string windWithGustTemplate = "[{0:000}] degrees {1:0} knots, maximum {2:0} knots";
 
         public UdonSharpBehaviour windSource;
-        [Popup("programVariable", "@windSource", "vector")] public string windVariableName = "Wind";
-        [Popup("programVariable", "@windSource", "float")] public string windGustVariableName = "WindGustStrength";
+        public string windVariableName = "Wind";
+        public string windGustVariableName = "WindGustStrength";
         [Tooltip("Knots")] public float minWind = 0.5f;
 
         public AudioClip[] digits = { }, phonetics = { };
         public AudioClip periodInterval, repeatInterval;
-        [ListView("Vocabulary")] public string[] clipWords = { };
-        [ListView("Vocabulary")] public AudioClip[] clips = { };
+        public string[] clipWords = { };
+        public AudioClip[] clips = { };
 
         private float magneticDeclination;
         private int informationIndex;
@@ -47,6 +45,14 @@ private void Start()
 
         public AudioClip[] _Generate()
         {
+            var runwayOperationCount = GetRunwayOperationCount();
+            if (runwayOperationCount == 0)
+            {
+                Debug.LogError("[Virtual-CNS][ATIS] No runway operations configured. Fix the ATISGenerator inspector setup. Reusing the previous ATIS sequence if available.", gameObject);
+                if (words != null && words.Length > 0) return words;
+                return repeatInterval ? new[] { repeatInterval } : Array.Empty<AudioClip>();
+            }
+
             var now = DateTime.UtcNow;
             var hour = now.Hour;
             var minute = now.Minute / 30 * 30;
@@ -67,7 +73,9 @@ public AudioClip[] _Generate()
             var maxWindSpeed = windSpeed + Mathf.RoundToInt(windGustStrength * KNOTS);
 
             var windString = windCalm ? "calm" : string.Format(gusty ? windWithGustTemplate : windTemplate, new object[] { windHeading, windSpeed, maxWindSpeed });
-            var runwayOperationIndex = windCalm ? defaultRunwayIndex : IndexOfRunwayOperation(windHeading);
+            var runwayOperationIndex = windCalm
+                ? Mathf.Clamp(defaultRunwayIndex, 0, runwayOperationCount - 1)
+                : IndexOfRunwayOperation(windHeading, runwayOperationCount);
 
             var rawText = string.Format(template, (char)('A' + informationIndex), timestamp, runwayTemplates[runwayOperationIndex], windString);
             Debug.Log($"[Virtual-CNS][ATIS] Encoding: {rawText}");
@@ -78,6 +86,11 @@ public AudioClip[] _Generate()
             foreach (var rawWord in rawWords)
             {
                 var word = rawWord.Trim(trimChars);
+                if (string.IsNullOrEmpty(word))
+                {
+                    period = rawWord.EndsWith(".");
+                    continue;
+                }
                 var chars = word.ToCharArray();
                 var firstChar = chars[0];
 
@@ -173,12 +186,20 @@ private AudioClip GetPhoneticClip(char c)
             return phonetics[c - 'A'];
         }
 
-        private int IndexOfRunwayOperation(float windHeading)
+        private int GetRunwayOperationCount()
         {
+            if (windHeadings == null || runwayTemplates == null) return 0;
+            return Mathf.Min(windHeadings.Length, runwayTemplates.Length);
+        }
+
+        private int IndexOfRunwayOperation(float windHeading, int runwayOperationCount)
+        {
+            if (runwayOperationCount <= 0) return 0;
+
             var minDifference = float.MaxValue;
             var minIndex = 0;
 
-            for (var i = 0; i < windHeadings.Length; i++)
+            for (var i = 0; i < runwayOperationCount; i++)
             {
                 var difference = Mathf.Abs(Mathf.DeltaAngle(windHeading, windHeadings[i]));
                 if (difference < minDifference)

Packages/jp.virtualaviation.virtual-cns/ATIS/Scripts/ATISGeneratorEditor.cs

@@ -0,0 +1,176 @@
+#if !COMPILER_UDONSHARP && UNITY_EDITOR
+using UdonSharpEditor;
+using UnityEditor;
+using UnityEngine;
+
+namespace VirtualCNS
+{
+    [CustomEditor(typeof(ATISGenerator))]
+    public class ATISGeneratorEditor : Editor
+    {
+        private SerializedProperty template;
+        private SerializedProperty windHeadings;
+        private SerializedProperty runwayTemplates;
+        private SerializedProperty defaultRunwayIndex;
+        private SerializedProperty windTemplate;
+        private SerializedProperty windWithGustTemplate;
+        private SerializedProperty windSource;
+        private SerializedProperty windVariableName;
+        private SerializedProperty windGustVariableName;
+        private SerializedProperty minWind;
+        private SerializedProperty digits;
+        private SerializedProperty phonetics;
+        private SerializedProperty periodInterval;
+        private SerializedProperty repeatInterval;
+        private SerializedProperty clipWords;
+        private SerializedProperty clips;
+
+        private void OnEnable()
+        {
+            template = serializedObject.FindProperty(nameof(ATISGenerator.template));
+            windHeadings = serializedObject.FindProperty(nameof(ATISGenerator.windHeadings));
+            runwayTemplates = serializedObject.FindProperty(nameof(ATISGenerator.runwayTemplates));
+            defaultRunwayIndex = serializedObject.FindProperty(nameof(ATISGenerator.defaultRunwayIndex));
+            windTemplate = serializedObject.FindProperty(nameof(ATISGenerator.windTemplate));
+            windWithGustTemplate = serializedObject.FindProperty(nameof(ATISGenerator.windWithGustTemplate));
+            windSource = serializedObject.FindProperty(nameof(ATISGenerator.windSource));
+            windVariableName = serializedObject.FindProperty(nameof(ATISGenerator.windVariableName));
+            windGustVariableName = serializedObject.FindProperty(nameof(ATISGenerator.windGustVariableName));
+            minWind = serializedObject.FindProperty(nameof(ATISGenerator.minWind));
+            digits = serializedObject.FindProperty(nameof(ATISGenerator.digits));
+            phonetics = serializedObject.FindProperty(nameof(ATISGenerator.phonetics));
+            periodInterval = serializedObject.FindProperty(nameof(ATISGenerator.periodInterval));
+            repeatInterval = serializedObject.FindProperty(nameof(ATISGenerator.repeatInterval));
+            clipWords = serializedObject.FindProperty(nameof(ATISGenerator.clipWords));
+            clips = serializedObject.FindProperty(nameof(ATISGenerator.clips));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            UdonSharpGUI.DrawDefaultUdonSharpBehaviourHeader(target);
+
+            serializedObject.Update();
+
+            EditorGUILayout.PropertyField(template);
+            EditorGUILayout.Space();
+
+            DrawRunwayOperations();
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Wind Source", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(windSource);
+            EditorGUILayout.PropertyField(windVariableName);
+            EditorGUILayout.PropertyField(windGustVariableName);
+            EditorGUILayout.PropertyField(minWind);
+            EditorGUILayout.PropertyField(windTemplate);
+            EditorGUILayout.PropertyField(windWithGustTemplate);
+
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Audio Tables", EditorStyles.boldLabel);
+            EditorGUILayout.PropertyField(digits, true);
+            EditorGUILayout.PropertyField(phonetics, true);
+            EditorGUILayout.PropertyField(periodInterval);
+            EditorGUILayout.PropertyField(repeatInterval);
+
+            EditorGUILayout.Space();
+            DrawClipTable();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+
+        private void DrawRunwayOperations()
+        {
+            EditorGUILayout.LabelField("Runway Operations", EditorStyles.boldLabel);
+
+            var count = DrawCountField("Operation Count", 1, windHeadings, runwayTemplates);
+            var effectiveCount = Mathf.Min(windHeadings.arraySize, runwayTemplates.arraySize);
+            if (effectiveCount == 0)
+            {
+                EditorGUILayout.HelpBox("Add at least one runway operation. ATIS generation is blocked until this is fixed.", MessageType.Error);
+                defaultRunwayIndex.intValue = 0;
+                if (GUILayout.Button("Create Default Runway Operation"))
+                {
+                    ResizeArrays(1, windHeadings, runwayTemplates);
+                    windHeadings.GetArrayElementAtIndex(0).floatValue = 0.0f;
+                    runwayTemplates.GetArrayElementAtIndex(0).stringValue = "runway operation unavailable";
+                }
+                return;
+            }
+
+            if (effectiveCount != count)
+            {
+                EditorGUILayout.HelpBox("Only the overlapping runway operation entries are active until the backing arrays are normalized.", MessageType.Warning);
+                if (GUILayout.Button("Normalize Runway Operation Arrays"))
+                {
+                    ResizeArrays(count, windHeadings, runwayTemplates);
+                    effectiveCount = count;
+                }
+            }
+
+            defaultRunwayIndex.intValue = Mathf.Clamp(defaultRunwayIndex.intValue, 0, effectiveCount - 1);
+            defaultRunwayIndex.intValue = EditorGUILayout.IntSlider("Default Runway Index", defaultRunwayIndex.intValue, 0, effectiveCount - 1);
+
+            for (var i = 0; i < effectiveCount; i++)
+            {
+                using (new EditorGUILayout.VerticalScope(EditorStyles.helpBox))
+                {
+                    EditorGUILayout.LabelField($"Operation {i}", EditorStyles.boldLabel);
+                    EditorGUILayout.PropertyField(windHeadings.GetArrayElementAtIndex(i), new GUIContent("Wind Heading"));
+                    EditorGUILayout.PropertyField(runwayTemplates.GetArrayElementAtIndex(i), new GUIContent("Runway Template"));
+                }
+            }
+        }
+
+        private void DrawClipTable()
+        {
+            EditorGUILayout.LabelField("Word Clips", EditorStyles.boldLabel);
+
+            var count = DrawCountField("Clip Count", 0, clipWords, clips);
+
+            for (var i = 0; i < count; i++)
+            {
+                using (new EditorGUILayout.HorizontalScope())
+                {
+                    EditorGUILayout.PropertyField(clipWords.GetArrayElementAtIndex(i), GUIContent.none);
+                    EditorGUILayout.PropertyField(clips.GetArrayElementAtIndex(i), GUIContent.none);
+                }
+            }
+        }
+
+        private static int DrawCountField(string label, int minimumSize, params SerializedProperty[] properties)
+        {
+            var minSize = int.MaxValue;
+            var maxSize = 0;
+            for (var i = 0; i < properties.Length; i++)
+            {
+                minSize = Mathf.Min(minSize, properties[i].arraySize);
+                maxSize = Mathf.Max(maxSize, properties[i].arraySize);
+            }
+
+            if (minSize == int.MaxValue) minSize = 0;
+
+            if (minSize != maxSize)
+            {
+                EditorGUILayout.HelpBox($"{label} backing arrays are out of sync. Adjust the count to normalize them.", MessageType.Info);
+            }
+
+            var requestedSize = Mathf.Max(minimumSize, EditorGUILayout.IntField(label, Mathf.Max(minimumSize, maxSize)));
+            if (requestedSize != maxSize)
+            {
+                ResizeArrays(requestedSize, properties);
+                return requestedSize;
+            }
+
+            return minSize;
+        }
+
+        private static void ResizeArrays(int size, params SerializedProperty[] properties)
+        {
+            for (var i = 0; i < properties.Length; i++)
+            {
+                properties[i].arraySize = size;
+            }
+        }
+    }
+}
+#endif