WebFun

In 1996/97 LucasArts released two games forming the Desktop Adventures series – Indiana Jones and His Desktop Adventures and Yoda Stories. Both games are 2D puzzle games, featuring a top-down view, a variety of quests and randomly generated worlds.

WebFun aims to be a faithful re-implementation of the game engine driving the Desktop Adventures series and document to its inner workings.

This documentation describes various observations made while reverse-engineering the games. Some of it applies to Indiana Jones and His Desktop Adventures as well, but due to personal preference most of the reverse-engineering efforts have been focused on Yoda Stories.

Releated Projects

The Desktop Adventures games have infected quite a few people over the years. Here are some projects with similar goals as WebFun.

Project Architecture

This section describes some of the fundamental structures underlying WebFun.

Getting Started

To set up a local development environment you'll need:

• Git to download the source code
• Node.js, version 14 or newer
• Yarn to install dependencies and run dev tasks

Get the Source Code

Open your terminal and execute the following script to download the repository:

git clone https://github.com/cyco/webfun

Install dependencies

To download and install all dependencies change into the new directory created by git clone and run yarn:

cd webfun
yarn install

Start the server

Using yarn again from the project directory you can now start a local web server. Run the following command in your terminal and the local page will be opened in your default browser.

yarn start

Now you're all set up. The development page will reload whenever a code change is detected. See Build System for a list of tasks yarn can execute for you.

When you're done hit CTRL and c on your keyboard to stop the server.

Data Sources

By default WebFun is set up to load game assets from archive.org. For local development it's often helpful to load the files from disk and speed things up a bit. WebFun uses an environment variable called WEBFUN_GAMES to determine where to find games.

To override the default configuration (stored in the file .env.defaults), you can either set it in your shell before starting the web server or create a new file .env and put the value there. The value of the variable should be a JSON encoded array of GameSource objects.

Note: Environment variables are only read when a program is started. Make sure to restart your development server after making changes to .env

The following configuration adds a local Yoda Stories installation to the default archive.org game source.

WEBFUN_GAMES=[{"title":"Yoda Stories (local)","variant":"yoda","data":"game-data/YODESK.DTA","exe":"game-data/YODESK.EXE","help":"game-data/YODESK.HLP","sfx":"game-data/SFX/"},{"title":"Yoda Stories from archive.org","variant":"yoda","exe":"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2FYodesk.exe","sfx":"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2Fsfx%2F","data":"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2Fyodesk.dta","help":"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2FYodesk.hlp"}]

Build System

WebFun uses the package manager yarn to manage dependencies and run build scripts.

The following tasks are defined in package.json and can be started using yarn <task-name> on the command line.

start -- Start a local web server for development.

By default this starts the server on localhost port 8080. You can change the hostname to listen on with the environment variable host. Some features like the service worker might require an HTTPS connection to work properly. If you place a self-signed certificate under config/ssl.key and config/ssl.pem the server will accept HTTPS connections.

Assuming you have mapped webfun.local to 127.0.0.1 in your hosts file (like echo "127.0.0.1 webfun.local" >> /etc/hosts), you can use mkcert to generate certificates that will be valid on your system like this:

# change to the project directory
$ cd webfun
# create a certificate
$ mkcert -cert-file config/ssl.pem -key-file config/ssl.key webfun.local localhost 127.0.0.1 ::1

# start the development server with the proper hostname
$ host=webfun.local yarn start

format -- Format source code files using eslint & prettier. You should always run this task before committing a code change to make sure everything is properly formatted and adheres es to the coding standards.

test -- Run basic test suite once without collecting code coverage.

test:cont -- Run unit test whenever a change is detected. This task does not collect collect code coverage for performance reasons.

test:full -- Run all tests and collect code coverage.

test:unit -- Run unit tests with code coverage enabled.

test:unit:cont -- Run unit tests with code coverage whenever a change is detected

build -- Clear build directory and run a fresh build suitable for production.

build:docs -- Build this documentation. This script requires mdbook to be installed, see documentation for details.

Webpack

Webpack is used to bundle scripts and prepare other assets like css stylesheets, fonts and copy static files in production builds. The following configuration files are used for various tasks, all of them are located in the config directory:

webpack.commmon.js -- A shared configuration that is used as a base for the dev and test configurations.

webpack.dev.js -- Configuration for the development task, the development web server with hot module reloading is defined here.

webpack.test.js -- Used for running tests

webpack.prod.js -- Defines the production build

webpack.service-worker.js -- Defines the production build for the service worker script. This is in a separate file because splitting the service worker code via chunks does not produce a file that runs in the service worker context.

Custom Plugins

WebFun uses a few custom webpack plugins. These are all single-file scripts found in the config directory.

file-list-webpack-plugin -- Creates a list of files produce during a production build and stores it in a json file. This file is used to pre-load assets when the service worker is installed.

spy-on-imports-webpack-plugin -- This plugin rewrites imports created by Webpack so jasmine.spy can be used on wildcard module imports to mock dependencies during test execution:

import * as UtilModule from "src/util";

describe("some test", () => {
	beforeEach(() => spyOn(UtilModule, "download"));

	it("starts a download", () => {
		subject.doYourThing();

		expect(UtilModule.download).toHaveBeenCalled();
	});
});

Documentation

This source for documentation is at docs and built using mdbook. You can trigger a manual build by executing the following command from the project root:

$ yarn build:docs

The resulting files are placed in build/docs/.

Mdbook also supports starting a local web server to render a live preview of changes made to the markdown files:

$ cd docs
$ mdbook serve

Plugins

Currently there are two plugins used during compilation of the documentation. You'll probably have to install them manually.

mdbook-linkcheck is included to check that all links the documentation points to are valid.

mdbook-open-on-gh adds a link to the current page on GitHub at the bottom of each page.

You can install the plugins with cargo from you command line:

$ cargo install mdbook-linkcheck mdbook-open-on-gh

Deployment

WebFun is hosted on GitHub pages using the branch release with a custom domain. The deployment process takes several steps, automated by this simple shell script:

#!/usr/bin/env bash

SOURCE="$HOME/Source/webfun"
TARGET="$HOME/Source/webfun-release"

# Stop on errors
set -e

# Clone release branch to $TARGET if it does not exist
if [ ! -d "$TARGET" ]; then
	git clone -b release git@github.com:cyco/WebFun.git "$TARGET"
fi

# Change to project root
cd "$SOURCE"

# Execute full test suite
yarn test:full

# Set environment variable to load game files from archive.org
export WEBFUN_GAMES="[{\"title\":\"Yoda Stories from archive.org\",\"variant\":\"yoda\",\"sfx-format\":\"wav\",\"exe\":\"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2FYodesk.exe\",\"sfx\":\"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2Fsfx%2F\",\"data\":\"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2Fyodesk.dta\",\"help\":\"https://cors.archive.org/download/Star_Wars_-_Yoda_Stories_1997_LucasArts/Star%20Wars%20-%20Yoda%20Stories%20%281997%29%28LucasArts%29.iso/Yoda%2FYodesk.hlp\"},{\"title\":\"Yoda Stories Demo (archive.org)\",\"variant\":\"yoda-demo\",\"sfx-format\":\"wav\",\"exe\":\"https://cors.archive.org/download/StarWarsYodaStories_1020/YodaDemo.zip/YodaDemo%2FYodaDemo.exe\",\"sfx\":\"https://archive.org/download/StarWarsYodaStories_1020/YodaDemo.zip/YodaDemo%2Fsfx%2F\",\"data\":\"https://cors.archive.org/download/StarWarsYodaStories_1020/YodaDemo.zip/YodaDemo%2FYodaDemo.dta\",\"help\":\"https://cors.archive.org/download/StarWarsYodaStories_1020/YodaDemo.zip/YodaDemo%2FYodaDemo.hlp\"}]"

# Run production build
yarn build

# Run production build of documentation
yarn build:docs

# Build docker container for local deployment
# docker build -t webfun:latest .

# Clear out target directory
rm -r "$TARGET"/*

# Copy release files
cp -r build/* "$TARGET"

# Copy screenshots for landing page
cp -r docs/screenshots "$TARGET"/docs/screenshots
cp -r assets/preview.png "$TARGET"/preview.png

# Re-create CNAME to setup custom URL for GitHub pages
echo -n www.webfun.io > "$TARGET"/CNAME

# Change directory for manual inspection
cd "$TARGET"

# Stage new version
git add .

# Give further instructions
echo ""
echo "Your relase is ready. Please inspect changes manually and the run"
echo ""
echo "   cd \"$TARGET\""
echo "   git commit -m \"chore: Update release\""
echo "   git push"
echo ""

Gameplay

The following section describes various aspects of the gameplay.

Window

Desktop Adventures are played in a window. There's no fullscreen mode and no resolution choices. The virtual world is rendered in a 288x288 pixel view. The player's item are dispalyed in an inventory table to the right. Each item can be clicked to pick up and then dropped on the scene. Below the inventory you'll find a compass that shows where the player can go, and indcator for the currently equipped weapon plus remaining ammo and a circular health indicator. As the hero takes damage this changes from green, over yellow and red to black. Once the black circle is completed the player dies and the game is over.

Color Palette

Color cycling effects in Yoda Stories

Like many older games, the Desktop Adventures engine uses a color palette for rendering. That means the colors you see on the screen are not specified directly by supplying values for the three components red, green and blue, but rather by choosing one of several pre-defined colors from a color palette.

This has two major advantages. First, the amount of data needed to store an image is drastically reduced. Instead of giving three values for each pixel of an image, only one value is enough.

Second, and more interesting nowadays, changing a color in the palette affects all pixels on screen. This allows for very efficient animations and the results for cleverly composed images can be pretty impressive. Check out this site as well as Mark Ferrari's excellent talk 8 Bit & '8 Bitish' Graphics-Outside the Box to see what can be done with palette animations.

Layout of the color palette in a hex editor

The Desktop Adventures engine uses a palette composed of 256 24-bit BGR colors, each represented as a 32-bit integer, totaling 1024 bytes. By convention, the color at index 0 is interpreted as transparent.

Here are the color palettes used by Yoda Stories and Indiana Jones and His Desktop Adventures:

Indy's Desktop Adventures	Yoda Stories

As described in the links above, the Desktop Adventures engine allows for color cycling animations to make the static environments more lively. Each game has a hard-coded set of regions in the palette that shifted to make animations. Each run is either advanced every frame (fast animations) or every other frame (slower animations).

Consult the following tables for a description of the animated regions in each game:

Color Cycles in Yoda Stories

Color Cycles in Indy's Desktop Adventures

Here are some renderings of the animations in the color palette:

Indy's Desktop Adventures	Yoda Stories

Extracting the color palette

The color palette is contained in the .data section of the game's executable Yodesk.exe as well as the demo YodaDemo.exe. Since the exact offset might differ depending on the specific version or language of the game, the easiest way to find it is to locate the string CDeskcppDoc\0 and extract the next 1024 bytes from there. In most versions the palette seems to start at offset 0x550F0.

For Indy's Desktop Adventures a reliable way to extract the color palette is to search for the ASCII string sss, move back 103 bytes and read 0x400 bytes from there.

"Free" colors

The following colors are not referenced by any tile in Yoda Stories and could be used for UI elements in restricted environments (e.g. ScummVM or gaming console).

3, 4, 5, 6, 7, 8, 196, 197, 198, 199, 206, 246, 247, 248, 249, 250, 251, 252, 253, 254

Tiles

The Desktop Adventures engine is almost entirely tile based. That means small re-usable images are used as the fundamental elements for all graphics. Maps, enemies and bullets are all made up of tiles.

Note: Only the startup image and the speech bubbles are not rendered using tiles.

Each tile is made up of 32x32 pixels image data – an array of 8-bit color palette indexes – and some flags that specify the properties of the tile.

General Attributes

Floor

Locator

If the Locator type bit is set, these flags specify the sub-type. Some tiles required to render the map scene are not marked with special bit flags, so a hard coded list of tile ids per game is required.

Item

These item flags are used in hints in the map screen, and in R2D2's help messages.

Weapon

Character

Zones

Zones are the game's maps, where the hero can walk around, solve puzzles and fight monsters.

They are made up of 9x9 or 18x18 tiles in three layers. A ground layer, and object layer, used for collision detection, and a roof layer that is rendered above the hero.

Each zone has a type that is used in the world generation process. See the following table for a list of zone types:

Additionally each zone provides lists of tiles that can be used to solve the puzzle, NPCs that can be used to trade with and tiles that the zone can drop when solved. In the world generation these items are chosen semi-randomly to create a new story every time.

On the world map neighboring zones can be visited by walking off the current zone. Additionally zones are connected through doors.

In order to make zones a little more interesting to play and replay, the game includes a custom scripting language. These actions are defined per zone.

Special points of interest on a zone are marked by hotspots. These locations mark doors, or places where an item can be used or an NPC be placed by the world generator.

In Yoda Stories, every zone belongs to one of the following planets:

Actions

Actions can make zones more interactive and dynamic. They are used for example to implement switches and in-game cut-scene animations. Each action is made up of a bunch of conditions and instructions that are executed if all conditions are satisfied.

See Scripting for a more detailed description of the internal scripting language.

Hotspots

Each hotspot has a position on the map, a type, and a single argument. Unless disabled, hotspots are triggered by placing an item, walking to the location or removing the tile at the object layer underneath the hotspot.

The following table describes the hotspot types and their purpose:

Monsters

TODO: Describe monster attributes, waypoints, drops, etc.

Scripting

The Desktop Adventures engine includes a binary scripting language. Each zone can have a number of actions. Each action consists of conditions and instructions.

Conditions and instructions have the following structure:

type Condition = {
	opcode: number,
	arguments: number[5],
	text: string?
}

See Conditions and Instructions for a description of the known opcodes for conditions and instructions respectively.

Execution

Actions are evaluated on the current zone. Once every condition of an action is satisfied all instructions are executed. Consider this mock execution engine:

function execute(actions) {
	for (const action of actions) {
		if (action.conditions.every(condition => condition.isSatisfied()) {
			for (const instruction of action.instructions) {
				instruction.execute();
			}
		}
	}
}

Registers

There are several registers available for use in scripts. All registers are local to the zone.

• counter – A simple 16-bit register
• sector-counter – 16-bit register that is propagated to connected rooms
• random – 16-bit register that can be set to random values

Conditions

The following is a list of condition opcodes used by Yoda Stories.

TODO: Check if Indy uses the same opcodes

Instructions

The following is a list of instructions opcodes used by Yoda Stories.

TODO: Check if Indy uses the same opcodes

Score

At the end of each game a score called the Indy Quotient or Force Factor is calculated. The game keeps track of the last and highest scores in the ini file at C:/WINDOWS/Yodesk.ini (see files/yodesk-ini.md) using the keys HScore and LScore, respectively.

The game combines four components to rate the player's performance:

• Time
• Solved puzzle ratio
• Difficulty
• Visited zones

Time:

const time = (baseTime in seconds + elapsedTime in seconds) / 60 - 5 * worldSize
if time <= 0 return 200
if 20 * time < 200
	return 200 - 20 * time
return 0

Puzzles:

const solved = sectors.filter(zone => zone && zone.visited).length
return solved / worldSize * 100.0

Difficulty:

const solved = sectors.filter(zone => zone && zone.visited && zone.solved).length
const total = sectors.length
return solved / worldSize * 100.0

Visited Zones:

const solved = sectors.filter(zone => zone && zone.visited).length
return solved / worldSize * 100.0

Final Score:

return Sum(components)

Map Screen

In order for the player to find their way around the world and get some hints on how to solve the puzzles, the game includes a map screen. The screen can be accesses after the player finds the map (aka Locator) item.

TODO: Describe how locator texts are determined

Observations

Here are some observations about the map:

• The map scene uses 28x28 tiles instead of the usual 32x32
• Inventory allows opening the map by clicking any item that has Bits 7 and 20 set
• The map can be activated by hitting L on the keyboard
• Hints check tile attributes to determine if something is valuable, a tool, a part, etc.

R2D2 Help

When Luke first visits Dagobah his trusty companion R2-D2 is already waiting for him, ready to be picked up and help out.

R2D2 can be placed anywhere on the game screen and will try to give some information on whatever it was dropped on.

The messages given by R2 are stored as string resources in the executable.

The following string ids are used:

List of Storage Tile IDs

[0x102, 0x10, 0x48d, 0x279, 0x27b, 0x27c, 0x6e5]

List of Door IDs

[70, 71, 72, 73, 74, 75, 76, 145, 149, 152, 153, 220, 221, 223, 231, 232, 233, 350, 582, 584, 586, 588, 702, 709, 755, 756, 759, 760, 804, 806, 983, 984, 1047, 1048, 1081, 1112, 1120, 1259, 1461, 1462, 1472, 1473, 1539, 1544, 1858]

List of X-Wing Tile IDs

[0x3b4, 0x3b5, 0x3b6]

Cheats

On most websites for cheat codes you can find mentions of cheat codes like BLASTERS and OBJECTS that supposedly fill up the inventory with all items. These codes do not work and the executable does not even contain any reference to those codes.

Yoda Stories does however contain two cheat codes that actually work. To input them you have to activate the Locator and type one of the codes. It is important to click the Locator in the inventory instead of using the keyboard shortcut L (the L-key is interpreted as the first character of the cheat code).

After successfully entering a cheat code a message appears on the current zone.

Yoda Stories supports the following cheat codes:

Indiana Jones and His Desktop Adventures does not have any cheat codes.

Files

This sections describes several custom or unusual file and binary formats used by the engine.

Yodesk.ini

Data that persists between launches of a Desktop Adventures game, like settings, highscore and information about the last generated worlds is stored in a ini-file.

The file is a standard INI file with the sections OPTIONS, GameData and Recent File List.

The following is a sample file generated by Yoda Stories:

[OPTIONS]
MIDILoad=1
PlaySound=0
PlayMusic=0
Difficulty=1
GameSpeed=140
WorldSize=1
Count=302
HScore=870
LScore=570
LCount=0
Terrain=2

[GameData]
Alaska0=2126634910,129,3,318,232,264
Nevada0=950869581,163,3,364,348,362

Options section

GameData section

The GameData section is used to keep track of the end puzzles last used on each planet. When a new world on the planet is generated, these puzzles are excluded. This is supposed to increase variety between consecutive games so the player get different endings every time.

Each entry holds a comma separated list. The first entry is the last used PRNG seed, written out as a 32-bit integer, eventhough only 16-bits are used. The second number is a random value between 1 and 256 that is added to the puzzle ids. The third value is the number of puzzle ids, followed by the actual end puzzle ids that are to be excluded, each offset by the random value generated before.

Releases

It's hard to find a complete list of releases of Yoda Stories. MobyGames lists only two releases of the Windows version of the game - the US and a German version. The Star Wars Collectors Archive (SWCA) has additional information on releases from Japan, Taiwan, Italy and the Netherlands and there is a Spanish release version up on the internet archive.

If you know of any other releases please feel free to edit this page. And if you have access to a version that is not on the internet archive yet, please consider submitting it.

The Patch

In February of '97 Lucas Arts released a patch called Yoda Update #6 that fixes problems in some zones. The Patch is a self-extracting archive that replaces the main game data file Yodesk.dta with a new one.

A prompt saying zones #72, #236, #407, #474 and #572 have been fixed appears when the update is run.

The original release notes of yopatch6.exe have been preserved by the Wayback Machine here (and with a different design here). They claim that in addition to the zone fixes "minor art modifications" have been made.

It would be interesting to find out what exactly has changed in the newer data file.

$ shasum yopatch6.exe
a8e18864184d49feaf0b74b93f60855f40ffe9bf  yopatch6.exe

$ file yopatch6.exe
yopatch6.exe: PE32 executable (GUI) Intel 80386, for MS Windows

Zone 72

Zone #72 was one of the zones patch by update #6.

Zone 236

Zone #236 was one of the zones patch by update #6.

Zone 407

Zone #407 was one of the zones patch by update #6.

Zone 474

Zone #474 was one of the zones patch by update #6.

Zone 572

Zone #572 was one of the zones patch by update #6.

Trivia

Promotional Screenshots

After getting my hands on an actual retail copy of Yoda Stories I became curious of the screenshots shown on the back of the box. At first glance they seem to be captures of zones #95, #294 and #483. But after further inspection it's clear that none of the screenshots could have come from the final version of the game.

Zone #95 does not have any actions that could place Luke's X-Wing in the zone as shown in the screenshot.

Zone #294 is very close to the one depicted in the second screenshot, the only difference seems to be a missing crater tile next to Luke's head

The last screenshot was taken on a desert world. Zone #483 has very similar building and wall structures, but the dewback in the top left corner is missing.

I've created re-created the situation in each of the screenshots. They are available as downloads here, here and here.

Interestingly enough, the italian version of the box uses entirely different images that actually look like screenshots from the real game.

Left-over Debug Window

Checkout The Cutting Room Floor's entry on Yoda Stories for some more debug windows that are present in the program but can not be triggered.

Apart from the cheat codes there is a debug window that can be accessed using the key combination ctrl-F8. A modal comes up that shows the current zone id, position and the id of this world's goal. The shortcut works in both Yoda Stories and Indiana Jones and his Desktop Adventures.

Yodesk.ksy

This is a machine-readable definition of the file format used by Yoda Stories. It can be used to generate a parser or inspect files online in the Kaitai Web IDE.

meta:
  id: yodesk
  application: "Star Wars: Yoda Stories"
  file-extension: dta
  license: CC0-1.0
  ks-version: 0.9
  endian: le
  encoding: ASCII
doc: |
  [Star Wars: Yoda Stories](https://en.wikipedia.org/wiki/Star_Wars:_Yoda_Stories) is a unique tile based game with procedurally
  generated worlds.
  This spec describes the file format used for all assets of the Windows
  version of the game.

  The file format follows the TLV (type-length-value) pattern to build a
  central catalog containing the most important (and globally accessible)
  assets of the game (e.g. puzzles, zones, tiles, etc.). The same pattern is
  also found in some catalog entries to encode arrays of variable-length
  structures.

  With every new game, Yoda Stories generates a new world. This is done by
  picking a random sample of puzzles from `PUZ2`. One of the chosen puzzles
  will be the goal, which when solved wins the game.
  Each puzzle provides an item when solved and some require one to be completed.
  During world generation a global world map of 10x10 sectors is filled with
  zones based on the selected puzzles.

  To add variety and interactivity to each zone the game includes a simple
  scripting engine. Zones can declare actions that when executed can for
  example set, move or delete tiles, drop items or activate enemies.

seq:
  - id: catalog
    type: catalog_entry
    repeat: until
    repeat-until: _.type == "ENDF"

types:
  catalog_entry:
    seq:
      - id: type
        type: str
        size: 4
      - id: size
        type: u4
        if: type != "VERS" and type != "ZONE"
      - id: content
        type:
          switch-on: type
          cases:
             '"VERS"': version
             '"STUP"': startup_image
             '"CHAR"': characters
             '"CAUX"': character_auxiliaries
             '"CHWP"': character_weapons
             '"PUZ2"': puzzles
             '"SNDS"': sounds
             '"TILE"': tiles
             '"TNAM"': tile_names
             '"ZONE"': zones
             '"TGEN"': tgen
             '"ENDF"': endf
             _: unknown_catalog_entry
  unknown_catalog_entry:
    seq:
      - id: data
        size: _parent.size
  version:
    seq:
      - id: version
        doc: Version of the file. This value is always set to 512.
        type: u4
  startup_image:
    doc: |
      A 288x288 bitmap to be shown while other assets are loaded and a new
      world is generated.
    seq:
      - id: pixels
        size: _parent.size
  sounds:
    doc: |
      This section declares sounds used in the game. The actual audio data is
      stored in wav files on the disk (in a directory named `sfx`) so this
      section contains paths to each sound file.
      Sounds can be referenced from the scripting language (see `play_sound`
      instruction opcode below) and from weapon (see `character` structure).
      Some sound ids (like the one when the hero is hit, or can't leave a
      zone) are hard coded in the game.
    seq:
      - id: count
        type: s2
      - id: sounds
        type: prefixed_strz
        repeat: expr
        repeat-expr: -count
  tile_names:
    seq:
      - id: names
        doc: |
          List of tile ids and their corresponding names. These are shown in
          the inventory or used in dialogs (see `speak_hero` and `speak_npc`
          opcodes).
        type: tile_name
        repeat: until
        repeat-until:  _.tile_id == 0xFF_FF
  tile_name:
    seq:
      - id: tile_id
        type: u2
      - id: name
        type: strz
        size: 0x18
        if: tile_id != 0xFF_FF
  tiles:
    seq:
      - id: tiles
        type: tiles_entries
        size: _parent.size
  tiles_entries:
    seq:
      - id: tiles
        type: tile
        repeat: eos
  tile:
      seq:
        - id: attributes
          type: tile_attributes
          size: 4
        - id: pixels
          size: 32 * 32
  tile_attributes:
      meta:
        bit-endian: le
      seq:
        - id: has_transparency
          type: b1
          doc: |
            Affects how tile image should be drawn. If set, the
            value 0 in `pixels` is treated as transparent. Otherwise
            it is drawn as black.
        - id: is_floor
          type: b1
          doc: |
            Tile is usually placed on the lowest layer of a zone
        - id: is_object
          type: b1
          doc: |
            Object, tile is usually placed on the middle layer of a zone
        - id: is_draggable
          type: b1
          doc: |
             If set and the tile is placed on the object layer it can be
             dragged and pushed around by the hero.
        - id: is_roof
          type: b1
          doc: |
             Tile is usually placed on the top layer (roof)
        - id: is_locator
          type: b1
          doc: |
             Locator, tile is used in world map view overview
        - id: is_weapon
          type: b1
          doc: |
             Identifies tiles that are mapped to weapons
        - id: is_item
          type: b1
        - id: is_character
          type: b1
          doc: |
            Tile forms part of a character
        - id: unused
          type: b7
        # Floor flags
        - id: is_doorway
          type: b1
          doc: |
            These tiles are doorways, monsters can't go
          if: is_floor
        # Locator flags
        - id: unused1
          type: b1
          if: is_locator
        - id: is_town
          type: b1
          doc: |
            Marks the spaceport on the map
          if: is_locator
        - id: is_unsolved_puzzle
          type: b1
          doc: |
            Marks a discovered, but unsolved puzzle on the map
          if: is_locator
        - id: is_solved_puzzle
          type: b1
          doc: |
            Marks a solved puzzle on the map
          if: is_locator
        - id: is_unsolved_travel
          type: b1
          doc: |
            Marks a place of travel on the map that has not been solved
          if: is_locator
        - id: is_solved_travel
          type: b1
          doc: |
            Marks a solved place of travel on the map
          if: is_locator
        - id: is_unsolved_blockade_north
          type: b1
          doc: |
            Marks a sector on the map that blocks access to northern zones
          if: is_locator
        - id: is_unsolved_blockade_south
          type: b1
          doc: |
            Marks a sector on the map that blocks access to southern zones
          if: is_locator
        - id: is_unsolved_blockade_west
          type: b1
          doc: |
            Marks a sector on the map that blocks access to western zones
          if: is_locator
        - id: is_unsolved_blockade_east
          type: b1
          doc: |
            Marks a sector on the map that blocks access to eastern zones
          if: is_locator
        - id: is_solved_blockade_north
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            northern zones
          if: is_locator
        - id: is_solved_blockade_south
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            southern zones
          if: is_locator
        - id: is_solved_blockade_west
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            western zones
          if: is_locator
        - id: is_solved_blockade_east
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            eastern zones
          if: is_locator
        - id: is_unsolved_goal
          type: b1
          doc: |
            The final puzzle of the world. Solving this wins the game
          if: is_locator
        - id: is_location_indicator
          type: b1
          doc: |
            Overlay to mark the current position on the map
          if: is_locator
        # Item flags
        - id: is_keycard
          type: b1
          if: is_item
        - id: is_tool
          type: b1
          if: is_item
        - id: is_part
          type: b1
          if: is_item
        - id: is_valuable
          type: b1
          if: is_item
        - id: is_map
          type: b1
          if: is_item
        - id: unused2
          type: b1
          if: is_item
        - id: is_edible
          type: b1
          if: is_item
        # Weapon flags
        - id: is_low_blaster
          type: b1
          doc: |
            Item is a low intensity blaster (like the blaster pistol)
          if: is_weapon
        - id: is_high_blaster
          type: b1
          doc: |
            Item is a high intensity blaster (like the blaster rifle)
          if: is_weapon
        - id: is_lightsaber
          type: b1
          if: is_weapon
        - id: is_the_force
          type: b1
          if: is_weapon
        # Character flags
        - id: is_hero
          type: b1
          if: is_character
        - id: is_enemy
          type: b1
          if: is_character
        - id: is_npc
          type: b1
          if: is_character
  action:
    doc: |
      Actions are the game's way to make static tile based maps more engaging
      and interactive. Each action consists of zero or more conditions and
      instructions, once all conditions are satisfied, all instructions are
      executed in order.

      To facilitate state, each zone has three 16-bit registers. These registers
      are named `counter`, `shared-counter` and `random`. In addition to these
      registers hidden tiles are sometimes used to mark state.
      There are conditions and instructions to query and update these registers.
      The `shared-counter` register is special in that it is shared between a
      zone and it's rooms. Instruction `0xc` roll_dice can be used to set the
      `random` register to a random value.

      A naive implementation of the scripting engine could look like this:

      ```
      for action in zone.actions:
        all_conditions_satisfied = False
        for condition in action.conditions:
            all_conditions_satisfied = check(condition)
            if !all_conditions_satisfied:
              break

        if !all_conditions_satisfied:
          continue

        for instruction in action.instructions:
          execute(instruction)
      ```

      See `condition_opcode` and `instruction_opcode` enums for a list of
      available opcodes and their meanings.
    seq:
      - id: marker
        contents: "IACT"
      - id: size
        type: u4
      - id: num_conditions
        type: u2
      - id: conditions
        type: condition
        repeat: expr
        repeat-expr: num_conditions
      - id: num_instructions
        type: u2
      - id: instructions
        type: instruction
        repeat: expr
        repeat-expr: num_instructions
  condition:
    seq:
      - id: opcode
        type: u2
        enum: condition_opcode
      - id: arguments
        type: s2
        repeat: expr
        repeat-expr: 5
      - id: len_text
        type: u2
      - id: text
        type: str
        size: len_text
        doc: |
          The `text_attribute` is never used, but seems to be included to
          shared the type with instructions.
    enums:
      condition_opcode:
        0x0:
          id:  zone_not_initialised
          doc: Evaluates to true exactly once (used for initialisation)
        0x1:
          id:  zone_entered
          doc: Evaluates to true if hero just entered the zone
        0x2:
          id:  bump
        0x3:
          id:  placed_item_is
        0x4:
          id:  standing_on
          doc: |
            Check if hero is at `args[0]`x`args[1]` and the floor tile is
            `args[2]`
        0x5:
          id:  counter_is
          doc: Current zone's `counter` value is equal to `args[0]`
        0x6:
          id:  random_is
          doc: Current zone's `random` value is equal to `args[0]`
        0x7:
          id:  random_is_greater_than
          doc: Current zone's `random` value is greater than `args[0]`
        0x8:
          id:  random_is_less_than
          doc: Current zone's `random` value is less than `args[0]`
        0x9:
          id:  enter_by_plane
        0xa:
          id:  tile_at_is
          doc: |
            Check if tile at `args[0]`x`args[1]`x`args[2]` is equal to
            `args[3]`
        0xb:
          id:  monster_is_dead
          doc: True if monster `args[0]` is dead.
        0xc:
          id:  has_no_active_monsters
          doc: undefined
        0xd:
          id:  has_item
          doc: |
            True if inventory contains `args[0]`.  If `args[0]` is `0xFFFF`
            check if inventory contains the item provided by the current
            zone's puzzle
        0xe:
          id:  required_item_is
        0xf:
          id:  ending_is
          doc: True if `args[0]` is equal to current goal item id
        0x10:
          id:  zone_is_solved
          doc: True if the current zone is solved
        0x11:
          id:  no_item_placed
          doc: Returns true if the user did not place an item
        0x12:
          id:  item_placed
          doc: Returns true if the user placed an item
        0x13:
          id:  health_is_less_than
          doc: Hero's health is less than `args[0]`.
        0x14:
          id:  health_is_greater_than
          doc: Hero's health is greater than `args[0]`.
        0x15: unused
        0x16:
          id:  find_item_is
          doc: True the item provided by current zone is `args[0]`
        0x17:
          id:  placed_item_is_not
        0x18:
          id:  hero_is_at
          doc: True if hero's x/y position is `args_0`x`args_1`.
        0x19:
          id:  shared_counter_is
          doc: Current zone's `shared_counter` value is equal to `args[0]`
        0x1a:
          id:  shared_counter_is_less_than
          doc: Current zone's `shared_counter` value is less than `args[0]`
        0x1b:
          id:  shared_counter_is_greater_than
          doc: Current zone's `shared_counter` value is greater than `args[0]`
        0x1c:
          id:  games_won_is
          doc: Total games won is equal to `args[0]`
        0x1d:
          id:  drops_quest_item_at
        0x1e:
          id:  has_any_required_item
          doc: |
            Determines if inventory contains any of the required items needed
            for current zone
        0x1f:
          id:  counter_is_not
          doc: Current zone's `counter` value is not equal to `args[0]`
        0x20:
          id:  random_is_not
          doc: Current zone's `random` value is not equal to `args[0]`
        0x21:
          id:  shared_counter_is_not
          doc: Current zone's `shared_counter` value is not equal to `args[0]`
        0x22:
          id:  is_variable
          doc: |
            Check if variable identified by `args[0]`⊕`args[1]`⊕`args[2]` is
            set to `args[3]`. Internally this is implemented as opcode 0x0a,
            check if tile at `args[0]`x`args[1]`x`args[2]` is equal to
            `args[3]`
        0x23:
          id:  games_won_is_greater_than
          doc: True, if total games won is greater than `args[0]`

  instruction:
    seq:
      - id: opcode
        type: u2
        enum: instruction_opcode
      - id: arguments
        type: s2
        repeat: expr
        repeat-expr: 5
      - id: len_text
        type: u2
      - id: text
        type: str
        size: len_text
    enums:
      instruction_opcode:
        0x0:
          id:  place_tile
          doc: |
            Place tile `args[3]` at `args[0]`x`args[1]`x`args[2]`. To remove a
            tile `args[3]` can be set to `0xFFFF`.
        0x1:
          id:  remove_tile
          doc: Remove tile at `args[0]`x`args[1]`x`args[2]`
        0x2:
          id:  move_tile
          doc: |
            Move tile at `args[0]`x`args[0]`x`args[2]` to
            `args[3]`x`args[4]`x`args[2]`.  *Note that this can not be used to
            move tiles between layers!*
        0x3:
          id:  draw_tile
        0x4:
          id:  speak_hero
          doc: |
            Show speech bubble next to hero. _Uses `text` attribute_.

            Script execution is paused until the speech bubble is dismissed.
        0x5:
          id:  speak_npc
          doc: |
            Show speech bubble at `args[0]`x`args[1]`. _Uses `text`
            attribute_. The characters `¢` and `¥` are used as placeholders
            for provided and required items of the current zone, respectively.

            Script execution is paused until the speech bubble is dismissed.
        0x6:
          id:  set_tile_needs_display
          doc: Redraw tile at `args[0]`x`args[1]`
        0x7:
          id:  set_rect_needs_display
          doc: |
            Redraw the part of the current scene, specified by a rectangle
            positioned at `args[0]`x`args[1]` with width `args[2]` and height
            `args[3]`.
        0x8:
          id:  wait
          doc: Pause script execution for one tick.
        0x9:
          id:  redraw
          doc: Redraw the whole scene immediately
        0xa:
          id:  play_sound
          doc: Play sound specified by `args[0]`
        0xb:
          id:  stop_sound
          doc: Stop playing sounds
        0xc:
          id:  roll_dice
          doc: |
            Set current zone's `random` to a random value between 1 and
            `args[0]`.
        0xd:
          id:  set_counter
          doc: Set current zone's `counter` value to a `args[0]`
        0xe:
          id:  add_to_counter
          doc: Add `args[0]` to current zone's `counter` value
        0xf:
          id:  set_variable
          doc: |
            Set variable identified by `args[0]`⊕`args[1]`⊕`args[2]` to
            `args[3]`.  Internally this is implemented as opcode 0x00, setting
            tile at `args[0]`x`args[1]`x`args[2]` to `args[3]`.
        0x10:
          id:  hide_hero
          doc: Hide hero
        0x11:
          id:  show_hero
          doc: Show hero
        0x12:
          id: move_hero_to
          doc: |
            Set hero's position to `args[0]`x`args[1]` ignoring impassable
            tiles.  Execute hotspot actions, redraw the current scene and move
            camera if the hero is not hidden.
        0x13:
          id: move_hero_by
          doc: |
            Moves hero relative to the current location by `args[0]` in x and
            `args[1]` in y direction.
        0x14:
          id: disable_action
          doc: |
            Disable current action, note that there's no way to activate the
            action again.
        0x15:
          id: enable_hotspot
          doc: Enable hotspot `args[0]` so it can be triggered.
        0x16:
          id: disable_hotspot
          doc: Disable hotspot `args[0]` so it can't be triggered anymore.
        0x17:
          id:  enable_monster
          doc: Enable monster `args[0]`
        0x18:
          id: disable_monster
          doc: Disable monster `args[0]`
        0x19:
          id: enable_all_monsters
          doc: Enable all monsters
        0x1a:
          id: disable_all_monsters
          doc: Disable all monsters
        0x1b:
          id: drop_item
          doc: |
            Drops item `args[0]` for pickup at `args[1]`x`args[2]`. If the
            item is 0xFFFF, it drops the current sector's find item instead.

            Script execution is paused until the item is picked up.
        0x1c:
          id: add_item
          doc: Add tile with id `args[0]` to inventory
        0x1d:
          id: remove_item
          doc: Remove one instance of item `args[0]` from the inventory
        0x1e:
          id: mark_as_solved
          doc: |
            Marks current sector solved for the overview map.
        0x1f:
          id: win_game
          doc: Ends the current story by winning.
        0x20:
          id: lose_game
          doc: Ends the current story by losing.
        0x21:
          id: change_zone
          doc: |
            Change current zone to `args[0]`. Hero will be placed at
            `args[1]`x`args[2]` in the new zone.
        0x22:
          id:  set_shared_counter
          doc: Set current zone's `shared_counter` value to a `args[0]`
        0x23:
          id:  add_to_shared_counter
          doc: Add `args[0]` to current zone's `shared_counter` value
        0x24:
          id:  set_random
          doc: Set current zone's `random` value to a `args[0]`
        0x25:
          id:  add_health
          doc: |
            Increase hero's health by `args[0]`. New health is capped at
            hero's max health (0x300). Argument 0 can also be negative
            subtract from hero's health.
  monster:
    doc: A monster is a enemy in a zone.
    seq:
      - id: character
        type: u2
      - id: x
        type: u2
      - id: y
        type: u2
      - id: loot
        doc: |
          References the item (loot - 1) that will be dropped if the monster
          is killed. If set to `0xFFFF` the current zone's quest item will be
          dropped.
        type: u2
      - id: drops_loot
        doc: If this field is anything other than 0 the monster may drop an
          item when killed.
        type: u4
      - id: waypoints
        type: waypoint
        repeat: expr
        repeat-expr: 4
  zone:
    seq:
      - id: planet
        doc: |
          Planet this zone can be placed on.

          During world generation the goal puzzle dictates which planet is
          chosen. Apart from `swamp` zones, only the zones with type `empty`
          or the chosen type are loaded when a game is in progress.
        type: u2
        enum: planet
      - id: size
        type: u4
      - id: index
        type: u2
      - id: marker
        contents: "IZON"
      - id: size2
        type: u4
      - id: width
        doc: Width of the zone in tiles. Either 9 or 18.
        type: u2
      - id: height
        doc: Height of the zone in tiles. Either 9 or 18.
        type: u2
      - id: type
        enum: zone_type
        type: u4
      - id: shared_counter
        doc: |
            Scripting register shared between the zone and its rooms.
        type: u2
        valid: 0xFF_FF
      - id: planet_again
        doc: Repetition of the `planet` field
        type: u2
      - id: tile_ids
        type: zone_spot
        repeat: expr
        repeat-expr: width * height
        doc: |
          `tile_ids` is made up of three interleaved tile layers ordered from
          bottom (floor) to top (roof).
          Tiles are often references via 3 coordinates (xyz), which
          corresponds to an index into this array calculated as `n = y * width
          * 3 + x * 3 = z`.
      - id: num_hotspots
        type: u2
      - id: hotspots
        type: hotspot
        repeat: expr
        repeat-expr: num_hotspots
      - id: izax
        type: zone_auxiliary
      - id: izx2
        type: zone_auxiliary_2
      - id: izx3
        type: zone_auxiliary_3
      - id: izx4
        type: zone_auxiliary_4
      - id: num_actions
        type: u2
      - id: actions
        type: action
        repeat: expr
        repeat-expr: num_actions
    enums:
      planet:
        0: none
        1: desert
        2: snow
        3: forest
        5: swamp
      zone_type:
        0:
          id: none
        1:
          id: empty
          doc: |
            Empty zones do not contain a puzzle to be solved and are used to
            fill the space between between zones that are relevant for winning
            the game.
        2:
          id: blockade_north
          doc: |
            This type of zone blocks access to sectors north of it until the
            puzzle is solved.
        3:
          id: blockade_south
          doc: |
            This type of zone blocks access to sectors south of it until the
            puzzle is solved.
        4:
          id: blockade_east
          doc: |
            This type of zone blocks access to sectors east of it until the
            puzzle is solved.
        5:
          id: blockade_west
          doc: |
            This type of zone blocks access to sectors west of it until the
            puzzle is solved.
        6:
          id: travel_start
          doc: |
            Starting point to travel to an island on the edge of the world.
            `travel_start` and `travel_end` zones are connected through
            hotspot of type `vehicle_to` and `vehicle_back`.
        7:
          id: travel_end
          doc: |
            Travel target that is only placed on an island at the edge of the
            world map during world generation.
        8:
          id: room
          doc: |
            A zone that can not be placed on the world map directly. Instead
            rooms are accessed via actions or hotspots of type `door_in`. They
            usually contain at least one `door_out` hotspot to get back to the
            other zone.
        9:
          id: load
          doc: |
            This type of zone is shown after the game has loaded all assets.
            It should resemble the image from the catalog entry of type
            `startup_image` for a smooth transition from loading to game play.
        10:
          id: goal
          doc: |
            Every world contains exactly one goal zone. Solving this zone wins
            the game.
        11:
          id: town
          doc: |
            This is the entry zone where the hero arrives after leaving the
            swamp planet. Each planet can only have one town zone.
        13:
          id: win
          doc: |
            Shown when a game is won. The score is rendered above the tiles at
            coordinates 5x7 and 6x7.
        14:
          id: lose
          doc: |
            Shown when a game is lost.
        15:
          id: trade
          doc: |
            In order to solve this zone and gain a new item the hero has to
            trade something in.
        16:
          id: use
          doc: |
            This type of zone can be solved by making applying a tool or using
            a keycard.
        17:
          id: find
          doc: |
            This type of zone can be solved without using items.
        18:
          id: find_unique_weapon
          doc: |
            This zone provides the hero with a unique weapon and will be
            placed closed to a town zone.
  zone_spot:
    seq:
      - id: column
        doc: from bottom to top, 0xFFFF indicates empty tiles
        type: u2
        repeat: expr
        repeat-expr: 3
  hotspot:
    doc: |
      In addition to actions some puzzles and events are triggered by
      hotspots. These hotspots are triggered when the hero steps on them or
      places an item at the location. Additionally, hotspots are used during
      world generation to mark places where NPCs can spawn.
    seq:
      - id: type
        type: u4
        enum: hotspot_type
      - id: x
        type: u2
      - id: y
        type: u2
      - id: enabled
        doc: |
          If disabled, hotspots can not be triggered. See instruction opcodes
          called `enable_hotspot` and `disable_hotspot`.
        type: u2
      - id: argument
        type: u2
    enums:
      hotspot_type:
        0:
          id: drop_quest_item
          doc: |
            Drops the item provided by the zone when solved. Can be set to a
            specific item, or to `0xFFFF` to use the one from the currently
            assigned puzzle.
        1:
          id: spawn_location
          doc: |
            Possible spawn location for one of the zone's NPCs.
        2:
          id: drop_unique_weapon
          doc: |
            Hotspot that drops the unique weapon found in zones of type
            `find_unique_weapon`.
        3:
          id: vehicle_to
          doc: |
            Used in `travel_start` zones as a trigger to teleport to the
            corresponding `travel_end` zone. The hotspot argument contains the
            id of the zone to teleport to.
        4:
          id: vehicle_back
          doc: |
            Counter part to `vehicle_to` hotspots. This is used to determine
            the hero's position on the zone after the `vehicle_to` hotspot has
            been triggered and to teleport back to the zone on main land.
        5:
          id: drop_map
          doc: |
            Hotspot that drops the map (aka locator) tile. One `find` zone
            with a hotspot of this type will be placed next to a town during
            world generation.
        6:
          id: drop_item
          doc: |
             Hotspot that, when triggered drops the item specified in the
             hotspot's argument. If the item is set to `0xFFFF` the zone's
             quest item will be dropped.
        7:
          id: npc
          doc: |
            This seems to be a placeholder for a pre-assigned NPC.
        8:
          id: drop_weapon
          doc: |
            Drops a weapon (specified by the hotspot argument) when triggered.
        9:
          id: door_in
          doc: |
            When triggered this hotspot type move the hero to the zone
            specified in the hotspot argument. The hero's location on the new
            zone will be determined by a corresponding `door_out` hotspot in
            the target zone.
        10:
          id: door_out
          doc: |
            Determines where the hero will be placed when the zone is entered
            through a door. When triggered, this transports the player back to
            the `door_in` hotspot they game from.
        11: unused
        12: lock
        13:
          id: teleporter
          doc: |
            Teleporter hotspots can be used to instantly teleport to other
            (visited) teleporters on the map
        14:
          id: ship_to_planet
          doc: |
            Behaves similar to the `vehicle_to` hotspot type but travels
            between the town and the swamp planet.
        15:
          id: ship_from_planet
          doc: |
            Behaves similar to the `vehicle_back` hotspot type but travels
            between the town and the swamp planet.

  zone_auxiliary:
    seq:
      - id: marker
        contents: "IZAX"
      - id: size
        type: u4
      - type: u2
      - id: num_monsters
        type: u2
      - id: monsters
        type: monster
        repeat: expr
        repeat-expr: num_monsters
      - id: num_required_items
        type: u2
      - id: required_items
        doc: List of items that can be used to solve the zone.
        type: u2
        repeat: expr
        repeat-expr: num_required_items
      - id: num_goal_items
        type: u2
      - id: goal_items
        doc: |
          Additional items that are needed to solve the zone. Only used if the
          zone type is `goal`.
        type: u2
        repeat: expr
        repeat-expr: num_goal_items
  zone_auxiliary_2:
    seq:
      - id: marker
        contents: "IZX2"
      - id: size
        type: u4
      - id: num_provided_items
        type: u2
      - id: provided_items
        doc: Items that can be gained when the zone is solved.
        type: u2
        repeat: expr
        repeat-expr: num_provided_items
  zone_auxiliary_3:
    seq:
      - id: marker
        contents: "IZX3"
      - id: size
        type: u4
      - id: num_npcs
        type: u2
      - id: npcs
        doc: |
          NPCs that can be placed in the zone to trade items with the hero.
        type: u2
        repeat: expr
        repeat-expr: num_npcs
  zone_auxiliary_4:
    seq:
      - id: marker
        contents: "IZX4"
      - id: size
        type: u4
      - type: u2
  zones:
    seq:
      - id: num_zones
        type: u2
      - id: zones
        type: zone
        repeat: expr
        repeat-expr: num_zones
  puzzles:
    seq:
      - id: puzzles
        type: puzzle
        repeat: until
        repeat-until: _.index == 0xFF_FF
  puzzle:
    seq:
      - id: index
        type: u2
      - id: marker
        if: index != 0xFF_FF
        contents: "IPUZ"
      - id: size
        type: u4
        if: index != 0xFF_FF
      - id: type
        type: u4
        if: index != 0xFF_FF
      - id: item1_class
        type: u4
        enum: puzzle_item_class
        if: index != 0xFF_FF
      - id: item2_class
        type: u4
        enum: puzzle_item_class
        if: index != 0xFF_FF
      - type: u2
        if: index != 0xFF_FF
      - id: strings
        type: prefixed_str
        repeat: expr
        repeat-expr: 5
        if: index != 0xFF_FF
      - id: item_1
        type: u2
        if: index != 0xFF_FF
      - id: item_2
        type: u2
        if: index != 0xFF_FF
    enums:
      puzzle_item_class:
        0: keycard
        1: tool
        2: part
        4: valuable
        0xFFFF_FFFF: none
  endf:
    seq: []
  tgen:
    doc: |
        The TGEN section is only present in non-english versions of the game. It's purpose or
        internal structure is unknown.
    seq:
      - id: data
        size: _parent.size
  characters:
    seq:
      - id: characters
        type: character
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character:
    seq:
      - id: index
        type: u2
      - id: marker
        contents: "ICHA"
        if: index != 0xFF_FF
      - id: size
        type: u4
        if: index != 0xFF_FF
      - id: name
        type: strz
        size: 16
        if: index != 0xFF_FF
      - id: type
        type: u2
        enum: character_type
        if: index != 0xFF_FF
      - id: movement_type
        type: u2
        enum: movement_type
        if: index != 0xFF_FF
      - id: probably_garbage_1
        type: u2
        if: index != 0xFF_FF
      - id: probably_garbage_2
        type: u4
        if: index != 0xFF_FF
      - id: frame_1
        type: char_frame
        if: index != 0xFF_FF
      - id: frame_2
        type: char_frame
        if: index != 0xFF_FF
      - id: frame_3
        type: char_frame
        if: index != 0xFF_FF
    enums:
      character_type:
        1: hero
        2: enemy
        4: weapon
      movement_type:
        0: none
        4: sit
        9: wander
        10: patrol
        12: animation
  char_frame:
    seq:
      - id: tiles
        type: u2
        repeat: expr
        repeat-expr: 0x8
  character_auxiliaries:
    seq:
      - id: auxiliaries
        type: character_auxiliary
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character_auxiliary:
    seq:
      - id: index
        type: u2
      - id: damage
        type: s2
        if: index != 0xFF_FF
  character_weapons:
    seq:
      - id: weapons
        type: character_weapon
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character_weapon:
    seq:
      - id: index
        type: u2
      - id: reference
        doc: |
          If the character referenced by index is a monster, this is a
          reference to their weapon, otherwise this is the index of the
          weapon's sound
        type: u2
        if: index != 0xFF_FF
      - id: health
        type: u2
        if: index != 0xFF_FF
  # Utilities
  prefixed_str:
    seq:
      - id: len_content
        type: u2
      - id: content
        type: str
        size: len_content
  prefixed_strz:
    seq:
      - id: len_content
        type: u2
      - id: content
        type: strz
        size: len_content
  waypoint:
    seq:
    - id: x
      type: u4
    - id: y
      type: u4

Deskadv.ksy

This is a machine-readable definition of the file format used by Indiana Jones and His Desktop Adventures. It can be used to generate a parser or inspect files online in the Kaitai Web IDE.

meta:
  id: deskadv
  application: "Indiana Jones and His Desktop Adventures"
  file-extension: daw
  license: CC0-1.0
  ks-version: 0.9
  endian: le
  encoding: ISO-8859-2

seq:
  - id: catalog
    type: catalog_entry
    repeat: until
    repeat-until: _.type == "ENDF"

types:
  catalog_entry:
    seq:
      - id: type
        type: str
        size: 4
      - id: size
        type: u4
        if: type != "VERS"
      - id: content
        type:
          switch-on: type
          cases:
             '"VERS"': version
             '"STUP"': startup_image
             '"CHAR"': characters
             '"CAUX"': character_auxiliaries
             '"CHWP"': character_weapons
             '"PUZ2"': puzzles
             '"SNDS"': sounds
             '"TILE"': tiles
             '"TNAM"': tile_names
             '"ANAM"': action_names
             '"PNAM"': puzzle_names
             '"ZNAM"': zone_names
             '"HTSP"': hotspots
             '"ACTN"': actions
             '"ZONE"': zones
             '"ZAUX"': zones_aux_1
             '"ZAX2"': zones_aux_2
             '"ZAX3"': zones_aux_3
             '"ZAX4"': zones_aux_4
             '"TGEN"': tgen
             '"ENDF"': endf
             _: unknown_catalog_entry

  unknown_catalog_entry:
    seq:
      - id: data
        size: _parent.size
  version:
    seq:
      - id: version
        doc: Version of the file. This value is always set to 512.
        type: u4
  startup_image:
    doc: |
      A 288x288 bitmap to be shown while other assets are loaded and a new
      world is generated.
    seq:
      - id: pixels
        size: _parent.size
  sounds:
    doc: |
      This section declares sounds used in the game. The actual audio data is
      stored in wav files on the disk (in a directory named `sfx`) so this
      section contains paths to each sound file.
      Sounds can be referenced from the scripting language (see `play_sound`
      instruction opcode below) and from weapon (see `character` structure).
      Some sound ids (like the one when the hero is hit, or can't leave a
      zone) are hard coded in the game.
    seq:
      - id: count
        type: s2
      - id: sounds
        type: prefixed_strz
        repeat: expr
        repeat-expr: -count
  tile_names:
    seq:
      - id: names
        doc: |
          List of tile ids and their corresponding names. These are shown in
          the inventory or used in dialogs (see `speak_hero` and `speak_npc`
          opcodes).
        type: tile_name
        repeat: until
        repeat-until:  _.tile_id == 0xFF_FF
  tile_name:
    seq:
      - id: tile_id
        type: u2
      - id: name
        type: strz
        size: 0x10
        if: tile_id != 0xFF_FF
  tiles:
    seq:
      - id: tiles
        type: tiles_entries
        size: _parent.size
  tiles_entries:
    seq:
      - id: tiles
        type: tile
        repeat: eos
  tile:
      seq:
        - id: attributes
          type: tile_attributes
          size: 4
        - id: pixels
          size: 32 * 32
  tile_attributes:
      meta:
        bit-endian: le
      seq:
        - id: has_transparency
          type: b1
          doc: |
            Affects how tile image should be drawn. If set, the
            value 0 in `pixels` is treated as transparent. Otherwise
            it is drawn as black.
        - id: is_floor
          type: b1
          doc: |
            Tile is usually placed on the lowest layer of a zone
        - id: is_object
          type: b1
          doc: |
            Object, tile is usually placed on the middle layer of a zone
        - id: is_draggable
          type: b1
          doc: |
             If set and the tile is placed on the object layer it can be
             dragged and pushed around by the hero.
        - id: is_roof
          type: b1
          doc: |
             Tile is usually placed on the top layer (roof)
        - id: is_locator
          type: b1
          doc: |
             Locator, tile is used in world map view overview
        - id: is_weapon
          type: b1
          doc: |
             Identifies tiles that are mapped to weapons
        - id: is_item
          type: b1
        - id: is_character
          type: b1
          doc: |
            Tile forms part of a character
        - id: unused
          type: b7
        # Floor flags
        - id: is_doorway
          type: b1
          doc: |
            These tiles are doorways, monsters can't go
          if: is_floor
        # Locator flags
        - id: unused1
          type: b1
          if: is_locator
        - id: is_town
          type: b1
          doc: |
            Marks the spaceport on the map
          if: is_locator
        - id: is_unsolved_puzzle
          type: b1
          doc: |
            Marks a discovered, but unsolved puzzle on the map
          if: is_locator
        - id: is_solved_puzzle
          type: b1
          doc: |
            Marks a solved puzzle on the map
          if: is_locator
        - id: is_unsolved_travel
          type: b1
          doc: |
            Marks a place of travel on the map that has not been solved
          if: is_locator
        - id: is_solved_travel
          type: b1
          doc: |
            Marks a solved place of travel on the map
          if: is_locator
        - id: is_unsolved_blockade_north
          type: b1
          doc: |
            Marks a sector on the map that blocks access to northern zones
          if: is_locator
        - id: is_unsolved_blockade_south
          type: b1
          doc: |
            Marks a sector on the map that blocks access to southern zones
          if: is_locator
        - id: is_unsolved_blockade_west
          type: b1
          doc: |
            Marks a sector on the map that blocks access to western zones
          if: is_locator
        - id: is_unsolved_blockade_east
          type: b1
          doc: |
            Marks a sector on the map that blocks access to eastern zones
          if: is_locator
        - id: is_solved_blockade_north
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            northern zones
          if: is_locator
        - id: is_solved_blockade_south
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            southern zones
          if: is_locator
        - id: is_solved_blockade_west
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            western zones
          if: is_locator
        - id: is_solved_blockade_east
          type: b1
          doc: |
            Marks a solved sector on the map that used to block access to
            eastern zones
          if: is_locator
        - id: is_unsolved_goal
          type: b1
          doc: |
            The final puzzle of the world. Solving this wins the game
          if: is_locator
        - id: is_location_indicator
          type: b1
          doc: |
            Overlay to mark the current position on the map
          if: is_locator
        # Item flags
        - id: is_keycard
          type: b1
          if: is_item
        - id: is_tool
          type: b1
          if: is_item
        - id: is_part
          type: b1
          if: is_item
        - id: is_valuable
          type: b1
          if: is_item
        - id: is_map
          type: b1
          if: is_item
        - id: unused2
          type: b1
          if: is_item
        - id: is_edible
          type: b1
          if: is_item
        # Weapon flags
        - id: is_low_blaster
          type: b1
          doc: |
            Item is a low intensity blaster (like the blaster pistol)
          if: is_weapon
        - id: is_high_blaster
          type: b1
          doc: |
            Item is a high intensity blaster (like the blaster rifle)
          if: is_weapon
        - id: is_lightsaber
          type: b1
          if: is_weapon
        - id: is_the_force
          type: b1
          if: is_weapon
        # Character flags
        - id: is_hero
          type: b1
          if: is_character
        - id: is_enemy
          type: b1
          if: is_character
        - id: is_npc
          type: b1
          if: is_character
  action:
    doc: |
      Actions are the game's way to make static tile based maps more engaging
      and interactive. Each action consists of zero or more conditions and
      instructions, once all conditions are satisfied, all instructions are
      executed in order.

      To facilitate state, each zone has three 16-bit registers. These registers
      are named `counter`, `shared-counter` and `random`. In addition to these
      registers hidden tiles are sometimes used to mark state.
      There are conditions and instructions to query and update these registers.
      The `shared-counter` register is special in that it is shared between a
      zone and it's rooms. Instruction `0xc` roll_dice can be used to set the
      `random` register to a random value.

      A naive implementation of the scripting engine could look like this:

      ```
      for action in zone.actions:
        all_conditions_satisfied = False
        for condition in action.conditions:
            all_conditions_satisfied = check(condition)
            if !all_conditions_satisfied:
              break

        if !all_conditions_satisfied:
          continue

        for instruction in action.instructions:
          execute(instruction)
      ```

      See `condition_opcode` and `instruction_opcode` enums for a list of
      available opcodes and their meanings.
    seq:
      - id: marker
        contents: "IACT"
      - id: size
        type: u4
      - id: num_conditions
        type: u2
      - id: conditions
        type: condition
        repeat: expr
        repeat-expr: num_conditions
      - id: num_instructions
        type: u2
      - id: instructions
        type: instruction
        repeat: expr
        repeat-expr: num_instructions
  condition:
    seq:
      - id: opcode
        type: u2
        enum: condition_opcode
      - id: arguments
        type: s2
        repeat: expr
        repeat-expr: 5
      - id: len_text
        type: u2
      - id: text
        type: str
        size: len_text
        doc: |
          The `text_attribute` is never used, but seems to be included to
          shared the type with instructions.
    enums:
      condition_opcode:
        0x0:
          id:  zone_not_initialised
          doc: Evaluates to true exactly once (used for initialisation)
        0x1:
          id:  zone_entered
          doc: Evaluates to true if hero just entered the zone
        0x2:
          id:  bump
        0x3:
          id:  placed_item_is
        0x4:
          id:  standing_on
          doc: |
            Check if hero is at `args[0]`x`args[1]` and the floor tile is
            `args[2]`
        0x5:
          id:  counter_is
          doc: Current zone's `counter` value is equal to `args[0]`
        0x6:
          id:  random_is
          doc: Current zone's `random` value is equal to `args[0]`
        0x7:
          id:  random_is_greater_than
          doc: Current zone's `random` value is greater than `args[0]`
        0x8:
          id:  random_is_less_than
          doc: Current zone's `random` value is less than `args[0]`
        0x9:
          id:  enter_by_plane
        0xa:
          id:  tile_at_is
          doc: |
            Check if tile at `args[0]`x`args[1]`x`args[2]` is equal to
            `args[3]`
        0xb:
          id:  monster_is_dead
          doc: True if monster `args[0]` is dead.
        0xc:
          id:  has_no_active_monsters
          doc: undefined
        0xd:
          id:  has_item
          doc: |
            True if inventory contains `args[0]`.  If `args[0]` is `0xFFFF`
            check if inventory contains the item provided by the current
            zone's puzzle
        0xe:
          id:  required_item_is
        0xf:
          id:  ending_is
          doc: True if `args[0]` is equal to current goal item id
        0x10:
          id:  zone_is_solved
          doc: True if the current zone is solved
        0x11:
          id:  no_item_placed
          doc: Returns true if the user did not place an item
        0x12:
          id:  item_placed
          doc: Returns true if the user placed an item
        0x13:
          id:  health_is_less_than
          doc: Hero's health is less than `args[0]`.
        0x14:
          id:  health_is_greater_than
          doc: Hero's health is greater than `args[0]`.
        0x15: unused
        0x16:
          id:  find_item_is
          doc: True the item provided by current zone is `args[0]`
        0x17:
          id:  placed_item_is_not
        0x18:
          id:  hero_is_at
          doc: True if hero's x/y position is `args_0`x`args_1`.
        0x19:
          id:  shared_counter_is
          doc: Current zone's `shared_counter` value is equal to `args[0]`
        0x1a:
          id:  shared_counter_is_less_than
          doc: Current zone's `shared_counter` value is less than `args[0]`
        0x1b:
          id:  shared_counter_is_greater_than
          doc: Current zone's `shared_counter` value is greater than `args[0]`
        0x1c:
          id:  games_won_is
          doc: Total games won is equal to `args[0]`
        0x1d:
          id:  drops_quest_item_at
        0x1e:
          id:  has_any_required_item
          doc: |
            Determines if inventory contains any of the required items needed
            for current zone
        0x1f:
          id:  counter_is_not
          doc: Current zone's `counter` value is not equal to `args[0]`
        0x20:
          id:  random_is_not
          doc: Current zone's `random` value is not equal to `args[0]`
        0x21:
          id:  shared_counter_is_not
          doc: Current zone's `shared_counter` value is not equal to `args[0]`
        0x22:
          id:  is_variable
          doc: |
            Check if variable identified by `args[0]`⊕`args[1]`⊕`args[2]` is
            set to `args[3]`. Internally this is implemented as opcode 0x0a,
            check if tile at `args[0]`x`args[1]`x`args[2]` is equal to
            `args[3]`
        0x23:
          id:  games_won_is_greater_than
          doc: True, if total games won is greater than `args[0]`

  instruction:
    seq:
      - id: opcode
        type: u2
        enum: instruction_opcode
      - id: arguments
        type: s2
        repeat: expr
        repeat-expr: 5
      - id: len_text
        type: u2
      - id: text
        type: str
        size: len_text
    enums:
      instruction_opcode:
        0x0:
          id:  place_tile
          doc: |
            Place tile `args[3]` at `args[0]`x`args[1]`x`args[2]`. To remove a
            tile `args[3]` can be set to `0xFFFF`.
        0x1:
          id:  remove_tile
          doc: Remove tile at `args[0]`x`args[1]`x`args[2]`
        0x2:
          id:  move_tile
          doc: |
            Move tile at `args[0]`x`args[0]`x`args[2]` to
            `args[3]`x`args[4]`x`args[2]`.  *Note that this can not be used to
            move tiles between layers!*
        0x3:
          id:  draw_tile
        0x4:
          id:  speak_hero
          doc: |
            Show speech bubble next to hero. _Uses `text` attribute_.

            Script execution is paused until the speech bubble is dismissed.
        0x5:
          id:  speak_npc
          doc: |
            Show speech bubble at `args[0]`x`args[1]`. _Uses `text`
            attribute_. The characters `¢` and `¥` are used as placeholders
            for provided and required items of the current zone, respectively.

            Script execution is paused until the speech bubble is dismissed.
        0x6:
          id:  set_tile_needs_display
          doc: Redraw tile at `args[0]`x`args[1]`
        0x7:
          id:  set_rect_needs_display
          doc: |
            Redraw the part of the current scene, specified by a rectangle
            positioned at `args[0]`x`args[1]` with width `args[2]` and height
            `args[3]`.
        0x8:
          id:  wait
          doc: Pause script execution for one tick.
        0x9:
          id:  redraw
          doc: Redraw the whole scene immediately
        0xa:
          id:  play_sound
          doc: Play sound specified by `args[0]`
        0xb:
          id:  stop_sound
          doc: Stop playing sounds
        0xc:
          id:  roll_dice
          doc: |
            Set current zone's `random` to a random value between 1 and
            `args[0]`.
        0xd:
          id:  set_counter
          doc: Set current zone's `counter` value to a `args[0]`
        0xe:
          id:  add_to_counter
          doc: Add `args[0]` to current zone's `counter` value
        0xf:
          id:  set_variable
          doc: |
            Set variable identified by `args[0]`⊕`args[1]`⊕`args[2]` to
            `args[3]`.  Internally this is implemented as opcode 0x00, setting
            tile at `args[0]`x`args[1]`x`args[2]` to `args[3]`.
        0x10:
          id:  hide_hero
          doc: Hide hero
        0x11:
          id:  show_hero
          doc: Show hero
        0x12:
          id: move_hero_to
          doc: |
            Set hero's position to `args[0]`x`args[1]` ignoring impassable
            tiles.  Execute hotspot actions, redraw the current scene and move
            camera if the hero is not hidden.
        0x13:
          id: move_hero_by
          doc: |
            Moves hero relative to the current location by `args[0]` in x and
            `args[1]` in y direction.
        0x14:
          id: disable_action
          doc: |
            Disable current action, note that there's no way to activate the
            action again.
        0x15:
          id: enable_hotspot
          doc: Enable hotspot `args[0]` so it can be triggered.
        0x16:
          id: disable_hotspot
          doc: Disable hotspot `args[0]` so it can't be triggered anymore.
        0x17:
          id:  enable_monster
          doc: Enable monster `args[0]`
        0x18:
          id: disable_monster
          doc: Disable monster `args[0]`
        0x19:
          id: enable_all_monsters
          doc: Enable all monsters
        0x1a:
          id: disable_all_monsters
          doc: Disable all monsters
        0x1b:
          id: drop_item
          doc: |
            Drops item `args[0]` for pickup at `args[1]`x`args[2]`. If the
            item is 0xFFFF, it drops the current sector's find item instead.

            Script execution is paused until the item is picked up.
        0x1c:
          id: add_item
          doc: Add tile with id `args[0]` to inventory
        0x1d:
          id: remove_item
          doc: Remove one instance of item `args[0]` from the inventory
        0x1e:
          id: mark_as_solved
          doc: |
            Marks current sector solved for the overview map.
        0x1f:
          id: win_game
          doc: Ends the current story by winning.
        0x20:
          id: lose_game
          doc: Ends the current story by losing.
        0x21:
          id: change_zone
          doc: |
            Change current zone to `args[0]`. Hero will be placed at
            `args[1]`x`args[2]` in the new zone.
        0x22:
          id:  set_shared_counter
          doc: Set current zone's `shared_counter` value to a `args[0]`
        0x23:
          id:  add_to_shared_counter
          doc: Add `args[0]` to current zone's `shared_counter` value
        0x24:
          id:  set_random
          doc: Set current zone's `random` value to a `args[0]`
        0x25:
          id:  add_health
          doc: |
            Increase hero's health by `args[0]`. New health is capped at
            hero's max health (0x300). Argument 0 can also be negative
            subtract from hero's health.
  monster:
    doc: A monster is a enemy in a zone.
    seq:
      - id: character
        type: u2
      - id: x
        type: u2
      - id: y
        type: u2
  zone:
    seq:
      - id: marker
        contents: "IZON"
      - id: size2
        type: u4
      - id: width
        doc: Width of the zone in tiles. Either 9 or 18.
        type: u2
      - id: height
        doc: Height of the zone in tiles. Either 9 or 18.
        type: u2
      - id: type
        enum: zone_type
        type: u4
      - id: tile_ids
        type: zone_spot
        repeat: expr
        repeat-expr: width * height
        doc: |
          `tile_ids` is made up of three interleaved tile layers ordered from
          bottom (floor) to top (roof).
          Tiles are often references via 3 coordinates (xyz), which
          corresponds to an index into this array calculated as `n = y * width
          * 3 + x * 3 = z`.
    enums:
      planet:
        0: none
        1: desert
        2: snow
        3: forest
        5: swamp
      zone_type:
        0:
          id: none
        1:
          id: empty
          doc: |
            Empty zones do not contain a puzzle to be solved and are used to
            fill the space between between zones that are relevant for winning
            the game.
        2:
          id: blockade_north
          doc: |
            This type of zone blocks access to sectors north of it until the
            puzzle is solved.
        3:
          id: blockade_south
          doc: |
            This type of zone blocks access to sectors south of it until the
            puzzle is solved.
        4:
          id: blockade_east
          doc: |
            This type of zone blocks access to sectors east of it until the
            puzzle is solved.
        5:
          id: blockade_west
          doc: |
            This type of zone blocks access to sectors west of it until the
            puzzle is solved.
        6:
          id: travel_start
          doc: |
            Starting point to travel to an island on the edge of the world.
            `travel_start` and `travel_end` zones are connected through
            hotspot of type `vehicle_to` and `vehicle_back`.
        7:
          id: travel_end
          doc: |
            Travel target that is only placed on an island at the edge of the
            world map during world generation.
        8:
          id: room
          doc: |
            A zone that can not be placed on the world map directly. Instead
            rooms are accessed via actions or hotspots of type `door_in`. They
            usually contain at least one `door_out` hotspot to get back to the
            other zone.
        9:
          id: load
          doc: |
            This type of zone is shown after the game has loaded all assets.
            It should resemble the image from the catalog entry of type
            `startup_image` for a smooth transition from loading to game play.
        10:
          id: goal
          doc: |
            Every world contains exactly one goal zone. Solving this zone wins
            the game.
        11:
          id: town
          doc: |
            This is the entry zone where the hero arrives after leaving the
            swamp planet. Each planet can only have one town zone.
        13:
          id: win
          doc: |
            Shown when a game is won. The score is rendered above the tiles at
            coordinates 5x7 and 6x7.
        14:
          id: lose
          doc: |
            Shown when a game is lost.
        15:
          id: trade
          doc: |
            In order to solve this zone and gain a new item the hero has to
            trade something in.
        16:
          id: use
          doc: |
            This type of zone can be solved by making applying a tool or using
            a keycard.
        17:
          id: find
          doc: |
            This type of zone can be solved without using items.
        18:
          id: find_unique_weapon
          doc: |
            This zone provides the hero with a unique weapon and will be
            placed closed to a town zone.
  zone_spot:
    seq:
      - id: column
        doc: from bottom to top, 0xFFFF indicates empty tiles
        type: u2
        repeat: expr
        repeat-expr: 3
  hotspot:
    doc: |
      In addition to actions some puzzles and events are triggered by
      hotspots. These hotspots are triggered when the hero steps on them or
      places an item at the location. Additionally, hotspots are used during
      world generation to mark places where NPCs can spawn.
    seq:
      - id: type
        type: u4
        enum: hotspot_type
      - id: x
        type: u2
      - id: y
        type: u2
      - id: enabled
        doc: |
          If disabled, hotspots can not be triggered. See instruction opcodes
          called `enable_hotspot` and `disable_hotspot`.
        type: u2
      - id: argument
        type: u2
    enums:
      hotspot_type:
        0:
          id: drop_quest_item
          doc: |
            Drops the item provided by the zone when solved. Can be set to a
            specific item, or to `0xFFFF` to use the one from the currently
            assigned puzzle.
        1:
          id: spawn_location
          doc: |
            Possible spawn location for one of the zone's NPCs.
        2:
          id: drop_unique_weapon
          doc: |
            Hotspot that drops the unique weapon found in zones of type
            `find_unique_weapon`.
        3:
          id: vehicle_to
          doc: |
            Used in `travel_start` zones as a trigger to teleport to the
            corresponding `travel_end` zone. The hotspot argument contains the
            id of the zone to teleport to.
        4:
          id: vehicle_back
          doc: |
            Counter part to `vehicle_to` hotspots. This is used to determine
            the hero's position on the zone after the `vehicle_to` hotspot has
            been triggered and to teleport back to the zone on main land.
        5:
          id: drop_map
          doc: |
            Hotspot that drops the map (aka locator) tile. One `find` zone
            with a hotspot of this type will be placed next to a town during
            world generation.
        6:
          id: drop_item
          doc: |
             Hotspot that, when triggered drops the item specified in the
             hotspot's argument. If the item is set to `0xFFFF` the zone's
             quest item will be dropped.
        7:
          id: npc
          doc: |
            This seems to be a placeholder for a pre-assigned NPC.
        8:
          id: drop_weapon
          doc: |
            Drops a weapon (specified by the hotspot argument) when triggered.
        9:
          id: door_in
          doc: |
            When triggered this hotspot type move the hero to the zone
            specified in the hotspot argument. The hero's location on the new
            zone will be determined by a corresponding `door_out` hotspot in
            the target zone.
        10:
          id: door_out
          doc: |
            Determines where the hero will be placed when the zone is entered
            through a door. When triggered, this transports the player back to
            the `door_in` hotspot they game from.
        11: unused
        12: lock
        13:
          id: teleporter
          doc: |
            Teleporter hotspots can be used to instantly teleport to other
            (visited) teleporters on the map
        14:
          id: ship_to_planet
          doc: |
            Behaves similar to the `vehicle_to` hotspot type but travels
            between the town and the swamp planet.
        15:
          id: ship_from_planet
          doc: |
            Behaves similar to the `vehicle_back` hotspot type but travels
            between the town and the swamp planet.

  zone_auxiliary:
    seq:
      - id: marker
        contents: "IZAX"
      - id: size
        type: u4
      - type: u2
      - id: num_monsters
        type: u2
      - id: monsters
        type: monster
        repeat: expr
        repeat-expr: num_monsters
      - id: num_required_items
        type: u2
      - id: required_items
        doc: List of items that can be used to solve the zone.
        type: u2
        repeat: expr
        repeat-expr: num_required_items
  zone_auxiliary_2:
    seq:
      - id: marker
        contents: "IZX2"
      - id: size
        type: u4
      - id: num_provided_items
        type: u2
      - id: provided_items
        doc: Items that can be gained when the zone is solved.
        type: u2
        repeat: expr
        repeat-expr: num_provided_items
  zone_auxiliary_3:
    seq:
      - id: marker
        contents: "IZX3"
      - id: size
        type: u4
      - id: num_npcs
        type: u2
      - id: npcs
        doc: |
          NPCs that can be placed in the zone to trade items with the hero.
        type: u2
        repeat: expr
        repeat-expr: num_npcs
  zone_auxiliary_4:
    seq:
      - id: marker
        contents: "IZX4"
      - id: size
        type: u4
      - type: u2
  zones:
    seq:
      - id: num_zones
        type: u2
      - id: zones
        type: zone
        repeat: expr
        repeat-expr: num_zones
  puzzles:
    seq:
      - id: puzzles
        type: puzzle
        repeat: until
        repeat-until: _.index == 0xFF_FF
  puzzle:
    seq:
      - id: index
        type: u2
      - id: marker
        if: index != 0xFF_FF
        contents: "IPUZ"
      - id: size
        type: u4
        if: index != 0xFF_FF
      - id: item1_class
        type: u4
        enum: puzzle_item_class
        if: index != 0xFF_FF
      - id: item2_class
        type: u4
        enum: puzzle_item_class
        if: index != 0xFF_FF
      - type: u2
        if: index != 0xFF_FF
      - id: strings
        type: prefixed_str
        repeat: expr
        repeat-expr: 5
        if: index != 0xFF_FF
      - id: item_1
        type: u2
        if: index != 0xFF_FF
    enums:
      puzzle_item_class:
        0: keycard
        1: tool
        2: part
        4: valuable
        0xFFFF_FFFF: none
  endf:
    seq: []
  tgen:
    doc: |
        The TGEN section is only present in non-english versions of the game. It's purpose or
        internal structure is unknown.
    seq:
      - id: data
        size: _parent.size
  characters:
    seq:
      - id: characters
        type: character
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character:
    seq:
      - id: index
        type: u2
      - id: marker
        contents: "ICHA"
        if: index != 0xFF_FF
      - id: size
        type: u4
        if: index != 0xFF_FF
      - id: name
        type: strz
        size: 16
        if: index != 0xFF_FF
      - id: type
        type: u2
        enum: character_type
        if: index != 0xFF_FF
      - id: movement_type
        type: u2
        enum: movement_type
        if: index != 0xFF_FF
      - id: frame_1
        type: char_frame
        if: index != 0xFF_FF
      - id: frame_2
        type: char_frame
        if: index != 0xFF_FF
      - id: frame_3
        type: char_frame
        if: index != 0xFF_FF
    enums:
      character_type:
        1: hero
        2: enemy
        4: weapon
      movement_type:
        0: none
        4: sit
        9: wander
        10: patrol
        12: animation
  char_frame:
    seq:
      - id: tiles
        type: u2
        repeat: expr
        repeat-expr: 0x8
  character_auxiliaries:
    seq:
      - id: auxiliaries
        type: character_auxiliary
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character_auxiliary:
    seq:
      - id: index
        type: u2
      - id: damage
        type: s2
        if: index != 0xFF_FF
  character_weapons:
    seq:
      - id: weapons
        type: character_weapon
        repeat: until
        repeat-until: _.index == 0xFF_FF
  character_weapon:
    seq:
      - id: index
        type: u2
      - id: reference
        doc: |
          If the character referenced by index is a monster, this is a
          reference to their weapon, otherwise this is the index of the
          weapon's sound
        type: u2
        if: index != 0xFF_FF
      - id: health
        type: u2
        if: index != 0xFF_FF
  action_names:
    seq:
      - id: names
        type: zone_action_name
        repeat: until
        repeat-until:  _.zone_id == 0xFF_FF
  zone_action_name:
    seq:
      - id: zone_id
        type: u2
      - id: action_names
        type: action_name
        repeat: until
        repeat-until: _.action_id == 0xFF_FF
        if: zone_id != 0xFF_FF
  action_name:
    seq:
      - id: action_id
        type: u2
      - id: name
        type: strz
        size: 0x10
        if: action_id != 0xFF_FF
  puzzle_names:
    seq:
      - id: num_puzzle_names
        type: u2
      - id: puzzle_names
        type: strz
        size: 0x10
        repeat: expr
        repeat-expr: num_puzzle_names
  zone_names:
    seq:
      - id: zone_names
        type: zone_name
        repeat: until
        repeat-until: _.zone_id == 0xFF_FF
  zone_name:
    seq:
      - id: zone_id
        type: u2
      - id: name
        type: strz
        size: 0x10
        if: zone_id != 0xFF_FF
  hotspots:
    seq:
      - id: zone_hotspots
        type: zone_hotspot
        repeat: until
        repeat-until: _.zone_id == 0xFF_FF
  zone_hotspot:
    seq:
      - id: zone_id
        type: u2
      - id: num_hotspots
        type: u2
        if: zone_id != 0xFF_FF
      - id: hotspots
        type: hotspot
        repeat: expr
        repeat-expr: num_hotspots
        if: zone_id != 0xFF_FF
  actions:
    seq:
      - id: zone_actions
        type: zone_action
        repeat: until
        repeat-until: _.zone_id == 0xFF_FF
  zone_action:
    seq:
      - id: zone_id
        type: u2
      - id: num_actions
        type: u2
        if: zone_id != 0xFF_FF
      - id: actions
        type: action
        repeat: expr
        repeat-expr: num_actions
        if: zone_id != 0xFF_FF
  zones_aux_1:
    seq:
      - id: zone_auxiliaries
        type: zone_auxiliary
        repeat: expr
        repeat-expr: _root.catalog[4].content.as<zones>.num_zones
  zones_aux_2:
    seq:
      - id: zone_auxiliaries
        type: zone_auxiliary_2
        repeat: expr
        repeat-expr: _root.catalog[4].content.as<zones>.num_zones
  zones_aux_3:
    seq:
      - id: zone_auxiliaries
        type: zone_auxiliary_3
        repeat: expr
        repeat-expr: _root.catalog[4].content.as<zones>.num_zones
  zones_aux_4:
    seq:
      - id: zone_auxiliaries
        type: zone_auxiliary_4
        repeat: expr
        repeat-expr: _root.catalog[4].content.as<zones>.num_zones
  # Utilities
  prefixed_str:
    seq:
      - id: len_content
        type: u2
      - id: content
        type: str
        size: len_content
  prefixed_strz:
    seq:
      - id: len_content
        type: u2
      - id: content
        type: strz
        size: len_content

Yodasav.ksy

This is a machine-readable definition of the save game format used by Yoda Stories. It can be used to generate a parser or inspect files online in the Kaitai Web IDE.

meta:
  id: yodasav
  file-extension: wld
  application: "Yoda Stories"
  endian: le
  encoding: ASCII
seq:
  - id: magic
    contents: "YODASAV44"
  - id: seed
    type: u4
  - id: planet
    type: u4
  - id: on_dagobah
    type: u4
  - id: puzzles1
    type: id_array
  - id: puzzles2
    type: id_array
  - id: dagobah
    type: dagobah
  - id: world
    type: world
  - id: inventory_count
    type: u4
  - id: inventory
    type: u2
    repeat: expr
    repeat-expr: inventory_count
  - id: current_zone
    type: u2
  - id: world_x
    type: u4
  - id: world_y
    type: u4
  - id: current_weapon
    type: s2
  - id: current_ammo
    type: s2
    if: current_weapon != -1
  - id: force_ammo
    type: s2
  - id: blaster_ammo
    type: s2
  - id: blaster_rifle_ammo
    type: s2
  - id: zone_x
    type: u4
  - id: zone_y
    type: u4
  - id: damage_taken
    type: u4
  - id: lives_left
    type: u4
  - id: difficulty
    type: u4
  - id: time_elapsed
    type: u4
  - id: world_size
    type: u2
  - id: unknown_array_count
    type: u2
  - id: unknown_array_sum
    type: u2
  - id: end_puzzle
    type: u4
  - id: end_puzzle_again
    type: u4

types:
  id_array:
    seq:
      - id: count
        type: u2
      - id: content
        type: u2
        repeat: expr
        repeat-expr: count
  world_thing:
    seq:
      - id: unknown1
        type: u4
      - id: unknown2
        type: u4
      - id: unknown3
        type: u4
      - id: unknown4
        type: u4
      - id: unknown5
        type: u4
      - id: zone_id
        type: u2
      - id: unknown6
        type: u2
      - id: required_item
        type: u2
      - id: provided_item
        type: u2
      - id: unknown7
        type: u2
      - id: additionally_required_item
        type: u2
      - id: unknown8
        type: u2
      - id: puzzle_npc
        type: u2
      - id: unknown9
        type: u4
      - id: unknown10
        type: u2
      - id: rooms
        type: room
  dagobah:
    seq:
      - id: world_things
        type: world_thing
        repeat: expr
        repeat-expr: 2 * 2
      - id: zones
        type: zone
        repeat: until
        repeat-until: _.unknown1 == -1 or _.unknown2 == -1
  world:
    seq:
      - id: world_things
        type: world_thing
        repeat: expr
        repeat-expr: 10 * 10
      - id: zones
        type: zone
        repeat: until
        repeat-until: _.unknown1 == -1 or _.unknown2 == -1
  rooms:
    seq:
      - id: rooms
        type: room
        repeat: until
        repeat-until: _.unknown1 == -1
  room:
    seq:
      - id: unknown1
        type: s4
      - id: unknown2
        type: s4
      - id: zone_id
        type: s2
        if: unknown1 == -1
      - id: unknown3
        type: u4
        if: unknown1 == -1
  zone:
    seq:
      - id: unknown1
        type: s4
      - id: unknown2
        type: s4

List of game files

The following is a list of checksum of files related to Yoda Stories or Indiana Jones and His Desktop Adventures. If you have access to other versions of the games feel free to add them below.

Yoda Stories

Yoda Stories (English)

Yoda Stories (Spanish)

Yoda Stories (German)

Yoda Stories Demo (English)

Indiana Jones and his Desktop Adventures

Indiana Jones and his Desktop Adventures (English)

Indiana Jones and his Desktop Adventures (French)

Indiana Jones and his Desktop Adventures (Spanish)