Scripting Reference

Contents

Welcome!

You are reading the Lua scripting reference manual for Legend of Grimrock 2. The focus of this document is on completeness rather than brevity. Refer to the tutorials for more detailed examples on how to use the material described here.

The Lua functions and methods described here can be accessed from a script entity and typed on the console.

In addition the following standard Lua functions can be used: tonumber, tostring, type, pairs, ipairs, and all functions in table, math and string modules. See the Lua reference manual for more details about their usage.

Entities and Components

Entities, game objects (or just “go”) are the objects spawned in the dungeon either by placing them in the dungeon using the Dungeon Editor or spawning them dynamically from a script. For example, instances of buttons, pressure plates, teleporters and the party are all entities. Each entity has an id, a string which identifies the entity uniquely. You can refer to an entity by simply typing it’s id. For example, the following script prints the world coordinates of the entity with the id “party” to the console:

print(party:getWorldPosition())

Entities themselves do not have much useful functionality. Instead, interesting objects are made by adding components to the entities. For example, you would build an object with a 3D model that emits a continuous sound by adding a Model and a Sound component to an entity. A component is always created and owned by a single entity and components cannot exists without an entity. Each component has a class, e.g. Door and Model are classes, and a name which uniquely identifies the components inside its entity. By default the name of a component is the class name in lower case but you can pick any name when defining assets. Usually one entity can have only one component of a kind (for example, single Door component per entity) but some components do not have this restriction. For example, an entity can have any number of Model, Light, Particle and Sound components. In this case, each component must be explicitly and uniquely named (for example, “model1”, “model2”).

All entities have the following properties that can be accessed with the dot operator:

• name: returns the name of the entity
• id: returns the unique identifier of the entity
• x: returns the x-coordinate of the entity on the map
• y: returns the y-coordinate of the entity on the map
• elevation: returns the elevation of the entity on the map (0 = ground level)
• facing: returns the facing of the entity (0=north, 1=east, 2=south, 3=west)
• level: returns the dungeon level index of the entity
• map: returns the Map object representing the dungeon level where the entity is
• xyz: returns the component named “xyz” (or nil if no such component exists)

For example, “torch1.x” would return the x-coordinate of the entity named “torch1”, and “torch1.light” would returns the component named “light”.

All components have the following properties that can be accessed with the dot operator:

• go: returns the entity that owns the component

For example, “item.go.model” would return the component named “model” attached to the item component.

You can also refer to the script entity itself from its own script code using the implicit “self” variable. This can be handy if you need to refer to it’s coordinates. For example the following script prints the x- and y-coordinates of the script entity to the console:

print(self.x, self.y)

Some special objects have no direct representation of them in the dungeon. For example, a Champion is an object that is contained inside the Party entity. You have no direct access to these objects but various functions return references to them. For example, the following script retrieves the first champion in the party and changes his name:

party.party:getChampion(1):setName("Jakob")

Global Functions

print(…)
Prints all arguments to the console.

iff(cond, a, b)
Returns a if cond is true, otherwise returns b.

vec(x, y, z, w)
Returns a new vector. All components are optional and default to zero.

getForward(direction)
Converts direction, a number between 0 and 3 corresponding to a compass direction, to delta-x and delta-y values.

getDirection(dx, dy)

toLocal(ox, oy, facing, x, y)

delayedCall(receiver, delay, msg)

spawn(object, level, x, y, facing, elevation, [id])
Spawns a new object at given position on a dungeon level where x and y specify the x- and y-coordinates on the map and level is a level index. facing must be a number between 0 and 3 and it indicates the following directions: 0=north, 1=east, 2=south, 3=west. id parameter is optional. If given it must be an unique id in the context of the dungeon. If not given an unique id is automatically generated.

findEntity(id)
Returns an entity with given name or nil if no such entity exists.

hudPrint(text)
Prints a line of text to the text area at the bottom of the screen.

setMouseItem(item)
Sets the given item as mouse item, or destroys the mouse item if item is nil.

getMouseItem()
Returns the “mouse item”, the item attached to the mouse pointer. If there is no mouse item, nil is returned.

playSound(sound)
Plays a sound effect. sound must be a name of a built-in or custom sound effect.

playSoundAt(sound, level, x, y)
Plays a sound effect at given position. sound must be a name of a built-in or custom sound effect.

rollDamage(power)
Returns a random amount of damage for an attack with given power.

damageTile(level, x, y, direction, elevation, flags, damageType, power)
Damages all creatures including the party in a given tile. direction specifies the direction of the attack for projectiles or melee attacks (0=north, 1=east, 2=south, 3=west). damageType must be one of the following: “physical”, “fire”, “poison”, “cold”, “shock”. Damage is rolled individually for all creatures using the power as base value. See also DamageFlags.

shootProjectile(projectile, level, x, y, direction, speed, gravity, velocityUp, offsetX, offsetY, offsetZ, attackPower, ignoreEntity, fragile, championOrdinal)
Shoots a projectile item. The parameters are:

• projectile: the name of the item to shoot.
• level,x,y: the initial position of the projectile in a level.
• direction: the shooting direction (0=north, 1=east, 2=south, 3=west).
• speed: the speed of the projectile (metres/second). Typical values around 10.
• gravity: the gravity force in y-direction. Typical values around 0.
• velocityUp: the initial velocity in y-direction. Typically set to 0.
• offsetX,offsetY,offsetZ: 3D offset in world space from the center of cell.
• attackPower: attack power of the projectile.
• ignoreEntity: the entity to be ignored for collisions (or nil if the entity should not ignore any collisions).
• fragile: a boolean flag, if set the projectile is destroyed on impact.
• championOrdinal: a champion ordinal number, used for dealing experience points. This parameter is optional.

Asset Definitions

The following functions can be used in dungeon’s init.lua script to define new assets.

defineAnimationEvent(desc)
Defines a new animation event. desc is a table with the following fields:

• animation: the name of animation file to attach animation event to. The filename must end with “.fbx”
• event: the animation event string, e.g. “footstep” or “attack”.
• frame: (optional) a frame number in the animation to attach the event to (one frame equals 1/30th of a second).
• normalizedTime: (optional) normalized time of the event in range 0-1 to be used instead of frame (0 = start of animation, 1 = end of animation).

defineObject(desc)
Defines a new entity type or replaces an existing definition. desc is a table with the following fields:

• name: the name of the object to define or replace.
• baseObject: (optional) the name of the base object definition to clone.
• components: an array of components to add or override (see below).
• placement: placement of the object in the square: “floor”, “ceiling”, “wall” or “pillar”.
• replacesWall: (optional) a boolean, if true the object removes an existing wall object when spawned.
• replacesFloor: (optional) a boolean, if true the object removes an existing floor object when spawned.
• replacesCeiling: (optional) a boolean, if true the object removes an existing ceiling object when spawned.
• editorIcon: index of the icon in Dungeon Editor.
• automapTile: (optional) automap tile type: “ground”, “grassy_ground”, “water”, “wall”, “rocky_wall”, “trees” or “chasm”.
• automapIcon: (optional) icon index in automap icon sheet.

The components field should contain a list of components to be added or replaced in the base object class. Each component has a class and a name. The name of a component is by default its class in lower case. Each component have the following fields:

• class: the class name of the component without the “Component” part. E.g. “Model”.
• name: (optional) the name of the component. Convention is to use lower case names.
• enabled: (optional) the initial enabled state of the component (default is true).
• xyz: (optional) sets the xyz property of the component by calling setXyz() method of the component. Any setter that receives a single parameters can be called using this mechanism.
• onXyz: (optional) adds the xyz hook to the component.

See component classes for details on properties and hooks supported by various components.

defineSound(desc)
Defines a new sound or replaces an existing sound definition. The samples used need to be 16bit 44100Hz .wav-files. desc is a table with the following fields:

• name: the name of the sound to define or replace.
• filename: the filename of the sample in wave format. The filename must be a valid asset reference ending with “.wav”. Optionally the filename may be a table containing multiple filenames for random sound variations.
• loop: a boolean which turns on and off looping.
• volume: a number between 0 and 1 which controls the amplitude of the sound.
• minDistance: the minimum distance in squares for sound falloff. The sound plays at max volume if it is closer than min distance to the listener.
• maxDistance: the maximum distance in squares for sound falloff. The sound is not audible after max distance.

defineParticleSystem(desc)
Defines a new particle system or replaces an existing particle system definition. desc is a table with the following fields:

• name: the name of the particle system to define or replace.
• emitters: a table of emitter descriptors. See below.

An emitter descriptor is a table which contains the parameters for a particle emitter. The following parameters are supported:

• emitterShape: type of the emitter, either “BoxShape” (default) or “MeshShape”.
• emissionRate: number of particles to emit per second.
• emissionTime: duration of emission in seconds. If set to zero, emission time is infinite.
• maxParticles: maximum number of active particles. Sensible values are between 100 and 1000.
• spawnBurst: if enabled maximum number of particles are emitted in a single burst when the particle system is started.
• boxMin: a 3D vector defining the minimum extents for particle emission.
• boxMax: a 3D vector defining the maximum extents for particle emission.
• sprayAngle: a table whose first and second elements set the minimum and maximum spraying angle in degrees.
• velocity: a table whose first and second elements set the minimum and maximum velocity in units per second.
• size: a table whose first and second elements set the minimum and maximum size for for emitted particles.
• lifeTime: a table whose first and second elements set the minimum and maximum lifetime for emitted particles.
• texture: a valid texture asset reference. The texture may contain multiple frames laid out on a grid.
• frameSize: (optional) pixel size of a frame in the particle animation sequence. Typically 32 or 64.
• frameCount: (optional) total number of frames in the particle animation sequence.
• frameRate: (optional) frame rate of the particle animation sequence.
• color0: a table containing R,G,B values in range 0-1 for initial particle color.
• color1,color2,color3: (optional) particle color sequence. These parameters have no effect if colorAnimation is not enabled.
• colorAnimation: a boolean which enables particle color animation.
• opacity: particle opacity value between 0 and 1.
• fadeIn: particle’s fade in time in seconds.
• fadeOut: particle’s fade out time in seconds.
• gravity: a 3D gravity vector.
• airResistance: air resistance parameter. Sensible values are between 0 and 10.
• rotationSpeed: rotation speed of particles in degrees.
• randomInitialRotation: a boolean flag, if enabled particles’ initial rotation angle is randomized.
• blendMode: blending mode for particle rendering. Must be either “Additive” or “Translucent”.
• objectSpace: a boolean flag, if enabled particles are emitted to object space rather than world space.
• clampToGroundPlane: a boolean flag, if enabled particles collide against the ground.
• depthBias: depth bias value in world space units.

defineRace(desc)
Defines a new race or replaces an existing race definition. desc is a table with the following fields:

• name: the name of the race to define or replace.
• uiName: the name of the race displayed to the user.
• inventoryBackground: filename of the background texture in character sheet.

A champion automatically gains the trait with the same name as his race.

defineCharClass(desc)
Defines a new character class or replaces an existing class definition. desc is a table with the following fields:

• name: the name of the race to define or replace.
• uiName: the name of the race displayed to the user.
• traits: (optional) list of extra traits provided by the character class.
• skillPoints: (optional) number of skill points received at first level (default is 2).

A champion automatically gains the trait with the same name as his character class.

defineSkill(desc)
Defines a new skill or replaces an existing skill definition. desc is a table with the following fields:

• name: the name of the skill to define or replace.
• uiName: the name of the skill displayed to the user.
• priority: sorting priority for UI. Built-in skills have priorities 10,20,30,…
• icon: icon index in the skill texture atlas.
• iconAtlas: (optional) filename of the icon atlas. Icons are 75×75 and the width and height of the atlas must be multiple of icon size.
• description: textual description of the skill.
• gameEffect: (optional) textual description of the game effect provided by the skill.
• traits: (optional) a table of new traits gained when progressing in the skill. For example, { [3] = “pack_mule” }.
• onRecomputeStats(champion, skillLevel): (optional) a hook for modifying champion’s attributes based on skill level. champion:addStatModifier() can be called from inside the hook.
• onComputeAccuracy(champion, weapon, attack, attackType, skillLevel): (optional) a hook for modifying accuracy of an attack. The function should return an accuracy modifier.
• onComputeCritChance(champion, weapon, attack, attackType, skillLevel): (optional) a hook for modifying critical hit chance of an attack. The function should return a critical hit modifier.

defineTrait(desc)
Traits work almost exactly like skills except they are on/off rather than having a level. See defineSkill() for a list of supported fields. The following additional fields are supported for traits:

• charGen: (optional) a boolean, if set the trait can be chosen at character creation.
• requiredRace: (optional) the name of the race for racial traits.
• hidden: (optional) a boolean, if set the trait is not shown in Traits tab.

defineMaterial(desc)
Defines a new material or replaces an existing material definition. desc is a table with the following fields:

• name: the name of the material to define or replace.
• shader: (optional) name of the built-in shader.
• diffuseMap: (optional) the filename of the diffuse texture. The filename must be valid asset reference ending with “.tga”. If no texture is specified a built-in white texture is used.
• specularMap: (optional) the filename of the specular texture. The filename must be valid asset reference ending with “.tga”. If no texture is specified a built-in white texture is used.
• normalMap: (optional) the filename of the normal map. The filename must be valid asset reference ending with “.tga”. If no texture is specified normal mapping is turned off.
• doubleSided: (optional) a boolean specifying whether the surface using the material can be seen from both sides.
• lighting: (optional) a boolean which turns on and off dynamic lighting.
• castShadow: (optional) a boolean which turns on and off shadow casting.
• ambientOcclusion: (optional) a boolean which turns on and off ambient occlusion.
• alphaTest: (optional) a boolean which turns on and off alpha testing.
• blendMode: (optional) the alpha blending mode, must be one of the following: “Opaque”, “Translucent”, “Additive”, “Modulative”.
• textureAddressMode: (optional) texture addressing mode:”Wrap”, “Clamp”, “WrapU_ClampV_WrapW”, “ClampU_WrapV_WrapW”, “WrapU_ClampV_ClampW” or “ClampU_WrapV_ClampW”.
• glossiness: (optional) the glossiness parameter for specular lighting. Typical values range between 1 and 100.
• depthBias: (optional) depth bias value. It is recommended to set this always to zero.
• onUpdate(material, time): (optional) hook to be called every frame. It can be used to animate materials.

defineSpell(desc)
Defines a new spell or replaces an existing spell. desc is a table with the following fields:

• name: the name of the spell to define.
• uiName: the name shown to the user (e.g. in spell scrolls).
• skill: the name of the skill used to cast the spell.
• requirements: the requirements for this spell, e.g. { “concentration”, 3 }.
• gesture: a numeric value encoding the spell gesture (see below).
• manaCost: number of mana points to spend when casting the spell.
• icon: index of the skill icon in Traits tab.
• iconAtlas: (optional) filename of the icon atlas. Icons are 75×75 and the width and height of the atlas must be multiple of icon size.
• spellIcon: index of the spell preview icon in rune panel.
• spellIconAtlas: (optional) filename of the spell icon atlas. Spell icons are 50×50 and the width and height of the atlas must be multiple of icon size.
• description: textual description of the spell.
• onCast(champion, x, y, direction, elevation, skillLevel): built-in spell function name or a custom spell function.

Spell gestures are encoded into numeric values. Each digit in the number corresponds to a rune. The available runes are: 1 = Fire, 2 = Life, 3 = Air, 4 = Spirituality, 5 = Balance, 6 = Physicality, 7 = Earth, 8 = Death, 9 = Water. For example, 1236 would be the gesture of the Fireball spell.

defineRecipe(desc)
Defines a new potion recipe or replases an existing recipe. desc is a table with the following fields:

• name: the name of the potion recipe to define or replace.
• level: Alchemy skill level needed to craft the potion.
• ingredients: a number describing the ingredients.

Ingredients are encoded into numeric value. Each digit in the number corresponds to an herb. The available herbs are: 1 = Blooddrop Cap, 2 = Etherweed, 3 = Mudwort, 4 = Falconskyre, 5 = Blackmoss, 6 = Crystal Flower. For example, 115 would translate to a recipe with two Blooddrop Caps and one Blackmoss.

defineTile(desc)
Defines a new tile for Dungeon Editor or replases an existing definition. desc is a table with the following fields:

• name: the name of the tile to define or replace.
• editorIcon: index of the icon in Dungeon Editor tile atlas.
• color: (optional) color of the editor icon, e.g. {255,255,255,255} is solid white.
• randomFloorFacing: (optional) a boolean, when true facing of spawned floor objects will be randomized.
• solid: (optional) a boolean, if true the square is solid wall.
• diggable: (optional) a boolean, if true the square can be digged.
• underwater: (optional) a boolean, if true the square is under water.
• heightmapMaterial: (optional) material name for heightmap building.
• heightmapMaterialPriority: (optional) priority for heightmap material blending. Higher priority materials blends over low priority materials.
• builder: (optional) type of geometry builder, “dungeon” or “mine”.
• floor: (optional) a table of floor object names and their relative probabilities. See below.
• wall: (optional) a table of wall object names and their relative probabilities. See below.
• pillar: (optional) a table of pillar object names and their relative probabilities. See below.
• centerPillar: (optional) a table of pillar object names to be placed in the center of cells and their relative probabilities for mine builder. See below.
• ceiling: (optional) a table of ceiling object names and their relative probabilities. See below.
• ceilingShaft: (optional) the name of the object automatically spawned if there’s a pit above.
• ceilingEdgeVariations: (optional) a boolean, if set ceiling objects use 16 different variations for all possible configurations of adjacent tiles. A bitmask _XXXX will be appended to ceiling object name, where each bit is either 0 (adjancent tile is empty space) or 1 (adjacent tile is solid).
• automapTile: (optional) the name of the automap tile: “ground”, “grassy_ground”, “water”, “wall”, “rocky_wall”, “trees” or “chasm”
• moveSound: (optional) the name of sound played when the party walks on the tile.

The tables referred above contain lists of objects and their probabilities that are used to randomly pick up pieces for generating the levels. At every odd table index there must be a valid object name. At every even table index there must be a number that indicates the relative probability of the object.

For example, the following would generate a wall drain approximately every 50th generated wall:

wall = {
    "dungeon_wall_01", 50,
    "dungeon_wall_drain", 1,
}

Components

Makes an item ammo for missile or firearm attack. The ammo types must match in the Ammo component and the attack component.

Adds animations to the 3D model attached to the same GameObject. The GameObject must have a Model component.

Implements the behavior of altars in Elemental Shrines. The name of the class is weird because of historical reasons.

Spawns objects in 2 square radius area. Used to implement Magma Golem’s flame wave attack.

Makes a thrown item explode when it hits something.

Implements boss fights. When activated, bossfight music starts and a progress bar is displayed at the top of the screen. The boss fight ends automatically when all monsters taking part in it are destroyed or it can be manually deactivated.

Base-class for all monster brains. You can either use one of the built in brains (e.g. TurleBrain) or implement a custom onThink hook. When the monster is ready to perform a new action, the brain’s onThink hook is called. The brain should respond by calling monster component’s performAction() method with a valid action name. The brain class itself contains many higher level behaviors such as fleeing and pursuit which can be used in place of performAction() to delegate decision making. If the brain can not decide what to do, Brain:wait() should be called. This will put the monster’s brain to sleep for a short time (typically 0.1s) to prevent extensive CPU usage.

Implements the burning condition for monsters. A monster with the burning condition is dealt ongoing fire damage until the effect’s duration ends or the monster dies.

Implements wall button mechanics for an object. Requires Clickable and Animation component. When the object is clicked, the button component plays a sound, tells the animation component to play “press” animation clip and triggers its onActivate hook and connectors.

Custom camera component for rendering from arbitrary view point.

Implements cast spell actions for spell wands. When used, a spell stored in the wand is cast. Optionally the wand may have limited number of charges.

Champion’s attributes, skills, traits, conditions and other statistics can be accessed through this class.

Implements the chest opening and closing animations. A chest be optionally locked and it could be mimic.

Defines the click box of an object. onClick hook is called when the player clicks on the object. A GameObject can have any number of Clickables.

A CloudSpell deals ongoing damage to party, monsters and obtacles in the same square. The component is automatically destroyed when its duration runs out.

Base-class for all Components. A Component always belongs to one and only one GameObject. Components can be enabled and disabled. A disabled component usually acts as it would not exist in the game.

Makes an item a container for other items.

Generic controller component which can be used to implement custom activate/deactivate/toggle, open/close, increment/decrement or start/stop semantics for an object. For example, if you add onActivate and onDeactivate hooks to the Controller, the controller can act as target for activate and deactivate events in the Dungeon Editor.

Counters start with an initial value and count down when activated. When counter’s value reaches zero, it calls its onActivate hook and triggers onActivate connectors.

Implements AI for Cave Crabs.

Implements the animation and behavior of healing crystals.

Door component blocks movement and projectiles from passing between two adjacent squares. Requires a Model component with a node named “gate”. The gate node is animated when the door is opened and closed. Doors can either open vertically (single doors) or horizontally (double doors).

Implemented various modifiers to stats of an Champion when the item is equipped. The traits of an item define where the item can be equipped.

Implements AI for Eyctopuses.

Implements AI for Fire Elementals.

Implements firearm attacks. Firearm attacks need ammo.

A floor trigger reacts to objects placed into trigger’s square. A floor trigger can be in two states: activated and deactivated. When an object is placed on a deactivated trigger, it changes to activated state and fires its onActivate hooks and connectors. Similarly when an object is removed from the square of an activated trigger, the trigger changes into deactivated state and fires its onDeactivate hooks and connectors.

Overrides fog parameters for indoor scenes. This component is used to make the fog green in Herder’s Den level in the main campaign. Only works indoors! The Sky component defines fog parameters for outdoor scenes.

Adds particle fog effect to the scene. The effect quite heavy on performance so use it wisely.

GameObject is a container for Components. A GameObject has a position and orientation in the world.

Implements AI for Goromorgs.

Implements the Goromorg shield effect for monsters. The shielded monster is invulnerable to all damage. Instead the damage is directed to the shield. When the shield’s energy is depleted the shield is destroyed.

Makes the object fall unless it is on ground or supported by a surface or a platform.

Makes the object breakable. Typically used with Obstacle component to make breakable obstacles. When the health value reaches zero, the object is destroyed.

Implements AI for Big Herders.

Implements AI for Small Herders.

Implements AI for Ice Guardians.

Implements AI for Ice Lizards.

Implements the Ice Shards spell.

Base-class for item actions (usually attacks). onAttack hook is called when the item’s action is performed by an champion.

Makes the object an item that can be picked up, dropped, thrown and placed into champions’ hands and inventory. Requires Model component.

A controller component that implements lever mechanics for an object. The GameObject should have a Clickable and an Animation component with “activate” and “deactivate” animation clips attached to it.

Dynamic light source for rendering. A single GameObject can have multiple Light components.

Implements AI for the Lindworm.

A controller component that implements lock mechanics for an object. Requires Clickable component.

Implements AI for Magma Golems.

Contains all entities (also known as GameObjects) of a dungeon level. Map size is currently always 32 by 32.

Adds custom graphics to the automap.

Adds a marker with text on the automap.

Holds parameters of a rendering material. Materials can only be accessed from material definition’s onUpdate hooks.

Implements melee attack action for items. Melee attacks can hit and damage a single target in front of the party.

Implements AI for generic (stupid) melee monsters.

3D model for rendering. A single GameObject can have multiple Model components.

Implements a custom monster action. An action is always connected with an animation that controls when the action starts and ends. onBeginAction and onEndAction hooks are called when the action is started and ended. onAnimationEvent hook is called when an animation event is triggered.

Implements a monster attack action. A monster can have more than one attacks.

Implements a monster charge action. When the action is started, it first plays the “chargeBegin” animation after which it alternates between “chargeContinue1” and “chargeContinue2” animations until the charge ends. Each animation moves the monster forward by one square.

Makes the object a monster. Requires Model, Animation and a brain component. Most monsters (depending on the brain) also require MonsterMove, MonsterTurn and MonsterAttack components.

Spawns a group of monsters when the next time the level is updated.

Implements low level movement behavior for monsters.

Implements low level turning behavior for monsters.

Implements AI for Mosquito Swarms.

Blocks movement for party and monsters. Optionally prevents placing items into obstacle’s square. Use the Health component to make the obstacle breakable.

Implements AI for Ogres.

Adds a particle effect to the GameObject. A single GameObject can have multiple Particle components.

The singular party component that holds the four champions. Champion’s position in the party can change when party formation is changed. However champions can be identified with their ordinal number that never changes.

Implements pit mechanics for an object. Non-flying monsters, items and party fall down to level below if the pit is open.

Implements the poisoned condition for monsters. A monster with the poisoned condition is dealt ongoing poisoned damage until the effect’s duration ends or the monster dies.

Defines the collision box for projectile-object collisions. Walls, doors, monsters and the party are implicitly projectile colliders and do not need ProjectileCollider components.

Causes the object to fly towards its facing direction. When the projectile hits something its onProjectileHit hook is called.

Implements custom hit reaction for a projectile hit. This component is obsolete and not used by the main campaign. Use an onProjectileHit hook in the Projectile component instead.

Implements pushable block mechanics for an object. The pushable block must be activated and it can only be pushed to squares with pushable block floors.

Implements custom floor trigger for pushable blocks.

Implements missile attack action for items. Missile attacks require ammo that must be held in champion’s other hand.

Implements AI for generic (stupid) ranged monsters.

Implements AI for the Ratling Boss.

Custom Lua script component. The script code may be embedded inside the component or in an external file.

Displays a piece of text or an image in item’s tooltip.

Implements secret mechanics for an object. When the secret component is activated, it playes the secret found sound and increments the “secrets_found” statistics. Each secret can be triggered only once.

Implements AI for Skeleton Archers.

Implements AI for Skeleton Commanders.

Placing an object with Sky component into a level makes it an outdoor level. Rendering parameters such as view distance and fog are set for outdoor rendering. The Sky component animates the light component attached to the same object to simulate day-night cycle. There should be only one Sky per level.

Implements AI for Slimes.

An attachment point for items. Wall hooks, sconces, statue’s hand could be sockets. A socket can hold a single item.

Dynamic sound source. A single GameObject can have multiple Sound components.

A Spawner dynamically spawns a new object when it’s activate method is called. After spawning an object the spawner goes into cooldown. After the cooldown time has elapsed, the spawner can be activated again.

Displays the gesture and information about a spell in item’s tooltip.

Transports the party and thrown items to another location in the game world. The target can be either a level below to above (set with setDirection method) or any location (set with setTeleportTarget).

A support for placing items. Altars, alcoves and chests are typically surfaces.

Implements AI for swarm monsters.

Transports the party, monsters, items and spells to another location in the game world.

Implements AI for Tentacles.

Implements throw attack action for items. When thrown, a Projectile component is dynamically created and added to the thrown item.

A TileDamager damages party, monsters and obstacles in the same square when activated. TileDamagers can be one shot or cause damage as long as the target stays in the same space.

Timer component triggers its onActivate hook periodically. The timer inverval or period can be customized. Timers can act in one shot mode (disable self set) or running mode (disable self not set).

Implements the animation and behavior of tiny critters such as beach crabs.

Implements AI for Swamp Toads.

Controller for torch holders. Requires Socket, Light, Sound and Particle components. The controller automatically spawns a new torch at the start of a new game and places it into the Socket component.

Makes an item a torch that burns until it runs out of fuel.

Implements AI for the Trickster.

Implements AI for Turtles.

Implements AI for Twigroots.

Implements AI for Uggardians.

A flaming special effect for creatures. Requires Model component.

Makes an item Usable by right-clicking on it.

Implements AI for Viper Roots.

Displays a piece of text in the center of the screen when the object is clicked on. Requires Clickable component.

A wall trigger is activated when a projectile hits a wall in the wall trigger’s square. The wall needs to have same facing as the wall trigger. When activated the wall trigger fires its onActivate hooks and connectors.

Implements AI for the Wargs.

Updates the reflection buffer of a water object. There should be max one water surface component per level. Water reflection is very heavy on performance so use it wisely.

Collects all water tiles in the level and creates an animated mesh covering all the tiles.

Implements AI for the Wizard.

Implements AI for Xeloroids.

Implements AI for Zarchtons.