Sublime Text LSP support

[setanarut]

Sublime Text GDscript LSP should be officially supported.
https://lsp.sublimetext.io/language_servers/

[Calinou]

I haven't found any LSP client add-on for Sublime Text, but anyone is free to create such an extension that interacts with the editor's language server 🙂

I've found an extension for syntax highlighting, but that's all: https://github.com/beefsack/GDScript-sublime

[martinlindelof]

should be officially supported.
Just tested it, works fine. You have to just add client in LSP.sublime-settings and then make sure Godot is running. When I saved settings file it started my game project, after that I had linting and err check. What's nice is that there's not that much auto-completion. Now I have to just figure out how to run current scene in godot from sublimetext

[dwexel]

hey this is old but in case anyone's looking, here's some code for running an arbitrary scene, based on documentation here

class RunASceneCommand(sublime_plugin.WindowCommand):
    encoding = 'utf-8'
    proc = None
    panel = None
    panel_lock = threading.Lock()

    open_projects = []
    open_scenes = []
    project_parent = ""

    def is_enabled(self, kill=False):
        if kill:
            return self.proc is not None and self.proc.poll() is None
        return True

    def run(self, kill=False):
        if kill:
            if self.proc:
                self.killed = True
                self.proc.terminate()
            return

        with self.panel_lock:
            self.panel = self.window.create_output_panel('exec')
            self.window.run_command('show_panel', {'panel': 'output.exec'})

        # get projects
        self.open_projects = []
        for folder in self.window.folders():
            project_files = Path(folder).rglob('project.godot')
            for p in project_files:
                self.open_projects.append([str(p.name), str(p)])

        if len(self.open_projects) > 1:
            self.window.show_quick_panel(self.open_projects, self.on_select_project)
        elif len(self.open_projects) == 1:
            self.on_select_project(0)


    def on_select_project(self, index):
        if index == -1:
            return    

        project_path = Path(self.open_projects[index][1])
        project_parent = Path(project_path).parent
        self.project_parent = project_parent

        self.open_scenes = []
        self.open_scenes.append(['<Main Scene>', ''])
        for p in project_parent.rglob('*.tscn'):
            self.open_scenes.append([str(p.name), str(p)])

        self.window.show_quick_panel(self.open_scenes, self.on_select_scene)

    def on_select_scene(self, index):
        if index == -1:
            return    

        if index == 0:
            args = ['godot']

        else:
            scene_path = Path(self.open_scenes[index][1])
            scene_path = scene_path.relative_to(self.project_parent)

            args = ['godot', str(scene_path)]

        self.do_write(str(self.project_parent))
        self.do_write(str(args))
        self.do_write('\n')

        if self.proc is not None:
            self.proc.terminate()
            self.proc = None

        self.proc = subprocess.Popen(
            args,
            stdout = subprocess.PIPE,
            stderr = subprocess.STDOUT,
            cwd = str(self.project_parent)
        )
    
        self.killed = False

        threading.Thread(
            target = self.read_handle,
            args = (self.proc.stdout,)
        ).start()


    def read_handle(self, handle):
        chunk_size = 2 ** 13
        out = b''
        while True:
            try:
                data = os.read(handle.fileno(), chunk_size)
                out += data
                if len(data) == chunk_size:
                    continue
                if data == b'' and out == b'':
                    raise IOError('EOF')
                self.queue_write(out.decode(self.encoding))
                if data == b'':
                    raise IOError('EOF')
                out = b''
            except (UnicodeDecodeError) as e:
                self.queue_write(f"Error decoding output using {self.encoding} - {str(e)}")
                break
            except (IOError):
                self.queue_write("\n[Finished]")
                break

    def queue_write(self, text):
        sublime.set_timeout(lambda: self.do_write(text), 1)

    def do_write(self, text):
        with self.panel_lock:
            self.panel.run_command('append', {'characters': text})