Level editor

The level editor built into the game, and the formats it reads and writes.

Overview

The game has a built-in level editor, included by the WITH_EDITOR build option (see Game-specific parameters). It's on by default on every platform that can save files, except the Nintendo 64, Dreamcast, GameCube and PlayStation 2, and never in a dedicated server. In the Shareware Demo, levels of locked episodes can't be opened in it, and the web version offers it only after at least one episode is imported.

The editor works with the game's own level format. Original .j2l levels are converted on the first start (see File locations) and can be opened from "Cache/".

Opening the editor

  • Level Editor in the main menu opens an empty level and the Open dialog.
  • The /edit command-line switch opens a level by name (episode/level) or by path:
Jazz2 /edit prince/castle1
Jazz2 /edit "C:\Levels\MyLevel.j2l"

Interface

  • Menu bar and toolbar at the top. The toolbar ends with the options of the current tool.
  • Left panel — the tools, the current stamp, and the Tiles and Events tabs.
  • Right panel — the layer list, with the properties of the selected layer or event below it.
  • Status bar — how to use the current tool, the current layer, the tile and event under the pointer, and the zoom.

The level fills the window behind the panels.

  • Panels are resized by dragging their inner edge. Each panel can also float over the level: use the button in its header, or drag the header. Drag it back to its edge, or double-click the header, to dock it again.
  • Small windows — below 600 units wide, the panels become drawers opened from the toolbar. Below 420 units, the tools move to a row at the bottom. View > Interface can fix the layout to desktop or compact.
  • Expert Mode (View menu, on by default) shows all tools and commands. Turned off, only the basic ones are shown.
  • Interface size follows the window size and the display scaling of the system (its DPI), so it isn't tiny on a small screen with many pixels, such as a phone. Ctrl+Shift++ / - makes it larger or smaller, in steps of 25% from 100% to 600%.
  • Safe Area (Options > Graphics in the game) also applies to the editor. The panels, windows and the bar shown while playing keep clear of the cut-off edges. While editing, the edges are filled like the bars.
  • The tools on the left scroll with the wheel or a finger when the window is too short for them.

In dialogs, Enter chooses the highlighted button. Esc or the cross closes the dialog without choosing anything. The cross can also be hit anywhere in the corner of the window. Windows such as Check Level, Statistics, the Navigator or the Palette stay open beside the level until they're closed. Opening one again brings it to the front, and its shortcut closes it. Some windows, such as History, the Navigator and the Event List, can be resized by their edges. A smaller Navigator shortens the list of bookmarks first, then the map. Every color has a swatch that opens a color picker.

Using the interface with the keyboard

  • Tab and Shift+Tab move between controls. Enter or Space presses the focused one, Esc gives the keys back to the level.
  • A dropdown opens with Enter, Space, F4 or Alt+Down. Up and Down change it without opening it.
  • Alt with the underlined letter opens a menu. In menus and long lists, typing a letter jumps to the next item that starts with it. Right or Enter opens a submenu, Left or Esc closes it.
  • Text fields have their own undo (Ctrl+Z, Ctrl+Y), and Ctrl with the arrows, Backspace or Del moves or deletes by words.
  • On macOS, Cmd works as Ctrl.

Contrast, font and motion

In View > Interface:

  • High Contrast Interface — a theme with stronger contrast.
  • Readable Font — text in a plain font (Roboto, "Content/Editor/Fonts") instead of the font of the game, with real lowercase letters and sharp at every interface size. Lines keep their height, so nothing moves when it's switched. It's on by default.
  • Reduce Motion — nothing animates: panels and lists don't slide, the view jumps instead of flying, and a play-test starts without the growing ring, with the music opened up and muffled again at once.

Navigator, bookmarks and notes

The Navigator (F2) shows the whole level in small. Click or drag in it to move the view. Events adds the events and the camera limits. Below the map:

  • Bookmarks 1 to 9 — set at the view center by Ctrl+Shift+1 – 9, gone to by Ctrl+1 – 9. Each can be renamed and given a color.
  • Notes — texts placed in the level (Ctrl+Shift+N at the pointer). A note keeps its author and time and can be replied to, so notes work as review threads. Done marks a note as resolved.

Bookmarks and notes can be undone like any other change, and export leaves them out.

Controls

Mouse

  • Left button — use the tool. Right button — pick the tile under the pointer (brush), or erase (rectangle, fill, events).
  • Wheel — zoom at the pointer. With Shift it scrolls sideways, with Ctrl up and down, with Alt it changes the layer, and with Ctrl+Shift the interface size.
  • Middle button, or the left one with Space held — pan the view.
  • Number fields — drag, click to type, or use the wheel (Shift for steps of ten). A drag is one undo step. The middle button resets a field to its default, where it has one: the speeds and offsets of a layer, the parameters of an event.
  • Dropdowns — the wheel steps through the choices.

Zoomed out below 15 %, layers are drawn from cached images (Editor::TileLod), so even a large level stays fast. The images are as sharp as the screen allows, up to 16 pixels per tile. Palette-shifted, solid and effect layers are always drawn as tiles.

Keyboard

KeysAction
D, E, R, G, IBrush, eraser, rectangle, fill, eyedropper
BGrab a block: press at one corner and again at the other, the block becomes the brush — see Grabbing blocks
Shift+B / Ctrl+BGrab a block added to / taken from the selection
Ctrl+E / Shift+ETake the event under the pointer / place it under the pointer, with any tool
M, W, Q, HSelect, magic wand, events, hand
T, P, U, K, LSmart brush, ground line, measure, events along path, shapes
Space / Alt (held)Hand / eyedropper while held
X / YFlip the stamp horizontally / vertically
Shift+RTurn the stamp clockwise
Z / Shift+ZPaint random tiles of the stamp / reroll them
1 – 9Edit a layer. With Shift, hide or show it
Page Up / Page DownPrevious / next layer
Ctrl+Z / Ctrl+YUndo / redo (also Ctrl+Shift+Z)
Ctrl+X, C, VCut, copy, paste — pasted tiles become the stamp
Ctrl+Shift+CCopy the selected tiles of the sprite layer with the events on them, or the selected events with the tiles under them — Ctrl+V pastes both
DelDelete the selection
Ctrl+A / D / ISelect all / deselect / invert — the tiles, or the events while the event tool is chosen
Shift+arrowsMove the selected tiles
Ctrl+Shift+X / YMirror the selection horizontally / vertically
EscCancel the current action, then deselect
+, - / 0 / HomeZoom in, out / zoom as in the game / fit the whole level
ArrowsMove the view
Ctrl+G / Ctrl+PGrid / flat layers
Ctrl+Shift+PPause layers that move by themselves
Ctrl+Shift+EShow events while using other tools
Ctrl+MCollision masks: over the tiles, instead of them, off
Ctrl+Shift+RShow where the player can get
Ctrl+TLevel texts
Ctrl+FFind and replace
Ctrl+Shift+RightContinue the row right of the pointer with suggested tiles
Ctrl+N, O, SNew, open, save
Ctrl+Shift+SSave as (Export has no key, it's in the File menu)
F5, Shift+F5, Ctrl+F5Play, play here, play from start — F5 while playing goes back to the editor
F6, F7, F8, F9 (while playing)Move the player to the pointer, stop time, next frame, slow motion — see Debug toggles
Ctrl+LPath of the last play-test
Ctrl+Shift+1 – 9 / Ctrl+1 – 9Set a bookmark / go to it
Ctrl+Shift+NAdd a note at the pointer
F2 / F3Navigator / event list
Ctrl+HHistory — click a change to go back or forward to it
Ctrl+KCommand palette — search all commands by name
F1Keyboard shortcuts

Grabbing blocks

As in Jazz Creation Station and MLLE, B grabs a block with any tool: point at one corner and press it, point at the other corner and press it again. The block becomes the brush, and the Esc key forgets the first corner. Over the tiles of the picker it grabs tiles of the tile set the same way.

  • A block of the sprite layer has the events on its tiles. Painted on the sprite layer, they replace the events under its tiles. On other layers, only the tiles are painted.
  • Events off the grid on its tiles go with it, each at the same place on its tile. They're added to the events off the grid there, but never twice to the same place.
  • The empty tiles of a block are skipped where it's painted. Shift+click paints the whole block, with its empty tiles and the events on them. Shift+drag paints a line of whole blocks.
  • Shift+B adds the rectangle to the selected tiles, Ctrl+B takes it out, and all the selected tiles become the brush. So a block can have any shape.
  • Grabbing a block ends the selection, so the brush paints anywhere.
  • Ctrl+E copies the event under the pointer (to the clipboard too), and Shift+E places it under the pointer, replacing the event there. Neither changes the tool.

Changing shortcuts

In Keyboard Shortcuts (F1), click a shortcut and press the new keys. Backspace removes it, Esc keeps it. An action that had the same keys loses them. Actions can be searched by name or by keys (ctrl+s), and Press Keys finds what a shortcut does. Reset All restores the defaults.

The side buttons of a mouse have no use of their own, so they can be shortcuts too, with or without modifiers. Press one instead of the keys, it's shown as Mouse 4 or Mouse 5.

Shortcuts like applies a preset (Editor::KeymapPreset):

  • This Editor — the defaults. B, Ctrl+E and Shift+E already work as in Jazz Creation Station, see Grabbing blocks.
  • Jazz Creation Station — F and I flip the stamp (Alt still picks a tile).
  • MLLE — as Jazz Creation Station, and:
    • Ctrl+C / X make the selection the brush, with its events (cut erases it).
    • Ctrl+V shows the events. Paste loses its key.
    • Ctrl+R plays, Ctrl+Shift+R plays from the pointer.
    • Ctrl+L / Shift+L go to the previous / next layer.
    • Ctrl++ / - zoom.
    • , picks the tile under the pointer, Shift+, with the event there.
    • Backspace makes the brush an empty tile.
    • E places the next event chosen in the list on the tile under the pointer.
    • M held shows the collision masks over the tiles, the select tool loses its key.

    MLLE can't turn the stamp, so R stays the rectangle.

Some shortcuts work only while the level is played — Back to Editor and the debug tools — which is why F5 both starts and stops a play-test.

Changed shortcuts are saved in "Jazz2.EditorHotkeys.json" in the configuration directory, as an object of action IDs and their shortcuts, such as "Ctrl+Shift+Z" or "Mouse 4", or null for none. Only those that differ from the defaults are written. Export and Import move them to another computer.

Gamepad

Pressing a gamepad button shows a cursor and lists the buttons in the status bar. Using the mouse or the keyboard switches back.

GamepadAction
Left stickMove the cursor, faster the further and longer it's pushed
Directional padMove the cursor by one tile. Over a number, change it
Right stickMove the view. Over a list, scroll it
Left / right triggerZoom out / in at the cursor
AUse the tool, or press what the cursor is over
BErase, or close what's open over the interface
XPick the tile or event under the cursor
YNext tool. Hold it for a tool ring (aim with the left stick, release to pick). Over a text field, open a keyboard
Left / right bumperPrevious / next layer
Back / left stick pressUndo / redo
StartPlay

While a dialog waits for an answer, the gamepad only moves the cursor and presses A and B. Text is typed with the system's on-screen keyboard where there is one, otherwise with the editor's own.

Touch screen

The status bar lists the gestures.

FingersAction
OneUse the tool once the finger moves a little. A quick tap is a click. Over the interface, it acts as a pointer
TwoPan, and pinch to zoom
Tap with two / threeUndo / redo
Hold one stillTool ring, tap to pick
Tap a text fieldSystem keyboard, or the editor's own

Over the interface, a finger held still shows the tooltip, and lists scroll by dragging them. In the layer list and the tile picker, hold a finger still for half a second before dragging: then it moves the layer or picks a block of tiles, instead of scrolling. A number field opens the keyboard when tapped, and changes the number when dragged. The frame of a layer in the view is part of the level: two fingers on it still pan, and it's resized only once one finger moved alone.

While a level is played, a finger on the bar at the top uses the bar, the other fingers play the game.

Layers

The layer list is in the right panel:

  • The eye hides a layer. Alt+click on it shows only that layer, or all layers again. The lock protects a layer from changes. Both only affect the editor, not the level.
  • A layer with Visible in game off (the first of its properties) isn't drawn in the editor either, so the view shows what is played. Its eye is crossed out in red and its properties warn about it. Layers of the original game without any tiles are converted so, a layer added to such a level later needs it turned on. Turning it on also shows the layer in the editor if its eye hid it.
  • The layers are listed in the order they're drawn, the front one first, as a level of JJ2+ is converted. Drag a layer to reorder it, the layers keep the depths of their places in the list then, two swapped layers swap their depths, so it's drawn where it's listed. The sprite layer keeps its depth, a layer moved past it gets a depth between it and the next layer. Check Level tells about a layer whose depth puts it in front of the one above it. Double-click a layer to rename it. An unnamed layer is named by what it is, such as Foreground or Background. Scripts can find a layer by its name, the names a level made in MLLE gives its layers are kept.
  • A layer of a level of the original game also keeps its Number there, 1 to 8, which scripts of JJ2+ refer to it by (jjLayers[n]) wherever it's moved; a duplicate of it doesn't get the number. It's changed in the layer properties, a layer that had the number takes the old number of the other one.
  • Duplicate Layer and Resize Layer are in the Layer menu. Removing a layer asks first.

Layer properties

The speed, offset and model of each axis decide where the layer is, as in JJ2+:

ModelWhere the layer isJJ2+
SpeedMoves by its speed and automatic speed. It meets the top left of the level only at speed 1LAYERSPEEDMODEL::BOTHSPEEDS
Speed from level startThe same, but starts at the top left of the level in a view of any sizeLAYERSPEEDMODEL::FROMSTART
Fixed to screenIgnores its speeds and offsetLAYERSPEEDMODEL::LAYER8
Fit to levelSpans the whole level, whatever its speeds—
Speed of view sizeThe speed is its position with the view at the top left of the level, the automatic speed at the bottom right, in sizes of the view—

Inherent offset (limitVisibleRegion of JJ2+) moves a layer of Speed that doesn't repeat vertically down by half of how much taller the view is than 200 pixels.

  • Movement presets set the speeds and models for common kinds of layers. Custom means none of them matches, as in most converted levels.
  • Renderer — how the layer is drawn, see Renderers.
  • Color — what it means depends on the renderer: a multiplier of the tiles, the tint, or the color of the horizon.
  • Editor opacity — how see-through the editor shows the layer, to see the layers behind it. Editor-only, the game doesn't use it.

Resize Layer changes the size around an anchor point. The new area is empty, extends the edge tiles, or repeats the layer. Events, the water level, bookmarks and notes move with the sprite layer. With the Select or Hand tool, the frame of the layer also has handles to resize it by dragging. With Ctrl held, a handle moves the whole layer instead, by its Offset X and Offset Y (by whole tiles with Shift too). The sprite layer can't be moved.

Renderers

RendererWhat it draws
TilesThe tiles as they are
Solid colorThe color of the layer where its tiles are
TintedThe tiles tinted by a palette entry
Palette shiftEach pixel shows the color Shift entries further in the palette, as SPRITE::PALSHIFT of JJ2+. Opacity sets how opaque the layer is. True color tile sets aren't shifted
Single colorOnly the shapes of the tiles, every visible pixel in the palette entry Color, such as a shadow of another layer, as SPRITE::SINGLECOLOR of JJ2+. Opacity sets how opaque the layer is
X-rayThe last frame of each animated tile only where an object is behind it, as its silhouette
Blur behindNot its tiles, but what is behind them, moved, mirrored or blurred by the colors of the tiles
Alpha mapEvery pixel in the palette entry Color, as opaque as its palette index is high, so a gradient of indices is a glow of that color, as SPRITE::ALPHAMAP of JJ2+. Opacity sets how opaque the layer is
Other paletteThe tiles through the additional palette Palette of the level (counted from 0) instead of its palette, so they keep their colors when a script changes the palette, as SPRITE::MAPPING of JJ2+. Opacity sets how opaque the layer is
SkyThe texture as two planes stretching to the horizon, as TEXTURE::WARPHORIZON of JJ2+
TunnelThe texture as circles getting smaller into the distance, as TEXTURE::TUNNEL
WaveThe texture where the tiles would be, its rows and columns moved by sine waves, as TEXTURE::WAVE
CylinderThe texture as the inside of a horizontal tube, as TEXTURE::CYLINDER
ReflectionWhat is behind it, mirrored below a horizon and rippled by the texture, as TEXTURE::REFLECTION

The sprite layer can only be drawn as tiles, in a solid color, tinted, with a palette shift, in a single color, as an alpha map or through another palette.

Blend mixes the layer with what is behind it, as the sprite modes of JJ2+ do: Screen lightens it (SPRITE::BLEND_SCREEN) and Multiply darkens it (SPRITE::BLEND_MULTIPLY), as far as Mix says (255 is fully). A layer drawn as tiles, with a palette shift, as an alpha map or through another palette can be blended so, tiles in true color are drawn as they are. Chroma key shows a layer drawn as tiles or a textured layer only where what is behind it has the color of the palette entry Key, so an area painted in that color is a window the layer shows through (SPRITE::CHROMAKEY). Darken, Lighten, Hue, Saturation, Color, Luminosity, Dissolve, Overlay, Hard light, Soft light, Difference, Dodge, Burn and Exclusion mix a layer drawn as tiles or a textured layer with what is behind it as image editors mix layers (SPRITE::BLEND_DARKEN and the like), as far as Mix says; backends that can't read what is behind a layer draw it as an ordinary one. A textured layer can also be Translucent, as opaque as Mix says. Backends that can't read what is behind a layer don't draw a layer of tiles of a chroma key, and draw a textured layer opaque. The sprite layer can't be blended.

  • Texture of a sky, tunnel, wave, cylinder or reflection — Its tiles (the 8×8 tiles at the top left of the layer), or an Own image of 256×256 pixels stored in the level and shown under the row. A level converted from JJ2+ gets an own image where it used a JJ2+ texture or an image made in MLLE. The menu of the row imports a PNG (its colors are matched to the palette), exports the image to edit it elsewhere, turns the tiles into an own image, or goes back to the tiles. It also lists the PNG images in Editor/Textures of the user content and of the content of the game, one of them picked is copied into the level as its own image. Images are exported there by default, so an exported texture is listed with the others.
  • Palette of a sky, tunnel, wave or cylinder — the additional palette of the level the texture is drawn through plus 1, 0 for the palette of the level, as SPRITE::MAPPING of JJ2+. The fade then goes towards the entry 207 of that palette. Its name and colors are shown under the row, clicked they show it in Level > Palettes, the same as under the palette of a layer of the renderer Other palette.

Level > Palettes edits the palette of the level and its additional palettes, picked at the top by the number layers pick them by. A level converted from JJ2+ gets those MLLE stored with it, in their order. New adds a copy of the shown palette, Rename and Remove are of the shown additional palette. Their colors are changed, made into gradients, imported and exported as those of the palette of the level, what is of the tiles of the level (marks, moving entries, the tile set) is only for that one. Removing a palette renumbers the layers drawn through those after it, those drawn through it are drawn in their own colors. The dialog shown already is brought to the front.

  • Sky — the Vanishing point and the Horizon line in percent of the view, and Fade into the color of the horizon.
  • Area of a sky, tunnel or cylinder — the Whole view, Resurrection as this game drew sky layers before version 4.0, the Whole view, JJ2+ in the perspective of JJ2+ with the texture placed by the speeds of the layer (SURFACE::FULLSCREEN), or only where the layer is, as a window (SURFACE::INNERWINDOW) or as part of the layer (SURFACE::INNERLAYER). The texture then moves by Inner speed and Inner auto inside the layer. JJ2+ draws the sky layer of a level saved by JCS (SURFACE::LEGACY) in its perspective too, placed where layer 5 is by the speed model of layer 8, so a converted level of JJ2+ (with MLLE data or a script) gets Whole view, JJ2+ and any other level Whole view, Resurrection. A cylinder is always drawn in the perspective of JJ2+, so it has only one Whole view.
  • Tunnel — Center in percent of the view, Fade into the color of the horizon, and Spiral.
  • Wave — the Wavelength of the waves that move the rows left and right and of those that move the columns up and down (one more pixel than the number, 0 for none), their Amplitude (1 moves the texture by 128 pixels each way), their Speed along the texture, and Swap angles to move the vertical waves the other way. The waves follow the texture, as in JJ2+. Backends without shaders draw its tiles, without the waves.
  • Cylinder — Center of the horizon, Fade of the far wall, and Half size for a more curved tube.
  • Reflection — below the Horizon line, mirrors what is behind it as on water. The texture ripples the reflection towards the Vanishing point: Distortion sets how strongly, Distance how small the ripples are. Tint and Tint opacity color it, Blur blurs it horizontally. The Area is the whole view, or only where the layer is, as a window (SURFACE::INNERWINDOW) or as part of the layer (SURFACE::INNERLAYER). The ripples then move by Inner speed and Inner auto instead of the speeds of the layer. Only the last reflection layer is drawn, and only on backends that support it.

While a layer is selected, a sky, tunnel, wave, cylinder or reflection is shown as plain tiles so it can be painted — except a reflection with its own image, which keeps rippling. Show Textured Layers in the View menu (Ctrl+Shift+T), or Show as in game in the properties of the layer, draws it as in the game instead, to see what its properties do.

Layers converted from MLLE keep their sprite mode: PALSHIFT and TRANSLUCENTPALSHIFT become a palette shift, TINTED a tinted layer, SINGLECOLOR and TRANSLUCENTCOLOR a single color layer (the latter with an opacity of 192), CHROMAKEY a Chroma key Blend, ALPHAMAP an alpha map, MAPPING and TRANSLUCENTMAPPING a layer drawn through another palette, TRANSLUCENT, TRANSLUCENTTILE, BLEND_NORMAL and INVISIBLE ordinary tiles with an alpha of 192, 192, the parameter or 0 (an invisible layer is still solid), BRIGHTNESS ordinary tiles darkened below the parameter 128, and the other BLEND_ modes a Blend of the layer, mixed as far as the parameter says. A textured layer keeps them, CHROMAKEY and the translucent modes as its Blend. Other modes are drawn as ordinary tiles.

How layers are shown

  • Layers scroll with parallax, as the game would place them for a player at the view center. Flat Layers (Ctrl+P) aligns them all to one grid, which helps when editing backgrounds.
  • A layer that moves by itself stays still while it's selected. Pause Layer Movement (Ctrl+Shift+P) stops all of them.
  • The sprites of events are drawn among the layers as in the game, layers in front of the sprite layer cover them. Show Events Over All Layers draws them over all layers.
  • The selected layer is framed in white, and darkened outside where it doesn't repeat. A repeating layer shows faint lines where it repeats, and the frame is around the copy nearest the middle of the view.
  • Ctrl+M shows the collision masks of the selected layer. On the sprite layer, symbols show what events make the tiles do — one-way, vine, hook, pole, hurting, destructible and so on. Translucent tiles are tinted, invisible ones crossed out.

Level properties

In the Level menu:

  • Properties — name, author, next, secret and bonus levels, music, starting light, weather, water level, the caption tile, and the pit and multiplayer settings.
    • The author defaults to the player name from the options.
    • The caption tile is shown in the level list. Auto picks a colorful tile the level uses a lot.
    • Whether the level is a race or has Capture the Flag isn't chosen here. It follows from the events when the level is saved: a warp with Set Lap makes a race, a CTF base makes Capture the Flag.
  • Texts (Ctrl+T) — events refer to texts by number, so new texts are added at the end and only the last one can be removed. The arrows reorder texts, and the events using them follow. Enter starts a new line, Ctrl+Enter confirms.
  • Episode — see Episode.

Saving also stores a small preview of the start of the level, which the custom level list shows.

Translating level texts

In Level Texts, choose a language at the top, or Add Language by its code (de, pt-br), and type the translations next to the texts. An empty translation shows the original text. The game shows the translation to its language, or to the language without its region (pt for pt-br).

For translators, Export .pot writes a gettext template, Export .po a catalog with the translations of the chosen language, and Import .po reads one back.

Weapons

Weapons in the Level menu shows the ten weapons of the level, each of them is:

  • Original weapon, maybe with other ammo options: the most ammo (with a multiplier of what a pickup gives), ammo at the start or full at every start, infinite ammo, whether it's allowed or can be powered up, whether gun crates give it and birds fire it, whether a shield fires in its place, bubbles under water, and the gems a player hit by it loses in Treasure Hunt — the options JJ2+ scripts know as jjWEAPON, which scripts read and change too,
  • a Custom weapon, which the game fires itself, also online, without a script: how often it fires, how many shots at once and how they spread, recoil and sound (of the game by its name, or embedded in the level), whether only while the player stands as the thunderbolt, and for its shot and its powered-up shot the speed, the acceleration (below 0 it slows down until it stops), gravity, damage, bounces, passing through enemies or walls, homing, freezing, a trigger (on a hit, an enemy close for a mine, or a timer), a blast with its damage and push, the explosion, the light and the look (a sprite, a glowing sprite as the pepper spray, a swirl of sparks as the electro blaster, or a beam as the thunderbolt, which reaches as far as the shot would fly in its time), with a second sprite each shot takes at random and the sprite flipped horizontally or vertically always or at random; it's made from a weapon of the game, whose rules crates and bosses keep for it,
  • a Script-driven weapon, set up by the script of the level as MLLE does it, with a weapon of a script library (.asc) next to the level or in the files of the original game, which works only where scripts of levels run.

The ammo of a weapon is counted in 1/256 of a round. A weapon of the game takes a round a shot, the toaster 50/256 and the thunderbolt 80/256 (40/256 powered up), a custom weapon takes what its Ammo a shot says, down to 1/256. Multiplier of each weapon (1 for all of them in the game) multiplies what a pickup gives and the maximum, and divides the ammo shown, so a weapon can fire many shots for each round shown. JJ2+ scripts and MLLE know only the multiplier, a script counts ammo in rounds times the multiplier.

A custom weapon is shown firing in a firing range below its pages, held for most of a second, with walls and a target; the player, the character chosen in the Play menu, and the target are moved by dragging them. The sound of firing is played by the button next to it. Try It plays the level from the middle of the view with the weapon in hand and full of ammo. On the Animations page, the shots, the icon on the screen and the ammo can be animations of the game or embedded images — PNG images of frames in rows and columns, imported into the colors of the sprites and kept in the level whole, with the columns, rows and number of frames changed below each — each shown playing as in the game. Sounds in WAV or Ogg Vorbis, up to 2 MB each, are embedded there too, kept in the level as the files are, and a custom weapon fires with one of them chosen next to its Sound; they're played as the game's own sounds, also by the clients of a server, which get them with the level. The ammo of a weapon named by the level is shown by that name in the event properties. A value the level changed is marked by a pencil next to it, as are the weapons in the list, with their numbers and animated icons on the screen. A weapon the script of the level sets up, as MLLE does or by its own code, is marked (script) and shows the icon the script gives it on the screen, or its ammo; one set up by its own code is told on the first page and its Script page, as how it looks and fires in the game comes from the script then.

The weapons a script-driven weapon is chosen from on the Script page are described by files in Editor/Weapons/ of the content or the user content, which also says which parameters the weapon has and how they're edited, and which callbacks of the level script it needs to pass on to its hook (as onMain() calling MLLE::WeaponHook.processMain(), which MLLE doesn't write either). The .ini files of MLLE are read as they are, a section of each weapon with Options = Name:type:default|.... Files of the editor are .json, a weapon, an array, or an object with a "Weapons" array:

{
    "Weapons": [{
        "Name": "Pathfinder",
        "Library": "WeaponVMega4.asc",
        "Constructor": "WeaponVMega::Pathfinder::Weapon()",
        "Image": "pathfinder.png",
        "Hooks": [ "onMain" ],
        "Params": [
            { "Name": "Nodes (idle)", "Type": "int", "Default": 1, "Min": 0, "Max": 16, "Description": "Shown as a tooltip" },
            { "Name": "Mode", "Type": "uint8", "Default": 0, "Options": [ { "Name": "Slow", "Value": 0 }, { "Name": "Fast", "Value": 1 } ] }
        ]
    }]
}

A parameter is bool, int8, uint8, int16, uint16, int, uint, int64, uint64, float, double or string, in the order the library pops them from its jjSTREAM, which is how they're kept in the level. A weapon of a library no file describes is offered too, with its parameters guessed from the library: what the function of the weapon that gets the jjSTREAM@ pops, by the declarations of what it pops into. A guess stops at the first value of a type it can't tell, the bytes after it are kept as they are.

When the level is saved and its script-driven weapons changed, the lines of its script that set them up, those marked ///@MLLE-Generated, are written again, and all other lines are kept. Until then, play-tests and the sprites the editor shows of the script run the script with those lines as they are in the editor. Script-driven weapons work only while scripts of levels are allowed in the options of the game. The weapons are kept in the chunk "WPNS" (see Chunks), a level of a newer version of it is shown but not changed.

Template on the first page makes the weapon as a template describes it with one click: a weapon of a script, or a custom weapon described by an item with "Kind": "Custom" of the same .json files in Editor/Weapons/. The images and sounds a custom weapon needs are files next to its template, embedded in the level when it's made, an image or a sound the level already has isn't embedded again. The button next to it saves a custom weapon as a template, with its images and sounds as files next to it, so the same weapon can be made in other levels:

{
    "Weapons": [{
        "Kind": "Custom",
        "Name": "Plasma Gun",
        "BasedOn": "Blaster",
        "Options": { "Maximum": 50 },
        "Fire": { "Cooldown": 12, "SpreadAngle": 10, "SoundFile": "plasma.wav" },
        "Shot": {
            "Sprite": { "File": "plasma.png", "Columns": 4, "Rows": 1, "Frames": 4, "FrameRate": 12, "HotspotX": 8, "HotspotY": 8 },
            "Speed": 4, "Acceleration": 0.5, "Look": "Glow", "DestroysBlocksAs": "Own"
        },
        "ShotPowered": { "Strength": 2 },
        "HudIcon": { "Metadata": "UI/HUD", "AnimState": 3 }
    }]
}

The names are those of the fields of Jazz2::WeaponDefinition (Jazz2::WeaponOptions as "Options", Jazz2::WeaponFireOptions as "Fire", Jazz2::WeaponShotOptions as "Shot" and "ShotPowered"), with angles in degrees, "AmmoPerShot" in rounds and choices by their names. What a template doesn't describe is as the weapon of the game it's made from has it, the name and the ammo options as the level has them, and the icons too if the weapon is a custom weapon already; the powered-up shot is as the usual one with what "ShotPowered" changes of it. A sprite is an animation of the game by its metadata and animation state, or an image file with how its frames are laid out, the size of the image tells them if it doesn't say. "Sound" is a sound of the game by its name, "SoundFile" a file to embed.

Episode

Episode in the Level menu shows the episode of the level — the folder it's in and its .j2e file:

  • the name, the first level, the episodes before and after it, and its position in the list (the original episodes are below 100),
  • the title and background images, which can be imported and exported as PNG,
  • the levels in the order their links lead, with broken links and levels nothing leads to marked.

Rename renames a level and its script, and updates the links to it in other levels. The previous files are kept as .bak.

Levels in unknown belong to no episode. For them, the editor offers to create a New Episode with the level as its first, to Move to Episode, or to list the Levels of No Episode. Moving lists every change first. The level is then saved into the folder of the episode, with its script and unsaved changes, and removed from unknown, and links to it in other levels are updated (their previous files kept as .bak).

Tiles

Tile picker

  • Click picks a tile, drag picks a rectangle. The arrows next to the name switch between tile sets and animated tiles.
  • Ctrl+wheel or the buttons on the right change the tiles per row, 10 by default.
  • With the brush, the Next row suggests tiles that other levels put next to the tiles around the pointer. Ctrl+Shift+Right fills the row right of the pointer with them.
  • The magnifier button in the header shows how much each tile is used.
  • The strip above the tiles holds favourite and recent tiles. Right-click a tile to make it a favourite.

Editing a tile

Double-click a tile in the picker, or use Edit Tile of the Brush in the Level menu, to change its pixels and collision mask. The change applies only to this level, the tile set file stays as it is.

  • Tools: pencil, line, rectangle, fill, Replace (recolors every pixel of a color), selection and eyedropper. Left paints, right erases.
  • Buttons below flip, rotate and shift the whole tile. The mirror buttons make painting mirrored. Copy and paste move pixels between tiles.
  • Seams shows the tile repeated around itself, to check that it tiles.
  • Paint in Level paints right in the level, everywhere the layer shows the tile.
  • True Color paints any color. The tile is first copied into the tiles of this level.
  • Mask: Mask from Pixels, Fill Below Surface, Slope, Mask of Brush Tile, Empty and Solid.
  • As in Tile Set drops the changes. Export PNG and Import PNG exchange the tile with another program.
  • An animated tile shows its frames, each edited as its own tile.

8-bit tiles keep palette indices, so a color is reduced to the nearest one of the palette — except in the tiles of this level.

Tiles of this level

The tiles of this level are an extra tile set stored inside the level, created when tiles are first added to it.

  • Its tiles are true color, with transparency.
  • Copy into This Level in the window of any tile copies the tile there, and the level uses the copy instead. That way any tile can get true color changes in a single level.
  • Save Tile Changes into Tile Set moves them into a tile set file.

Animated tiles

Animated Tiles in the Level menu lists them.

  • A new animated tile is made of the brush tiles. Add Brush adds them as frames.
  • Frame time is in game frames (60 per second). The delay holds the last frame longer, and an animation can play forward and back.
  • A removed animated tile is replaced by its first frame everywhere. Paint with It makes it the brush.

Tile sets

Tile Sets in the Level menu manages them all. New and changed tile set files are saved into the user content as Tilesets/<name>.j2t.

CommandWhat it does
Tile SetsThe default tile set and the extra ones. An extra one can use a range of its file and have its colors matched to the level palette. The tiles of the level are remapped, so they keep their look
New Tile Set > EmptyEmpty tiles in the level palette
New Tile Set > From ImageCuts an image into 32×32 tiles, with the options below
New Tile Set > From Tile Set File (.j2t)Converts a tile set of the original game, as the game converts it, or copies one of this game. It starts in the folder of the original game
Add Tiles > From ImageAdds the tiles of an image to a tile set of the level, a new tile set, or the tiles of this level
Add Tiles > Effect TilesTiles for a Blur behind layer: glass, glass blocks, frosted glass, water, heat haze, a magnifier or a puddle
Export ImageSaves the tile set shown in the preview as PNG, 10 tiles per row, with the masks in .mask.png
RearrangeDeletes, moves and inserts tiles of the default tile set, merges duplicates and removes unused ones, see below
Save Tile Changes into Tile SetIn the Level menu. Moves the tile changes of this level into the tile set file (the previous one kept as .bak), or into a new tile set

Options of the tiles from an image:

  • Colors — keep the palette of the image, keep true color, map to the level palette, or generate a palette (it keeps the entries the sprites use).
  • Dither — by an ordered pattern, or by error diffusion.
  • Margin and Gutters for sprite sheets, a Transparent color, and the Alpha a pixel needs to be seen.
  • Skip tiles that are the same as another.
  • A .mask.png next to the image gives the masks. Otherwise the tiles are solid where they're opaque. An image from Export Image comes back unchanged.

In Rearrange, click, Ctrl+click or Shift+click selects tiles, and dragging moves them. Levels refer to tiles by their position, so it either saves the tile set as itself and updates the levels that use it — the previous files kept as .bak, Files listing them first and Restore Backups putting them back, and this clears the undo history — or saves a new tile set that only this level uses.

Palette

Palette in the Level menu shows the palette in use. Only the level's own palette can be changed. It starts as a copy of the tile set's.

  • Click picks an entry, drag or Shift+click a range. Edit it as RGB, HSV, #RRGGBB or with the color picker. The level, sprites included, updates live.
  • Gradient fills a range between its ends. From Tile Set restores the colors of the tile set.
  • Keep the colors of sprites protects the entries that sprites use.
  • Tiles Using It makes the tiles that use the entry the brush.
  • The arrows move entries, Swap swaps two. Keep the look of the level remaps the tiles so the level looks the same.
  • Mark crosses out the unused entries, those the sprites use, or those that differ from the tile set.
  • Into Tile Set makes it the palette of the tile set. Import and Export read and write JASC (.pal), GIMP (.gpl), Adobe (.act) or PNG.

Painting and selecting

Choose a tool on the left, or in the Tools menu. Its options are at the end of the toolbar. The picker switches to the Tiles tab for the tools that paint or select tiles, and to the Events tab for the event tools.

ToolHow it worksOptions
Brush (D)Paints the stamp, Shift+drag paints a lineStamp options
Eraser (E)Erases, Shift+drag erases a line—
Rectangle (R)Fills a rectangle with the stampStamp options, Only empty
Fill (G)Fills the area of the same tileStamp options, Only empty, Across edges, Flipped too
Shapes (L)Draws a line, rectangle, ellipse or filled ellipse. Shift keeps lines at 45° and shapes squareThe shape, stamp options, Only empty
Select (M)Selects a rectangle of tiles—
Magic Wand (W)Selects joined tiles like the clicked one, Ctrl+click all of them in the layerWhole layer, Across edges, Flipped too
Eyedropper (I)Picks a tile—
Hand (H)Moves the view—

Across edges goes on at the other side of a repeating layer, Flipped too counts a flipped tile as the same one. The stamp options are:

  • Flip (X, Y) and turn (Shift+R) the stamp. Turning moves the tiles around, but the tiles themselves can only be flipped.
  • Random tiles (Z) paints a random tile of the stamp in each cell — the same one each time it's painted over, Shift+Z rerolls — optionally flipped at random. Weights of Tiles sets how often each tile comes up.
  • Tiles — paint the tiles As they are, or Normal, Translucent or Invisible, as the tile modifiers of the original game, or with Heat, the heat effect of JJ2+: every row of pixels of the tile wavers left and right, as if seen through heat (only in a layer drawn as tiles, and only on backends with shaders). Only modifier changes only the modifier.

The Select menu:

  • Invert Selection, Grow, Shrink and Select All Tiles Like These.
  • Selected tiles are moved by dragging them, or by Shift+arrows.
  • Mirror Selection flips the tiles and, on the sprite layer, the events on them, with their parameters changed as they should be — springs, directions, offsets. Mirroring Swaps Teams of Events also swaps the first two teams, for symmetric multiplayer levels.
  • Copy Tiles and Events (Ctrl+Shift+C) copies the selected tiles of the sprite layer with the events on them, off the grid too. With the event tool, it copies the selected events with the tiles under them. Ctrl+V makes both the brush, the events are placed with their tiles. Ctrl+C still copies only the tiles, or only the events while the event tool is chosen.
  • Copy All Layers and Paste All Layers (no keys by default) copy the area of every visible, unlocked layer with its events. Pasted warps and triggers get new identifiers.

Copied tiles and events also go to the system clipboard as text, so they can be pasted into another level, or into the game running elsewhere.

Find and Replace

Find and Replace (Ctrl+F):

  • Tiles — finds the brush tile, flipped the same way or any way, in the current layer, in all layers, or only in the selection. Select selects them, Replace puts another tile in, keeping its flips and translucency.
  • Events — finds events of a kind, optionally only those with the values of the parameters ticked, and replaces them with another kind. The parameters are edited as in the event properties. The new events get the values set for them. With Keep matching parameters, they keep the values of parameters of the same name, which are dimmed then. Selected takes the kind and the parameters of the selected event.

Replacing events asks first. Each replacement is one undo step.

Terrain tools

  • Smart Brush (T) — the left button paints ground, the right one removes it. Each tile is chosen by what other levels of the tile set put there with the same neighbors, so blocks get their tops, edges and corners automatically. The levels are read the first time it's used (the status bar shows the progress) and cached in Cache/Editor/Adjacency/.
  • Choose Tiles by Their Neighbors (Edit menu) picks the selected tiles again the same way. Fill Selection with Ground fills the selection with ground.
  • Beautify Selection (Edit menu) replaces the selected tiles with ones that fit their neighbors better and have the same collision mask, so the collision stays exactly the same.

Terrain rules and prefabs

Terrain Rules in the Edit menu shows the tile used for each of the 47 ways the surrounding cells can be solid, and lets you override it:

  • Click assigns the brush tiles — several of them alternate. Right-click restores the learned tile. The overrides are used first by the Smart Brush and the Ground Line tool.
  • A tile set can have several terrains, such as ground, wall or cloud.
  • Slopes tags a tile as a slope with heights at both edges, or excludes it from ground.
  • Try It is a small sandbox. Coverage shows which of the 47 still need a rule, in red.

Prefabs in the Edit menu keeps named stamps for a tile set: Save Brush saves one, Use makes it the brush. Save Copy of All Layers keeps a copy of all layers with events, such as a warp pair or a base for Capture the Flag.

Rules and prefabs are stored in Tilesets/<name>.rules. The game includes rules for castle1, diam1 and jungle2.

Ground Line tool

The Ground Line tool (P) lays ground along a line. Click to add points (Ctrl snaps to tile corners), right-click to lay it.

  • The tiles along the line get the ground pieces whose masks follow it best, filled down to existing ground.
  • Lays — Ground below the line, Ceiling above it, a Band as thick as the Depth, or a closed Shape. Smooth makes it a curve.
  • The line stays editable: drag a point, click the line to add one, Shift+click to remove one, right-click the line to remove its ground. Tiles edited by hand since are left alone.
  • Its collision surface is drawn over it, green where it matches, red where it misses.
  • Make Tiles Along Ground Line (Edit menu) makes tiles of this level so the collision follows the line exactly. Make Ground Line from Selection traces existing ground, so it can be reshaped.

Events

Everything that isn't a tile — starts, enemies, pickups, springs, warps, tile behaviors — is an event. Events sit on tiles of the sprite layer, one per tile.

The Events tab lists them by category, with a search box. Clicking one chooses it with the event tool (Q). Events the game doesn't use are found only by searching. The strip above the list holds favourite and recent events.

Placing and selecting

  • Click an empty tile to place the event, drag to keep placing. Shift places over existing events.
  • The Mode in the toolbar places by Click, in a Rectangle, or by Fill over the joined tiles of the same kind — handy for vines, hooks and hurting tiles. The Select mode only selects.
  • Click an event to select it, Ctrl+click to toggle it, Ctrl+drag to select a rectangle. Drag the selected events to move them. In the Select mode, a drag selects a rectangle, Shift adds and Ctrl removes.
  • The right button erases. Alt+click picks an event with all its parameters.
  • Del, cut, copy and paste work on the selected events. A warp copied with its target, or a trigger with its tiles, gets new identifiers each time it's pasted.
  • Fill Selection with Event in the Select menu places the event on the selected tiles that have none.

The right panel shows the parameters of the selected events, or of the event to place. A change applies to all selected events of the same kind, and a value that differs among them is shown as mixed. Events of different kinds share only their difficulties and flags. Raw parameters show all 16 bytes.

  • Some fields are shown only for some values of another field.
  • A crate or barrel edits the parameters of what is inside it.
  • A field that refers to another event: choose Choose in the Events tab, then click the event in the Events tab. Esc cancels.
  • An End of Level whose next level is 0 shows where it leads by default.
  • A selected Ambient Sound plays its sound.

A single selected event has white handles for its values that are a place in the level — the radius of a light, the width of a bridge, the length of a chain, camera limits, the water level. A tube or a force has an arrow of its speed. Shift snaps it to 8 directions. Dragging a handle is one undo step.

In the Edit menu, Select Events of the Same Kind selects all events like the selected one, and Copy Event to Every Tile Like Its Own places it on every tile that shows the same tile — place a hook once and copy it to all hook tiles.

Two more tools place events:

  • Measure (U) — drag to measure in pixels and tiles. It draws the arcs of jumps — walking, dashing, the double jump and the copter — and tells the easiest one that reaches. With Stop at walls, the arcs stop at walls. Started on a spring, it shows roughly where the spring throws the player.
  • Events Along Path (K) — places the event evenly along a path, such as a row of coins. Click to add points, right-click to place them. Options: Distance, Smooth, On tiles.

Event list

Event List (F3) lists all events of the level, with their position, difficulties and main parameters, filtered by what is typed. Click to select an event and move the view to it, Ctrl+click or Shift+click to select more and change them together.

How events look

Events look like the objects they create, with a corner mark in the color of their category. Others are boxes in that color with their name. Badges show the difficulties (bottom right, if not all three), that it respawns (blue, top right), and multiplayer only (purple, bottom left).

A level with a JJ2+ script shows the objects the script gives other sprites, such as the pickups of its own weapons, with those sprites. The script runs for it in a hidden copy of the level when the level is opened and whenever the script changes, only until its onLevelLoad() returns, and nothing else it does reaches the editor. Show Script Graphics in the View menu turns it off. Builds without scripting don't have it.

Arrows link warps to their targets (blue, a red cross means no target) and race waypoints in the order they're run (green). A selected light shows its reach, a trigger the events it belongs with, a water level change the new level, and a camera limit the area the camera can't reach. Events are dimmed while another layer is edited, and hidden under other tools unless Show Events (Ctrl+Shift+E) is on.

Off-grid events

Off-grid events are at any position, as levels made in MLLE can have them. They have a triangle in their corner, and the game spawns them at their exact position.

  • Ctrl+Shift+click places an event off the grid.
  • They're selected, moved (Shift snaps to tile centers), erased and picked as other events.
  • While one is dragged, X or Y held snaps only that axis to the tile center, with Shift to the nearest edge or center of a tile, as in MLLE.
  • Snap Off-Grid Events to Grid in the Level menu moves them onto their tiles.

Event catalog

The descriptions of events are compiled in, in Editor::EventCatalog (Editor/Events/EventCatalog.*.cpp). They describe the parameters as the game reads them. Each event has a type, a stable key, a name, a category, a preview (Editor::ResolveEventPreview()) and its parameters (Editor::EventParamField) — bits of the 16 bytes of parameters, with how they're edited, when they're shown, what mirroring does to them, and their handles. Bytes no parameter covers are kept as they are.

Events described outside the game

A level script can describe events the game doesn't know, one JSON object per line of its .j2as file:

#pragma editor-event {"Type": 300, "Key": "MyThing", "Name": "My Thing", "Category": "Enemy", "Preview": {"Metadata": "Enemy/Turtle", "Animation": 1}, "Params": [{"Name": "Speed", "Type": "UInt", "Offset": 0, "Bits": 4, "Max": 15, "Default": 3}, {"Name": "Mode", "Type": "Enum", "Offset": 0, "Shift": 4, "Bits": 2, "Options": ["Walk", "Fly", "Swim"]}]}

Event packs for all levels are .json files in Editor/Events/ of the content or the user content — an event, an array, or an object with an "Events" array. The level script wins over event packs, and those over the built-in events. They're read when a level is opened, and the script again whenever it's saved. Read Event Descriptions Again in the Level menu reloads them. A description that can't be used is skipped and reported in Check Level.

An event of the original game the game has no use for is kept as the passthrough event, for the level script. With "Original" in place of "Type", such events with that number are shown and edited as described. The descriptions MLLE keeps in a level script are read too, as such events — lines as in JCS.ini, which the "#pragma editor-event" lines of the same events replace:

///@Event 240=Warp Target |+|Area      |Warp   |Target |WarpID:8|Character:{Any,Jazz,Spaz,Lori}2|Color:{Yellow,Blue}1|Par:5

A parameter there is Name:8 (8 bits), Name:-8 (signed), Name:c1 (a check box) or Name:{A,B,C}2 (named values), one after another from the first bit of the parameters of the event.

The events of the original game the level script describes are also offered in the Events tab, and placed as a converted level has them — as the passthrough event, or as the event of the game an event of that number becomes, as when a script gives a food of the original game a behavior of its own. Such an event is then shown as described, with its parameters in the bits of the original event that the last bytes keep for the scripts. A line with nothing after = hides the event of that number, as it does in MLLE — the event it becomes in the game is then found in the tab only by searching:

///@Event 100=

Format of event descriptions

Keys are in PascalCase, as are the names given as values, which are matched regardless of case. Comments are allowed. An event may contain:

  • "Type" : integer Type of the event, 1 to 65279 (the types from 65280 on stand for the events of the original game in the Events tab)
    • A type of an event the game knows describes it again, for a level script that uses it in another way
  • "Original" : integer Number of an event of the original game, 1 to 255, in place of "Type"
    • The event is placed as the passthrough event, the number is its first parameter, shown as "Event"
    • Parameters start in the next byte, and each follows the previous one unless "Shift" says where it is, as they were in the original game
  • "Name" : string Name of the event, required
  • "Key" : string Stable name of the event (default is "Ext<type>" or "Original<number>")
  • "Category" : string Category in the event picker: "Basic", "Scenery", "Modifier", "Area", "Trigger", "Warp", "Light", "Environment", "Enemy", "Boss", "Collectible", "Container" or "Other" (default)
  • "Description" : string Description shown in the tooltip
  • "Traits" : array What the event is: "Object" (default), "TileModifier", "Area" and "MultiplayerOnly"
  • "Preview" : object Sprite shown in the level and in the picker
    • "Metadata" : string Path of the metadata in the content, e.g. "Enemy/Turtle", a box with the name is shown without it
    • "Animation" : integer Animation of the metadata
    • "FlipX" : bool Whether the sprite is mirrored
    • "Offset" : array Offset of the sprite as [x, y] in pixels
  • "PreviewByParam" : object Another sprite for some values of a parameter
    • "Param" : string Name (or index) of the parameter
    • "Cases" : array Objects with a "Value" (or "Default") and the keys of "Preview"
  • "Params" : array Parameters, bits of the 16 bytes of parameters of the event, each may contain:
    • "Name" : string Name of the parameter, required
    • "Type" : string How it's edited: "UInt" (default), "Int", "Bool", "Enum", "Flags", "Event" (type of another event), "Text" (text of the level), "Trigger", "Warp", "String" or "Contents" (another event inside)
    • "Offset" : integer Byte the parameter starts at, required (default is 1 with "Original")
    • "Bits" : integer Number of bits, up to 32 (default is 8, 1 for "Bool", 16 for "Event")
    • "Shift" : integer Bit of the first byte the parameter starts at (default is 0)
    • "Length" : integer Length in bytes of "String" and "Contents"
    • "Min", "Max" : integer Range of the value (default is what the bits can hold, cut to -16777216 to 16777216)
    • "Default" : integer Value of a newly placed event
    • "Unit" : string Unit shown with the value: "Pixels", "Tiles", "Frames", "Seconds", "Percent" or "Degrees"
    • "Scale" : integer The value is shown multiplied by it
    • "Description" : string Description shown in the tooltip
    • "Options" : array Labels of "Enum" values from 0 on (of "Flags" bits from 1 on), or objects with a "Label" and a "Value"
    • "ShowIf" : object The parameter is shown only while another one's value matches, with the "Param" and "Equals", "NotEquals" or "AnyBits"
    • "Hidden" : bool Whether the parameter is never shown
    • "MirrorX", "MirrorY" : What mirroring the event does to the value, "Negate", "Toggle", {"Swap": [a, b, ...]} (values or bits of flags swapped in pairs) or {"SwapWith": "<param>"}
    • "Team" : bool Whether the value is a team that swapping teams swaps
    • "Gizmo" : string Handle in the level, "Radius", "Length" (down), "Width" (to the right), "OffsetX" or "OffsetY"
    • "GizmoStep" : integer Pixels for a unit of the value of the handle (default is 1)
    • "Link" : object Events with the same value in the same "Channel" are linked by lines, with the "Role": "Source", "Target" or "Peer" (default)
      • Channels of the game are "Warp", "Trigger" and "RollingRock"
    • "Direction" : object The values of a "Group" (0 to 3) are drawn as an arrow, each along its "Axis" ("X" or "Y"), "Negative" for the other way
    • "TypeParam" : string Of "Contents", the parameter with the type of the event inside, it can't be inside of the contents

Example event pack

{
    /* The file can contain both multi-line comments */
    // and single-line comments

    /* The file can also be a single event or an array of events instead */
    "Events":
    [
        /* A new event a level script spawns by its type, the type of an event the game knows would describe
           it again, for a level script that uses it in another way */
        {
            "Type": 300,
            "Key": "MyTurtle",
            "Name": "My Turtle",
            "Category": "Enemy",
            "Description": "A turtle the level script makes walk, fly or swim",
            "Preview": { "Metadata": "Enemy/Turtle", "Animation": 1 },
            /* Another look for some values of a parameter */
            "PreviewByParam": {
                "Param": "Mode",
                "Cases": [
                    { "Value": 1, "Metadata": "Enemy/TurtleTube", "Animation": 0 },
                    { "Value": "Default", "FlipX": false }
                ]
            },
            "Traits": [ "Object" ],
            "Params": [
                { "Name": "Speed", "Type": "UInt", "Offset": 0, "Bits": 4, "Max": 15, "Default": 3, "Unit": "Pixels",
                  "Description": "How fast it moves" },
                /* Options are values from 0 on, or objects with their own values */
                { "Name": "Mode", "Type": "Enum", "Offset": 0, "Shift": 4, "Bits": 2, "Options": [ "Walk", "Fly", "Swim" ] },
                { "Name": "Height", "Type": "Int", "Offset": 1, "Bits": 8, "Min": -64, "Max": 64,
                  /* Shown only while "Mode" is "Fly" */
                  "ShowIf": { "Param": "Mode", "Equals": 1 },
                  /* A handle in the level, 4 pixels for a unit of the value */
                  "Gizmo": "OffsetY", "GizmoStep": 4, "MirrorY": "Negate" },
                { "Name": "Facing", "Type": "Enum", "Offset": 2, "Bits": 1, "Options": [ "Right", "Left" ], "MirrorX": "Toggle" },
                /* Events with the same value in the same channel are linked by lines */
                { "Name": "Nest", "Type": "UInt", "Offset": 3, "Bits": 8, "Link": { "Channel": "MyNests", "Role": "Source" } }
            ]
        },

        /* An event of the original game the game has no use for, kept as the passthrough event for the level script;
           its number in the original game is the first parameter, the parameters it had there follow from the next
           byte, one after another unless "Shift" says where one is */
        {
            "Original": 254,
            "Name": "Color Block",
            "Category": "Scenery",
            "Description": "Event 254 of the original game, a block the level script colors",
            "Params": [
                { "Name": "Color", "Type": "Enum", "Bits": 2, "Options": [ "Red", "Green", "Blue", "Yellow" ] },
                { "Name": "Solid", "Type": "Bool" },
                { "Name": "Delay", "Type": "UInt", "Bits": 5, "Unit": "Seconds" }
            ]
        }
    ]
}

Checking the level

In the Level and View menus:

  • Statistics — counts for each difficulty: enemies, bosses, gems and coins (also those in crates), food, carrots, extra lives, ammo, checkpoints, warps, exits and starts. Click a count to select those events. Below, the results of the play-tests.
  • Check Level — likely problems, see Check Level.
  • Show Where the Player Can Get (Ctrl+Shift+R) — tints green every tile the player can reach from the start, by walking, jumping, swimming, climbing, springs, poles, tubes and warps. It errs on the safe side, so some routes may be missing. The View > Reachable Area submenu has it, chooses the character, and can add the multiplayer starts. Only in builds with multiplayer.
  • Show Game Screen Frame — a frame of what the game shows: the game view, 4:3, 16:9, or half of a split screen, in the View > Game Screen Frame submenu.
  • Compare with Saved — marks the tiles and events that differ from the saved file.

Check Level

Check Level lists likely problems — errors in red, then warnings and information, each kind with a button that shows or hides it. The list follows the changes of the level. Show moves the view to a problem, and Check Again checks everything again, including what the player can reach.

  • Starts — no Jazz start, characters without a start of their own, no multiplayer start in a multiplayer level.
  • Warps without targets, targets nothing leads to, coin warps needing more coins than there are, missing texts, triggers that do nothing, parameters out of range, unknown events, layer effects that can't work.
  • No reachable exit, and pickups or race waypoints that may be out of reach.
  • Events inside solid tiles, next levels or music that don't exist, and more tile IDs than a script can use (4096).
  • Multiplayer — fewer than 4 starts, bases for Capture the Flag missing or doubled, and gaps in the order of race waypoints.

Some problems have a button that fixes them: Remove Warp, Add Warp Target, Add Start, Add Multiplayer Start and Add CTF Base.

Playing the level

The level can be played right from the editor, saved or not. The view flies to the player and the game is revealed in a growing ring, with a bar at the top to get back.

  • Play (F5) — continues the last play-test where it was left. Tiles and events changed meanwhile are applied to it. Changes it can't take — starts, warp targets, generators, events that change what a tile does, off-grid events, multiplayer, or another character, difficulty or game mode — restart the level where the player was. Played alone at the same difficulty, the player keeps the lives, score and weapons, and what was collected or destroyed stays so.
  • Play Here (Shift+F5) — starts at the pointer, or at the view center from the menu.
  • Play from Start (Ctrl+F5).

The character, difficulty and game mode with the number of players are chosen in the Character, Difficulty and Game Mode submenus of the Play menu. Reforged Gameplay and Allow Ledge Climbing there start as the game is set up and change only how the level is played until the editor is closed. F5, Back to Editor in the pause menu, the exit or a game over return to the editor, with the view where the player was. Nothing is saved. Finishing a level that has a next one offers Edit It (opens the next level in the editor), Play On (plays the next level as the episode would) or Stay Here.

The Play menu can also play local splitscreen multiplayer — Cooperation, Battle, Team Battle, Race, Treasure Hunt or Capture the Flag, with 1 to 4 players — to test multiplayer starts, laps and bases.

Debug toggles

In the Debug button of the bar while playing. The keys can be changed in Keyboard Shortcuts.

KeyToggle
F5Back to Editor, keeping the play-test to resume it
F9Slow Motion — half speed, quarter speed, normal
(none)Show Hitboxes of players, enemies, collectibles and solid objects
(none)Show Event Zones — the tiles of modifiers, areas, triggers and warps
F7 / F8Stop Time of Level / Next Frame
F6Move Player to Pointer

Paths of play-tests

After a play-test, the path of the player is drawn over the level — thicker where faster, with red marks where it died. Ctrl+L toggles it. The last 8 paths are kept with the level: Show Deaths in Play-Tests shows where the player died in them, Forget Paths of Play-Tests removes them, and Statistics tells the best time.

Files

  • Save — writes the level. A level from "Cache/" is saved as a new file instead, since the cache is made again from the original levels.
  • Save As — saves into the user content (see File locations), or into "Content/" if it can be written. The level script is copied along. If the level exists elsewhere too, the editor tells which copy the game loads.
  • Export — saves for publishing, without what only the editor uses, after checking for problems such as a missing start. Don't allow editing marks the file so the editor won't open it. It's a courtesy, not a protection, so keep an editable copy.
  • Export Package — a ZIP archive to publish, see Export Package.

A failed save, such as on a full disk, never damages the file that was there.

Recovery

While a level has unsaved changes, a recovery copy is written every minute into "Editor/Recovery/" of the user content (or of the configuration directory where no content can be written to), with the undo history. When a level with a newer copy is opened, the editor offers to restore it. Recovery Copies in the File menu lists all copies, also of levels that were never saved.

Export Package

Export Package in the File menu writes a ZIP archive laid out as the content of the game, ready to be unpacked into the user content:

  • manifest.json — "format" (1), "game", "name", "author", "version", "description", "tags", "levels", "episode" and "files",
  • preview.png,
  • Episodes/<episode>/<level>.j2l — exported, or as saved with Keep what only the editor uses, and with All levels of the episode, the other levels and the .j2e file too,
  • the scripts of the levels, the tile sets and music they use that aren't of the game, and the event packs.

Files that are needed but missing are listed in red.

Script, files changed elsewhere and the lock

  • Edit Script in the Level menu opens the script of the level (<level>.j2as) in the program the system has for it, or in the one named by "ScriptEditor" in the settings (see Settings). A level without a script gets one made from a template. Once the script is saved, the events it describes are read again.
  • A tile set changed by another program is noticed, and Load Again shows the change.
  • A level open in the editor has a lock file next to it, <level>.j2l.lock. Opening a level that another editor has open warns first.

File dialog

The buttons at its top are the places the game reads files from. On a desktop, Computer after them browses the whole computer, the drives on Windows. A path can be typed into the row above the list, Enter goes there, or to the folder of a file, which is chosen then. Files the level refers to by their place in the game, such as the next level or the music, can be picked only from the places of the game. Files and folders the system hides, or whose names start with a dot, are listed only with Show hidden files at the bottom.

In a browser

The web version can't open local files directly: From This Computer in the open dialog uploads a level, and saving also downloads it. Settings and recovery copies are kept in the browser storage.

Settings

The settings are stored in "Jazz2.Editor.json" in the configuration directory (Editor::EditorSettings). The file can be edited by hand, best while the editor is closed. A value of a wrong type or out of range falls back to the default.

KeyMeaning
"UiScale"Interface scale, 0 by the window size
"Layout"0 by the window size, 1 desktop, 2 compact
"Expert", "ShowGrid", "PauseLayerMovement", "EventsOnTop", "OverriddenAssets", "ReadableFont", "ReducedMotion"Expert Mode, Show Grid, Pause Layer Movement, Show Events Over All Layers, Show Overridden Assets, Readable Font, Reduce Motion
"Theme"0 the usual theme, 1 high contrast
"ScriptEditor"The program Edit Script opens scripts in, empty for the one the system has. A path, or a name found in PATH, with optional arguments where {file} stands for the script, otherwise it goes last. A path with spaces followed by arguments is in quotes. Set only in this file
"Tool", "PickerEvents"Tool chosen and whether the picker showed the events when the editor was left, any level opens with them
"TileColumns"Tiles in a row of the tile picker, 1 to 32
"RightPanelWidth", "LayerListHeight", "PickerPanelWidth"Sizes of the panels
"PickerPanelPlacement", "RightPanelPlacement"Whether a panel floats and where: "Floating", "X", "Y", "Width", "Height"
"PlayCharacter", "PlayDifficulty", "PlayGameMode", "PlayPlayerCount"How the level is played
"Tools"Tool options: "AcrossSeams", "IgnoreFlips", "OnlyEmpty", "WandGlobal", "Shape" (0 line, 1 rectangle, 2 ellipse, 3 filled ellipse), "EventMode" (0 click, 1 rectangle, 2 fill), "MeasureArcs" (bits: 1 walk, 2 dash, 4 double jump, 8 copter), "MeasureCollisions", "MirrorSwapTeams"
"PlayTest"Play-test options: "TimeScale" (0.05 to 4), "ShowHitboxes", "ShowEventZones", "ShowDeaths", "ReachCharacter" (0 any, 1 Jazz, 2 Spaz, 3 Lori), "ReachFromMpStarts"
"ShowScreenFrame", "ScreenFrameKind"Show Game Screen Frame: 0 game view, 1 4:3, 2 16:9, 3 split screen
"CheckLevelFilter"What Check Level shows, bits: 1 errors, 2 warnings, 4 information
"RecentEvents", "FavoriteEvents"Event types in the strip of the Events tab
"TileFavorites"An object by tile set name, each with "Recent" and "Favorites" tile indices
"RecentFiles"Files listed in the File menu, the most recent first

Where the view was in each level is stored in the level itself, in the "edoc" chunk.

Level and tile set formats

All reading and writing of levels — by the converter, the game and the editor — goes through Formats::LevelReader and Formats::LevelWriter, and of tile sets through Formats::TileSetFile. Formats::LevelFile describes the layout of a level.

The editor holds a level as an Editor::LevelDocument. Loading and saving is lossless — the file comes out byte for byte the same. Tiles are referred to by tile set and index, so adding a tile set or an animated tile doesn't change any layer. Every file is written to a temporary file first and replaces the target only once it's complete (Utils::AtomicFile).

Chunks

A level can carry optional data at the end of its body, in chunks tagged by four characters. Readers skip chunks they don't know. The case of the first two letters tells what a chunk is (Formats::LevelFile):

  • First letter lowercase — editor-only: the game never reads it, and export drops it.
  • Uppercase and lowercase, such as "Gscr" — critical: the level can't be played correctly without it, so a reader since 4.0.0 that doesn't know it refuses the level (Formats::LevelFile::IsCriticalChunk()). Older readers skip it, so it may only hold data whose absence breaks nothing worse than the look of the level.
  • Both uppercase, such as "PRVW" — ancillary data of the game, skipped by a reader that doesn't know it. All chunks so far are ancillary or editor-only.
TagContents
"PRVW"Preview for the custom level list, kept on export: u16 width and height, then the pixels row by row as opaque RGBA in the QOI-based image content of the game's files (Compatibility::JJ2Anims::WriteImageContent()). The writer sets LevelFlags::HasPreview with it
"LPRP"What the records of the layers have no room for, kept on export (Formats::LayerPropertiesChunk): varuint count, then for each layer varuint index in layer order, varuint size and its fields, each as u8 kind, varuint size and the value — 1 the name (UTF-8), 2 the number in the original game (u8 1 to 8), 3 how the sprite layer is drawn (u8 renderer type and the 4 bytes of the color), 4 the parameters of a sky, tunnel, wave, cylinder or reflection its color has no room for (f32 fade X and Y or the amplitudes of a wave, u8 fade, u8 flags — 1 spiral, 2 window of the layer, 4 the layer, 8 half size, 16 swapped angles of a wave, 32 the perspective of JJ2+, 64 the ground only — and f32 inner speed X and Y and inner auto speed X and Y, then u8 the additional palette the texture is drawn through plus 1, 0 for none, as SPRITE::MAPPING of JJ2+), 5 a texture of its own (256×256 palette indices), 6 the blend (u8 blend and its parameter). A field of an unknown kind is skipped. Written only for layers without the defaults
"LSET"Settings of the level its properties have no room for, kept on export (Formats::LevelSettingsChunk): fields, each as u8 kind, varuint size and the value — 1 the colors of the water (RGB at the surface and at the bottom of the view), 2 how players move under water (u8 0 by the depth, 1 swimming, 2 low gravity), 3 how the ambient lighting goes with the water (u8 0 full light while the water is in view, 1 the ambient lighting everywhere, 2 darker the deeper under the water), 4 the layer the water is drawn in front of (varuint index plus 1, 0 hides the water; without it the water is in front of all layers), 5 the speed the water moves to a new level at (f32 pixels per second), 6 rules (u8 flags — 1 a bonus warp doesn't turn the coins into gems, 2 objects of generators take their parameters from where they land). A field of an unknown kind is skipped. Written only for settings without the defaults
"LTXT"Translations of the level texts, kept on export (Formats::LevelTextsChunk): u8 version (1), varuint number of languages, then each as a varuint size and a record of str8 language, varuint number of texts, and for each varuint text number, varuint length and UTF-8 text
"SCRD"Data of a level for its script, kept on export (Formats::ScriptDataChunk): sections, each as u8 kind, varuint size and its bytes — 1 the texts of the level as the original game had them, 2 the recolored sprites. Written by the converter for a level with a script
"WPNS"Weapons of the level, kept on export (Formats::WeaponsChunk): u8 version (1), i16 argument of the hook of the weapons of the script, varuint number of weapons, each as u8 weapon, varuint size and its properties (u8 id, varuint size and the value; one that isn't there is as the weapon of the game has it), then varuint number of images, each as varuint size, frame width, height and count, f32 speed of the animation, i16 hotspot and a palette index of each pixel. A newer version is left alone by the game and kept as it is by the editor
"ela2"Layer editor state (Editor::LevelDocument::LayerStateChunk): u8 version (1), varuint number of layers, varuint bytes of each layer, then those bytes of each layer — hidden and locked flags, and the editor opacity if any layer has one
"ann2"Bookmarks and notes (Editor::Annotation): u8 version (1), varuint count, then each as a varuint size and a record of i32 X and Y in pixels, u8 bookmark number (0 = note), varuint length and text. Version 2 adds u32 color, the author, i64 time, u8 flags (1 = done) and the replies, each with its author, time and text
"spl2"Ground lines (Editor::TerrainSpline): u8 version (1), varuint count, then each as a varuint size and a record of i32 layer, u8 depth, u8 kind (ground, ceiling, band, shape), u8 flags (1 = smooth), varuint point count and f32 X and Y of each in layer pixels, varuint count of written tiles and for each i32 X and Y, then the written and previous tile, each as u16 index, u8 source and u8 flags
"edoc"View state, written on every save so the level opens as it was left (Editor::DocumentViewState): u8 version (1), u16 flags (camera, grid, events, play path, flat layers, play settings), f32 center X, Y and zoom relative to the game's, i32 layer, u8 mask mode, character, difficulty, game mode and players
"ppth"Paths of the last play-tests (Editor::PlayPathHistory): u8 version (1), then up to 8 paths, each with its time, whether the level was finished, and up to 4096 points, each as a difference from the previous one with the speed of the player there (a varuint in 1/16 px per frame, up to 1024 px per frame)
"pkgi"What Export Package says of the package: u8 version (1), then a JSON object
"rcov"Path of the level a recovery copy belongs to (recovery copies only)
"rhst"History of changes of a recovery copy (Editor::CommandArchive): u8 version (3), a fingerprint of the layout of the records and of how snapshots are written, varuint number of commands, of those done and of those done when it was saved plus one, then each command as a varuint size and its data, in the native byte order (recovery copies only)

A versioned chunk is read for any version but 0. A newer version only adds fields at the end of a record, which a reader skips. "edoc", "PRVW", "ppth", "rcov" and "rhst" are made anew by the editor, so undo never brings them back.

Limits and checks

Levels and tile sets can come from anywhere, so the readers check everything before relying on it, and refuse what no editor would write:

  • A layer of more than 65535 tiles on a side, more than 2²⁶ tiles in a layer or 2²⁷ in all layers, a decompressed body over 1 GiB, an embedded tile set or a chunk over 256 MiB, more than 65535 off-grid events, 65536 overridden tiles or masks, or 65535 chunks, and a varuint of more than 5 bytes or a value over 32 bits.
  • Offsets and speeds of a layer, and parameters of a textured layer, that aren't finite are replaced by their defaults when a level is read or written, the level itself is still read.
  • Flag bits that would change the layout of a record (those of an extra tile set outside of 0x07) and a layer kind above the sprite layer (2) make a level unreadable since 4.0.0, instead of misread. The reserved event flag 0x08, which 3.9.0 could write, is dropped instead.
  • A tile set path must be relative and must not go up, and no part of it may end with a dot or a space or be a device name of Windows (Formats::LevelFile::IsSafeTileSetPath()).
  • A tile set has one or four channels, a whole number of tiles at most 32768 pixels wide, at least one tile, and a body that fits the file (Formats::TileSetFile::Validate()).
  • A savegame of a level whose size changed since is refused, instead of restored into the wrong places.

LevelFlags::NotEditable is a courtesy to the author, a single bit anyone can clear, not a protection.

Verifying the formats

The verify-formats command of AssetPacker reads every level and tile set in a directory and writes it back into memory, which must give the same file byte for byte (or the same content, for files written by other tools). With --sweep-truncated, every file is also read cut short at many places, which must never pass for a different level. fuzz-formats tests the readers with mutated files, and level-to-text writes a level as text for version control (see Command-line reference).

AssetPacker verify-formats <directory> [--sweep-truncated]
AssetPacker fuzz-formats <directory> [<findings directory>] [--iterations=N] [--seed=N]
AssetPacker level-to-text <level.j2l> <level.txt>
AssetPacker text-to-level <level.txt> <level.j2l>

Testing the editor

Debug builds have an editor self-test. /editor-selftest loads every level in "Cache/Episodes/" (or a given directory) into an Editor::LevelDocument and checks that saving gives the same file, that editor data survives saving and loading while export drops it, that random changes undone and redone give the original and the changed level, and that Check Level runs. It also validates the event catalog and tests the parts of the editor on their own — from the PNG codec and the quantizer to the history, recovery copies, the tools and the shortcuts. Results go to the log, then the game quits.

Jazz2 /editor-selftest
Jazz2 /editor-selftest --unit

With --unit only the tests that need no game data run, so no converted game is needed: the tools are driven through a host of their own over a document (Editor/Tests/FakeToolHost.h), and the level shown is checked to follow the document by its layers only. Sources/Jazz2/Editor/Tests/CheckIncludes.ps1 checks that the folders of the editor include each other only in the allowed directions, CI runs it before the build.

Debug builds also run /console commands once the editor is open, in order, so it can be driven without input — such as to take screenshots. Positions are in window pixels.

CommandWhat it does
/jump <x> <y> [scale], /fly <x> <y> <scale>Move the camera at once, or fly it there
/zoom <scale>, /fitZoom, fit the whole level
/view <x> <y> <percent>Center the view at a position (c c for the middle of the level) at a zoom as the status bar shows it
/drift <dx> <dy> [zoom] [frames]Move the view by so many screen pixels every frame, zooming out by the factor and back every so many frames. /drift 0 0 stops it
/lod <on\|off\|auto\|stats>Draw the layers as cached images always, never, or by the zoom. stats logs the pixels per tile, wanted and used, and the memory
/perf reset, /perf log <label>Start averaging the frame statistics, log them
/layer <index>, /hide <index>, /layersEdit a layer, hide it, log the layers
/paint <layer> <x> <y> <[source:]tile> [width] [height]Paint tiles of the default tile set, or of a source numbered as in /addtiles
/undo, /redo, /action <id>Undo, redo, run a menu action
/click <x> <y>, /rclick <x> <y>, /drag <x1> <y1> <x2> <y2>, /hover <x> <y>, /wheel <x> <y> <amount>Pointer input
/press <x> <y>, /move <x> <y>, /release <x> <y>A drag over several commands
/key <name>Press enter, escape, delete, f5, left, right, up, down, space, ctrl, shift or alt
/keydown <name>, /keyup <name>Hold or release a key
/type <text>Type into what has the keyboard focus, a space written as +
/focus [back]Move the keyboard focus as Tab or Shift+Tab does
/gamepad <x> <y>, /radial [<x> <y>]Use the gamepad with its cursor at a position. Show the tool ring, or point at a tool of it
/touch <down\|pointerdown\|move\|pointerup\|up> <id> <x> <y> ...A touch event in screen pixels, the finger that came or went given last
/keyboardShow the editor's own on-screen keyboard
/theme <default\|contrast> [still]Apply a theme, with reduced motion, not saved
/safearea <left> <top> <right> <bottom>Set the Safe Area of the game in percent, as its graphics options do
/keymap <default\|jcs\|mlle>Apply a set of shortcuts and save it
/renderer <type> [red [alpha]]Set the renderer of the current layer, see Tiles::LayerRendererType (10 sky, 11 tunnel, 14 wave, 15 cylinder, 16 reflection), and optionally its color
/textured <x> <y> [fade [flags]]Set the parameters of a tunnel, cylinder or reflection of the current layer that its color has no room for (Formats::TexturedLayerParams)
/innerspeeds <x> <y> <auto x> <auto y>Set the inner speeds of a reflection drawn only where the layer is
/addtiles <source> <image.png> [all] [dither]Add Tiles > From Image. all keeps duplicates. Source is a number as in /applytiles, level, or new:<name>
/fxtiles <source> <kind> <width> <height>Add Tiles > Effect Tiles into a source as in /addtiles. Kind is an Editor::FxTileKind
/newtileset <name> <tiles> [extra\|default\|save]New Tile Set > Empty
/importtileset <image.png> <name> [extra\|default\|save] [own\|true\|match\|reduce] [dither]New Tile Set > From Image, colors kept by default
/importtilesetfile <file.j2t> <name> [extra\|default\|save]New Tile Set > From Tile Set File (.j2t)
/exporttileset <image.png>Export Image of the default tile set
/applytiles <source> [new name\|-] [palette]Save Tile Changes into Tile Set. Source 0 is the default tile set, 1+ the extra ones. palette saves the level palette too
/tileoverride <tile ID> <index>Fill a tile with one palette entry and make it solid, in this level only
/palette <entry> <rrggbb>Set an entry of the level palette, and log how long it took
/palettemove <first> <last> <-1\|1> [keep]Move palette entries, with keep keeping the look of the level, and log how long it took
/animframe <index> <frames>Set the frame time of an animated tile
/placeevent <key> <x> <y> [bytes...]Place an event of the catalog on a tile, the bytes given replacing the first bytes of its parameters
/placeoffgrid <key> <x> <y> [delay]Place an off-grid event at a position in pixels, or with a delay in seconds, as a generator
/brush <key>, /selectevent <x> <y> [add], /eventsChoose the event to place, select (or add) the event of a tile, log the selection and the event tool
/texts, /findevents <key>Log the level texts, or up to 20 events of a kind
/links [next] [secret] [bonus]Set the next, secret and bonus level (- for none), then log them. Without arguments only log them
/check [index]Log the problems Check Level finds, or fix the one of the index
/saveprefab <name>, /exportrules <tile set>...Save the brush as a prefab. Make rules of tile sets from what the levels use the most (a space in a name written as +)
/pngtest <directory>Read every PNG in a directory, compare with a same-named .rgba file if present, write it to out/ and read it back
/preview <image.png>Write the preview the level would be saved with
/save <path>, /export <path>, /exportplayonly <path>, /autosaveSave, export, export as not editable, write a recovery copy
/restorecopy <path>Restore a recovery copy with its history
/rebuildLoad the shown level again from the document
/playring <progress>Freeze the play transition at a point between 0 and 1
/stopplay [keep]Return from the play-test to the editor, with keep keeping it to resume
/exitlevelLeave the played level through its exit
/teleport <x> <y>, /stepMove the player of the play-test to a position. Go on by one update
/playerstate [<score> <lives>]Add score and lives to the player of the play-test, and log what it has
/paths, /reach [character] [mp starts]Log the kept paths of play-tests, or how many tiles can be reached
/wait <frames>, /quitWait before the next commands, quit
Jazz2 /edit prince/castle1 /console "/jump 320 320 2" /console "/paint 2 8 8 5 6 4" /console "/wait 30" /console "/quit"