Trying out a new editor

Today, we talk about something a bit different, editor workflow! Sounds amazing, doesn't it?
I'm sure some of you can appreciate a little insight into how I work with lua and jbeam though.

Let's speak first about what tools I've used in the past for the majority of work for BeamNG:

• Zerobrane IDE (https://studio.zerobrane.com/)
• Notepad++ (https://notepad-plus-plus.org/)

The Zerobrane IDE is a very nice tool to work with lua, it supports all the nice stuff like syntax highlighting, auto formatting, linting, code outlines etc. All in all a very useful piece of software and what I have used in the past 3 or so years. (It also supports debugging lua with breakpoints and all, but that usually isn't all that helpful with the kind of work I do)
Here's a typical screenshot:


The second tool, Notepad++, is something literally everyone should have on their computers, it's just a super handy and powerful text editor. I use it for all text files other than lua, so mostly *.jbeam, *.json, *.pc, etc
Screenshot:


In addition to that, I also work a lot with our versioning control software, so that's overall 3 pieces of software for the majority of work.


Now, just out of curiosity, I wanted to take another look at Visual Studio Code, Microsoft's new-ish all around lightweight code editor. I gave it a spin when it was really new but didn't see any advantages over my existing setup.

The next post will detail what I've set up now with VS Code and how that works out.

 

Now let's take a look at what kind of setup I created for VS Code:
The requirements are to at least match what I had before:

• Lua
  • Syntax highlighting
  • Some basic form of code completion (nowhere near as useful as with something like C#)
  • Formatting
  • Linting
  • Code outline/function overview
• Jbeam
  • Syntax highlighting
  • NO linting (we'll get back to this later)
  • NO auto-formatting
• Generic text editor features
  • Comment/Uncomment
  • Multi-Cursor editing
  • Duplicate lines
  • Indent visualization

VS Code itself is not all that powerful, the real advantage is the extension system which allows you to create very nice extensions. By default it doesn't even support lua properly, so the first thing I did was to install a lua extension:

• vscode-lua (https://marketplace.visualstudio.com/items?itemName=trixnz.vscode-lua)

This already makes a lot of stuff possible with lua inside VS Code. It needs some basic configuration to meet my taste: (note: in VS Code all settings are done via JSON)

Code:

"lua.luacheckPath": "C:\\Program Files\\Microsoft VS Code\\luacheck.exe",
"lua.preferLuaCheckErrors": true,
"lua.format.indentCount": 2,
"lua.format.lineWidth": 3000,

The extension can use the very useful tool "luacheck" to lint your lua code and find potential issues. It's a much better linter than what is build into ZeroBrane, so that's already a plus.
Typical warnings from luacheck:


These can sometimes be safely ignored, other times they may point to a serious issue.
Now, with lua we are already almost there, the only thing missing now is some sort of code outline. Luckily I found a useful extension for that too:

• Code Outline (https://marketplace.visualstudio.com/items?itemName=patrys.vscode-code-outline)

It adds this little window in the explorer view:


Good. Lua sorted, the next post will take a look at working with jbeam files.

 

Jbeam files... In theory these are just loosely based on the JSON sytnax, but in practice they can be quite difficult to work with.

One of the things that really helps is a good syntax highlighter. It makes you spot mistakes like having used a string instead of an int/float much easier for example. Take a look here:

Without highlighting:

With highlighting:


Note how the "maxIntegralPart" mistake is much much easier to spot now. You could also go ahead and adjust the color settings to make it even more obvious.

Since jbeam generally uses similar syntax to JSON, finding a syntax highlighter for jbeam is as easy as opening VS Code, it has support for JSON built-in so that's already taken care of. (You'll have to tell VS code to treat jbeam files as JSON data so it automatically uses the right highlighting)

Now the less fun parts about jbeam, linting and formatting.
Since jbeam is a superset of JSON, it uses many things that JSON does not support and generally would be plain wrong with strict JSON.
This makes it difficult to lint a jbeam document, it's somewhat our own format, so there are no tools yet to lint jbeam data. This brings up the first issue with jbeam editing inside VS Code.
I haven't found a way yet to turn off the VS Code JSON linter, so I'm always stuck with these warnings/errors here:


This definitely can be ignored, but it's not ideal, especially since I need that panel for my work on lua, so just hiding it is not a solution either.

The second issue is formatting. While jbeam generally can be formatted by various JSON formatters, the result is often way too verbose when it comes to line breaks. Take a look at this example:
This is what we usually format our jbeam like:

Now, if I let VS code format that, it ends up like this:


Definitely much less usable. So by default, the formatting can't be used.

Unfortunately I did not find any solution yet for either of these two issues after I set up the whole thing yesterday. I may have to end up writing some jbeam support extension for VS Code.
Having a working formatter for jbeam is definitely something very desirable.

The next post will just detail what exact settings I have used and what other extension I installed that are not directly related to lua or jbeam.

 

Here are my current user settings for VS Code:


My workspace settings:


And a list of other extensions I've installed at the moment:

• Hop Light Theme (https://marketplace.visualstudio.com/items?itemName=bubersson.theme-hop-light)
• Material Icon Theme (https://marketplace.visualstudio.com/items?itemName=PKief.material-icon-theme)
• Excel Viewer (https://marketplace.visualstudio.com/items?itemName=PKief.material-icon-theme)

 

So what does this all boil down to? I can now potentially replace 3 programs (ZeroBrane, Notepad++ and version control) with just one neatly integrated solution while at the same time picking up some additional features.
Will it work out? I have no idea, but I'm willing to give it a try

Feel free to comment and/or ask questions!

 

Let's not turn this into a chat where everyone posts his favorite text editor, ok?

The idea was to talk about beam specific tasks and solutions.