Implement SCB to plain text to SCB compiler

[xezon]

• Similar to Implement W3D to plain text to W3D compiler #271

We need a tool that can convert binary SCB to plain text to SCB. This will allow us to edit and revision AI scripts in plain text.

Extra goal: World Builder is able to read and save plain text AI scripts as well.

[willherzog]

100% this. For me, the biggest challenge with scripting within the World Builder UI is the inability to do the sorts of things that are trivial to do in a text editing environment (find and replace being a major one).

For example, I've often wished there was a way to easily find where something specific is referenced within a mission's scripts, or even which missions use a particular thing (if it's not obvious).

Another problem with scripting in World Builder is with the Team Builder (which might also be something worth improving for the World Builder program itself): Unit types for teams are not included when a map is opened and it asks to replace references to missing objects* - instead, all missing objects are silently removed from any teams that used them. With the scripts in plain text format, this situation could instead be solved by a quick find and replace.

* Believe me, this can and does happen when working on a long-term modding project!

I suppose at some point we would also want IDE extension(s) to surface the game's symbols (i.e. to have the same scripting endpoints that are in World Builder) when working on scripts via text editing.

[augustresende]

"Add Ctrl + F for replace functionality"

[xamgore]

@xezon @willherzog *.scb files are hierarchical.

Example piece of 'SkrimishScripts.scb'

group_name: "USA Music",
is_group_active: true,
is_group_subroutine: false,
scripts: TypedList {
    items: [
        TypedChunk {
            type: "Script",
            version: 2,
            size: 183,
            body: Script {
                name: "USA Set Default Music Track",
                comment: "",
                condition_comment: "",
                action_comment: "",
                is_active: true,
                is_one_shot: true,
                easy: true,
                normal: true,
                hard: true,
                is_subroutine: false,
                delay_evaluation_seconds: 0,
                if_any: TypedList {
                    items: [
                        TypedChunk {
                            type: "OrCondition",
                            version: 1,
                            size: 67,
                            body: OrCondition {
                                conjunction: TypedList {
                                    items: [
                                        TypedChunk {
                                            type: "Condition",
                                            version: 3,
                                            size: 57,
                                            body: Condition {
                                                clause: SkirmishPlayerFaction,
                                                type_id: 0,
                                                type: None,
                                                parameters: [
                                                    Side,
                                                    FactionName,
                                                ],
                                            },
                                        },
                                    ],
                                },
                            },
                        },
                    ],
                },
                then_do: TypedList {
                    items: [
                        TypedChunk {
                            type: "ScriptAction",
                            version: 1,
                            size: 51,
                            body: ScriptAction {
                                action: SET_COUNTER,
                                name_id: 0,
                                type: None,
                                parameters: [
                                    Counter,
                                    Int,
                                ],
                            },
                        },
                    ],
                },
                else_do: TypedList {
                    items: [],
                },
            },
        },

I see them in the form of a compact JSON with a well-defined JSON-schema to allow code editors pre-validate files and show hints. Such hints could show the list of possible enum variants at any place of the cursor.

{ if:   [{ skirmishPlayerFaction: { side: "local", factionName: "GLA" } }],
  then: [{ setCounter: { counter: "name45", value: 42 } }] }

The plain text format (below) is comfortable for world-builder.exe users, yet lacks the tooling (syntax highlighting, a grammar generator, language server protocol, etc.)

***If***
True
***Then***
Set Flag Named 'FlagBuild' To False
Set Player 'Gla' Unable To Build Units
Set Player 'Gla' Unable To Build Buildings
Set timer 'intro end' expire in _sec

But let's think, what if the tooling could be ignored. The scb contents will be scattered into a file tree, where each Script is 4 files per se: script_config.json, conditions.txt, actions-if-true.txt, actions-if-false.txt.

The question is, which is the best option here?