NTE supports full control of train rendering via JavaScript. You can either fully control the rendering of all elements using JavaScript, or overlay JavaScript-driven displays or objects on an existing train model.

You can add a model that uses JavaScript to control rendering by writing something like this in the mtr_custom_resources.json file:

mtr_custom_resources.json

{
  "custom_trains": {
    "s_train_suspend": {
      "name": "JS Test Train",
      "base_type": "train_9_2",
      "color": "2AF0AD",
      "script_files": [ "mtr:js_train/main.js" ],
      "bve_sound_base_id": "optonix1500"
    }
  }
}

In general, the parameters are the same as those required for regular resourcepacks for MTR, except for the script_files parameter.

If the base_type parameter is not specified, the train appearance specified by the other parameters will be displayed as is, and then JavaScript-driven elements will be overlaid on top of it. Otherwise, if the base_type parameter is specified, the appearance will be controlled solely by JavaScript.

All trains of the same type use the same working environment (global variables and etc).

Code written in top-level space outside of functions will run when a resource package is loaded, and can be used to load resources such as models and textures. It is recommended to store resources (such as models, fonts and textures) in global variables, which do not need to be different for each train, to avoid excessive memory usage caused by loading a copy of the same content for each train.

Your script should include the following functions that the NTE will call as needed:

function create(ctx, state, train) { ... }
function render(ctx, state, train) { ... }
function dispose(ctx, state, train) { ... }

The NTE calls these functions with three parameters, each of which is described below.

The following lists all the rendering control operations that can be performed and all the information that can be obtained about the train.

The following functions are called to control rendering. The functions for rendering models should be called each time render is called.

• TrainScriptContext.drawCarModel(model: ModelCluster, carIndex: int, poseStack: Matrices): void

  • Requests NTE to render the car model.
  • carIndex: defines the car whose origin point will be used for rendering (0 — first car in front, train.trainCars() - 1 — last). The origin point is in the middle of the car, 1 block above ground level.
  • poseStack: transformation of model placement. If passed null, the model will be placed in the center without transformation.

• TrainScriptContext.drawConnModel(model: ModelCluster, carIndex: int, poseStack: Matrices): void

  • Requests the NTE to render a model of the wagon coupling.
  • carIndex: defines the car connection whose origin point will be used for rendering (0 — between the 1st and 2nd car in front, train.trainCars() - 2 — last). The origin point is in the middle of the connection, 1 block above ground level.
  • poseStack: transformation of model placement. If passed null, the model will be placed in the center without transformation.

• TrainScriptContext.drawConnStretchTexture(location: ResourceLocation, carIndex: int): void

  • Requests NTE to render the same stretching coupling between cars as in the original MTR. To improve performance, the provided textures are four images from the original MTR combined into one. Top left is the outside, top right is the inside, bottom left is the top, bottom right is the bottom. [Translator's note: these couplings have a fixed size.]

Call the following functions to play sounds. Call only when you need to start playback, repeated calls will cause multiple sounds to stack.

• TrainScriptContext.playCarSound(sound: ResourceLocation, carIndex: int, x: float, y: float, z: float, volume: float, pitch: float): void

  • Play sound. The sound source position can be set so that it can be heard by all nearby players.

• TrainScriptContext.playAnnSound(sound: ResourceLocation, volume: float, pitch: float): void

  • Play announcer sound. Can only be heard by the players currently in the train.

In addition, there is a set of functions to aid development and debugging.

• TrainScriptContext.setDebugInfo(key: String, value: Object)

  • Output debugging information in the upper left corner of the screen. You need to enable “Show JS debug info” in NTE Settings to display it. key is the name of the value, value is the content (GraphicsTexture type will be displayed, others will be converted to string).

• train.getRailProgress(car: int): double

  • Distance traveled by the car car from the moment of leaving the depot. Car counting starts from 0, the starting point is considered to be their front when leaving the depot. For example, getRailProgress(1) will return the distance to the coupling between cars 1 and 2

• train.getRailIndex(railProgress: double, roundDown: boolean): int

  • Calculates which track a particular railProgress is on at the first entry in path(). If this position is at the junction of two tracks, roundDown is true to return the one further to the rear, otherwise it returns the one further to the front.

• train.getRailSpeed(railIndex: int): float

  • The maximum speed at which this track can be traveled, as indicated by the railIndex entry in path(). It correctly handles the case where a train should not enter a station and accelerate when this section of track is a platform. The unit is m/tick, which is 1/20 m/s.

• train.getAllPlatforms(): List<PlatformInfo>

  • A list of all platforms through which the train passes according to the instruction. Each element is a PlatformInfo. A turn on a platform counts as one element.

• train.getAllPlatformsNextIndex(): int

  • Returns the number of the next station in the getAllPlatforms() list at which the train will stop (this value is updated when the train departs, so when it stops at a platform, it is the same station). A value of 0 means the train has just left the depot and is traveling to the first platform, and a value equal to getAllPlatforms().size() means it is returning to the depot. Note that it is therefore not necessarily within the index range of `getAllPlatforms()`, which needs to be determined.

• train.getThisRoutePlatforms(): List<PlatformInfo>

  • A list of all platforms of the current route. Each element is a PlatformInfo.

• train.getThisRoutePlatformsNextIndex(): int

  • Returns the number of the next station in the getThisRoutePlatforms() list where the train will stop. A value of 0 means that the train is going to the first platform, and a value equal to getThisRoutePlatforms().size() means that it is leaving for the next route or returning to the depot. Note that it is therefore not necessarily within the index range of `getThisRoutePlatforms()`, which needs to be determined.

• https://www.zbx1425.cn/nautilus/mtr-nte/#/js-train