Tales of Maj'Eyal - User contributions [en]

Doomelf

2017-03-22T03:05:28Z

BDota:

{{race
|name=Doomelf
|metarace=[[Elf]]
|locked=[[Unlockables#Races|Yes]]
|life_per_level=9
|exp_penalty=+25%
|strength=-2
|dexterity=+1
|constitution=+1
|magic=+3
|willpower=+2
}}

== Description ==

The Doomelves were added in the [[Ashes of Urh'Rok]] expansion.

Doomelves are not a real race, they are Shaloren that have been taken by demons and transformed into harbingers of doom. They enjoy unleashing torments and suffering on their victims. They possess the Haste of the Doomed talent which allows them to phase away once in a while.

== Unlock ==
* Kill [[Walrog]], [[Kryl-Feijan]], and [[Shasshhiy'Kaish]] with one character.
** Walrog can randomly spawn in dungeons with water and can be forced to spawn by killing both the dragon and naga bosses in the Eastern water dungeon.
** Kryl-Feijan can be found by entering the [[Dark Crypt]](World map event, 24+) and letting Melinda be sacrificed.
** Shasshhiy'Kaish is summoned through a random event. This event has cultists standing next to monoliths, and killing one will start the countdown to her arrival. This event can be found in [[Daikara]], [[Mark of the Spellblaze]], [[Elven Ruins]], [[Reknor]], and the [[Infinite Dungeon]] and has on average a ~72% chance to be found on a run (ignoring ID).
* This unlock is tied to an achievement and thus cannot be obtained on [[Difficulty|Easier mode]].

==Inscriptions==
*[[inscriptions|Rune: Shielding]] (Absorb 100, Duration 5, Cooldown 14)
*[[inscriptions|Rune: Heat Beam]] (40 Damage, Range 8, Cooldown 18)
*No third rune -- Likely bug

==Starting Location==
[[Searing Halls]]

== Racial Talents ==
{{:Doomelf_(category)}}

{{races}}

Doomelf

2017-03-22T03:04:55Z

BDota: Added unlock information

{{race
|name=Doomelf
|metarace=[[Elf]]
|locked=[[Unlockables#Races|Yes]]
|life_per_level=9
|exp_penalty=+25%
|strength=-2
|dexterity=+1
|constitution=+1
|magic=+3
|willpower=+2
}}

== Description ==

The Doomelves were added in the [[Ashes of Urh'Rok]] expansion.

Doomelves are not a real race, they are Shaloren that have been taken by demons and transformed into harbingers of doom. They enjoy unleashing torments and suffering on their victims. They possess the Haste of the Doomed talent which allows them to phase away once in a while.

== Unlock ==
** Kill [[Walrog]], [[Kryl-Feijan]], and [[Shasshhiy'Kaish]] with one character.
*** Walrog can randomly spawn in dungeons with water and can be forced to spawn by killing both the dragon and naga bosses in the Eastern water dungeon.
*** Kryl-Feijan can be found by entering the [[Dark Crypt]](World map event, 24+) and letting Melinda be sacrificed.
*** Shasshhiy'Kaish is summoned through a random event. This event has cultists standing next to monoliths, and killing one will start the countdown to her arrival. This event can be found in [[Daikara]], [[Mark of the Spellblaze]], [[Elven Ruins]], [[Reknor]], and the [[Infinite Dungeon]] and has on average a ~72% chance to be found on a run (ignoring ID).
** This unlock is tied to an achievement and thus cannot be obtained on [[Difficulty|Easier mode]].

==Inscriptions==
*[[inscriptions|Rune: Shielding]] (Absorb 100, Duration 5, Cooldown 14)
*[[inscriptions|Rune: Heat Beam]] (40 Damage, Range 8, Cooldown 18)
*No third rune -- Likely bug

==Starting Location==
[[Searing Halls]]

== Racial Talents ==
{{:Doomelf_(category)}}

{{races}}

God

2014-06-11T02:41:55Z

BDota:

Gods were powerful beings. Nearly all were killed by the Sher'Tul in the Godhunt, but some escaped. Gods are local phenomena, each world has their own gods, or possibly none at all.

==List of Gods==
* Amakthel
* Gerlyk
* Quekorja
* Ralkur
* Ugg'matho
* Xadoch

Modules

2013-12-20T20:17:51Z

BDota:

Discuss modules released for [[T-Engine 4]], as well as their development, here.

Looking to write your own module? [[T4 Modules Howto Guide|check out the documents here for some help.]]

A list of some modules in developement
* [[Bone Builder]]
* [[Broken Bottle]]
* [[Gatecrashers]]
* [[Iron and Steam]]
* [[Mosaic]]
* [[Qi Daozei]]
* [[RPG Engine for T-Engine]]
* [[Startide]]
* [[The Power of Dreams]]
* [[Veins of the Earth]]

[[Category:Modules]]

Tales of Maj'Eyal Wiki

2013-12-20T04:23:04Z

BDota: changed module guides link name to be more clear

__NOTOC__
'''Tales of Maj'Eyal 4''' (aka ToME 4) is an RPG Roguelike game, written as a module that runs in [[T-Engine 4]]. Download T-Engine and ToME for a myriad of Operating Systems from http://www.te4.org/download

[[T-Engine 4]] is the reboot and complete rewrite of T-Engine, released in beta form on May 11, 2010.
----
* [[tome history|History of ToME]]
* [[tome faq|Frequently Asked Questions]]
* [[tome glossary|Glossary of terms in ToME]]

'''Want to contribute to the ToME wiki?''' [[How To Contribute To The Wiki|Click here]] for how to get started.
-----

{| cellspacing="0" cellpadding="0" style="margin:0em 0em 1em 0em; width:100%; background-color:white"
| style="width:50%; vertical-align:top; border:1px solid;" |
<div style="border-bottom:1px solid; background-color:#FFB473; padding:0.2em 0.5em 0.2em 0.5em; font-size:110%; font-weight:bold;">Character Info</div>
<div style="border-bottom:0px solid; padding:0.4em 1em 1em 1em;">
* [[Classes]]
* [[Races]]
* [[Stats]]
* [[Talents]]
* [[Prodigies]]
* [[Resources]]
</div>
| style="width:50%; vertical-align:top; border:1px solid;" |
<div style="border-bottom:1px solid; background-color:#FFB473; padding:0.2em 0.5em 0.2em 0.5em; font-size:110%; font-weight:bold;">Game Info</div>
<div style="border-bottom:0px solid; padding:0.4em 1em 1em 1em;">
* [[Campaigns]]
* [[Achievements]]
* [[Backup Guardians]]
* [[Bosses]]
* [[Guides]]
* [[Quests]]
* [[Unlockables]]
* [[Vaults]]
* [[Zones]]
* [[Escorts]]
* [[Difficulty]]
* [[Permadeath]]
</div>
|}

{| cellspacing="0" cellpadding="0" style="margin:0em 0em 1em 0em; width:100%; background-color:white"
| style="width:50%; vertical-align:top; border:1px solid;" |
<div style="border-bottom:1px solid; background-color:#FFB473; padding:0.2em 0.5em 0.2em 0.5em; font-size:110%; font-weight:bold;">Game Mechanics</div>
<div style="border-bottom:0px solid; padding:0.4em 1em 1em 1em;">
* [[Character sheet]]: power, damage, saves, armor
* [[Combat Damage]]
* [[Effects]]
* [[Experience]]
* [[egos|Ego Items and their Effects]]
* [[Resources]]
* [[Vision]]
* [[Damage Types]]
</div>
| style="width:50%; vertical-align:top; border:1px solid;" |
<div style="border-bottom:1px solid; background-color:#FFB473; padding:0.2em 0.5em 0.2em 0.5em; font-size:110%; font-weight:bold;">Items</div>
<div style="border-bottom:0px solid; padding:0.4em 1em 1em 1em;">
* [[Items]]
* [[Artifacts]]
* [[Gems]]
* [[Item_list|Full List of all Items]]
* [[Materials|Item materials]]
* [[Mindstars]]
* [[Item sets]]
* [[Inscriptions]]
</div>
|}

{| cellspacing="0" cellpadding="0" style="margin:0em 0em 1em 0em; width:100%; background-color:white"
| style="width:50%; vertical-align:top; border:1px solid;" |
<div style="border-bottom:1px solid; background-color:#FFB473; padding:0.2em 0.5em 0.2em 0.5em; font-size:110%; font-weight:bold;">Development</div>
<div style="border-bottom:0px solid; padding:0.4em 1em 1em 1em;">
* [[Source Setup]]
* [[How to compile]]
* [[Lua|Lua: The language of ToME4]]
* [[Addons]]
** [[Hooks|Hooks and what they do]]
** [[Resources_for_Addons_and_Modules|Addon Resources]]
* [[Modules]]
** [[T4 Modules Howto Guide|Module creation guides]]
** [[Resources_for_Addons_and_Modules|Module Resources]]
* [[Debugging]]
* [[Command Line Arguments]]
</div>
|}

T4 Modules Howto Guide/Getting Started

2013-12-06T21:46:13Z

BDota:

<p>In order to start your own module, you need to create a new directory in the /game/modules/ directory, into which you copy the contents of either /game/modules/example/ or /game/modules/example_realtime/, which will give you bare-bones but working base to work off of.</p>

==init.lua==
<p>The first file you need to customize is the init.lua file. This file has a few things you need to edit to make this module your own:</p>

<table class="wikitable">
<tr>
<th>Setting</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>This is the official name of the module as seen in module selection list.</td>
</tr>
<tr>
<td>long_name</td>
<td>This is the long name of the module that appears is descriptions.</td>
</tr>
<tr>
<td>short_name</td>
<td>This is a short name used internal to the module. Preferred to be lower case and should be the same as the folder name.</td>
</tr>
<tr>
<td>author</td>
<td>Your name or pseudonym and email address.</td>
</tr>
<tr>
<td>homepage</td>
<td>Optional homepage of the module.</td>
</tr>
<tr>
<td>version</td>
<td>Module version. Does not automatically update. Change this between releases to differentiate them.</td>
</tr>
<tr>
<td>engine</td>
<td>Expected engine version.</td>
</tr>
<tr>
<td>description</td>
<td>A description of your module. Can be multiple lines and paragraphs.</td>
</tr>
<tr>
<td>starter</td>
<td>Only change if you know what you are doing. And if you have to ask, you don't.</td>
</tr>
<tr>
<td>show_only_on_cheat</td>
<td>If true, prevents this module from appearing in the mods list normally. This is enabled by default on the example module and should be disabled in your module.</td>
</tr>
<tr>
<td>no_get_name</td>
<td>Prevents the new character name dialog from showing up for your module. Use this if you set the character name yourself in your module.</td>
</tr>
<tr>
<td>allow_userchat</td>
<td>Registers 'space' as a key to talk, joins a channel named "module", and inits the chat system. If the game implements a game.logChat(str, ...) method it'll send chat listens to there.</td>
</tr>
<tr>
<td>background_name</td>
<td>A list of filenames (without the extension) of PNG images under the data/gfx/background directory to use as startup screen backgrounds. The game will load a logo file for each background at data/gfx/background/background_name.png if it is there</td>
</tr>
</table>

<h2 id="toc2">Launching your module using command line parameters</h2>
<p>By now you should be able to start t-engine normally and see your module in the list when you select new game. However, when changing features then quickly wanting to see its effects, this process involves a lot of unneeded clicks and wasted time. For this reason t-engine.exe supports various command line parameters.</p>

<table class="wikitable">
<tr>
<th>Parameter</th>
<th>Effect</th>
</tr>
<tr>
<td>-M<Module></td>
<td>Auto-loads the specified module (using the module's short_name).</td>
</tr>
<tr>
<td>-u<name></td>
<td>Uses the specified name for the character.</td>
</tr>
<tr>
<td>-n</td>
<td>Forces a new character, overwriting any old saves with the same name.</td>
</tr>
</table>

<p>To take advantage of this in windows, you need to right-click on t-engine.exe and select 'Create Shortcut'. On the created shortcut right-click again and select properties. In the dialog add the following to the Target field:</p>

<code>.../t-engine.exe -MMyModule -udefault -n</code>

<p>Replacing MyModule with your module name and default with whichever character name you desire. Using this shortcut now will launch your module directly, saving you some time while prototyping.</p>

Go back to [[T4 Modules Howto Guide]].

{{Module Guides}}

T4 Modules Howto Guide/Getting Started

2013-12-04T00:49:03Z

BDota:

<p>In order to start your own module, you need to create a new directory in the /game/modules/ directory, into which you copy the contents of either /game/modules/example/ or /game/modules/example_realtime/, which will give you bare-bones but working base to work off of.</p>

==init.lua==
<p>The first file you need to customize is the init.lua file. This file has a few things you need to edit to make this module your own:</p>

<table class="wikitable">
<tr>
<th>Setting</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>This is the official name of the module as seen in module selection list.</td>
</tr>
<tr>
<td>long_name</td>
<td>This is the long name of the module that appears is descriptions.</td>
</tr>
<tr>
<td>short_name</td>
<td>This is a short name used internal to the module. Preferred to be lower case and should be the same as the folder name.</td>
</tr>
<tr>
<td>author</td>
<td>Your name or pseudonym and email address.</td>
</tr>
<tr>
<td>homepage</td>
<td>Optional homepage of the module.</td>
</tr>
<tr>
<td>version</td>
<td>Module version. Does not automatically update. Change this between releases to differentiate them.</td>
</tr>
<tr>
<td>engine</td>
<td>Expected engine version.</td>
</tr>
<tr>
<td>description</td>
<td>A description of your module. Can be multiple lines and paragraphs.</td>
</tr>
<tr>
<td>starter</td>
<td>Only change if you know what you are doing. And if you have to ask, you don't.</td>
</tr>
<tr>
<td>show_only_on_cheat</td>
<td>If true, prevents this module from appearing in the mods list normally. This is enabled by default on the example module and should be disabled in your module.</td>
</tr>
<tr>
<td>no_get_name</td>
<td>Prevents the new character name dialog from showing up for your module. Use this if you set the character name yourself in your module.</td>
</tr>
<tr>
<td>allow_userchat</td>
<td>Registers 'space' as a key to talk, joins a channel named "module", and inits the chat system. If the game implements a game.logChat(str, ...) method it'll send chat listens to there.</td>
</tr>
<tr>
<td>background_name</td>
<td>A list of filenames (without the extension) of PNG images under the data/gfx/background directory to use as startup screen backgrounds</td>
<td>logo_name</td>
<td>A list of filenames (without the extension) of PNG images under the data/gfx/background directory to use as startup screen logos</td>
</tr>
</table>

<h2 id="toc2">Launching your module using command line parameters</h2>
<p>By now you should be able to start t-engine normally and see your module in the list when you select new game. However, when changing features then quickly wanting to see its effects, this process involves a lot of unneeded clicks and wasted time. For this reason t-engine.exe supports various command line parameters.</p>

<table class="wikitable">
<tr>
<th>Parameter</th>
<th>Effect</th>
</tr>
<tr>
<td>-M<Module></td>
<td>Auto-loads the specified module (using the module's short_name).</td>
</tr>
<tr>
<td>-u<name></td>
<td>Uses the specified name for the character.</td>
</tr>
<tr>
<td>-n</td>
<td>Forces a new character, overwriting any old saves with the same name.</td>
</tr>
</table>

<p>To take advantage of this in windows, you need to right-click on t-engine.exe and select 'Create Shortcut'. On the created shortcut right-click again and select properties. In the dialog add the following to the Target field:</p>

<code>.../t-engine.exe -MMyModule -udefault -n</code>

<p>Replacing MyModule with your module name and default with whichever character name you desire. Using this shortcut now will launch your module directly, saving you some time while prototyping.</p>

Go back to [[T4 Modules Howto Guide]].

{{Module Guides}}

God

2013-12-02T01:04:54Z

BDota:

Gods were powerful beings. Nearly all were killed by the Sher'Tul in the Godhunt, but some escaped.

==List of Gods==
* Amakthel
* Gerlyk
* Quekorja
* Ralkur
* Ugg'matho
* Xadoch

Qi Daozei

2013-11-28T01:13:29Z

BDota: Created page with "An oriental themed fantasy roguelike. {{Module |name=Qi Daozei |developer=Castler |version=0.3.0 |engine=1.0.5 |page=[http://te4.org/games/qdz] |link=[http:/..."

An oriental themed fantasy roguelike.

{{Module
|name=Qi Daozei
|developer=[[User:Castler|Castler]]
|version=0.3.0
|engine=1.0.5
|page=[http://te4.org/games/qdz]
|link=[http://forums.te4.org/viewtopic.php?f=40&t=38831]
}}

Template:Module

2013-11-28T01:03:02Z

BDota:

<div style="margin: 1.4em; margin-top:0; margin-right:0; padding: 0px; float: right; border:none;">
{|class="wikitable" style="border:none; margin:0; padding:0; text-align:left"
!colspan="2" style="font-size:larger;"|{{{name}}}
|-
! style="width:125px;" | Developer
| style="width:175px;" | {{{developer}}}
|-
! Current Version
| {{{version}}}
|-
! Engine Version
| {{{engine}}}
|-
! Standalone Version
| {{{standalone|N/A}}}
|-
! Module Page
| {{{page}}}
|-
! Forum Link
| {{{link}}}
|}
</div><includeonly>[[Category:Modules]]</includeonly><noinclude>[[Category:Templates]]</noinclude>

Startide

2013-11-28T01:01:44Z

BDota:

{{Module
|name=Startide
|developer=[[User:BDota|BDota]]
|version=0.0.2
|engine=1.0.5
|standalone=[http://www.fileswap.com/dl/xoWIra1WQN/]
|page=[http://te4.org/games/startide]
|link=[http://forums.te4.org/viewtopic.php?f=40&t=38429]
}}

A sci-fi module for T-Engine 4.

Startide

2013-11-28T01:01:27Z

BDota:

{{Module
|name=Startide
|developer=[[User:BDota|BDota]]
|version=0.0.2
|engine=1.0.5
|standalone=http://www.fileswap.com/dl/xoWIra1WQN/
|page=[http://te4.org/games/startide]
|link=[http://forums.te4.org/viewtopic.php?f=40&t=38429]
}}

A sci-fi module for T-Engine 4.

Template:Module

2013-11-28T00:54:42Z

BDota:

<div style="margin: 1.4em; margin-top:0; margin-right:0; padding: 0px; float: right; border:none;">
{|class="wikitable" style="border:none; margin:0; padding:0; text-align:left"
!colspan="2" style="font-size:larger;"|{{{name}}}
|-
! style="width:125px;" | Developer
| style="width:175px;" | {{{developer}}}
|-
! Current Version
| {{{version}}}
|-
! Engine Version
| {{{engine}}}
|-
! Standalone Version
| {{{standalone}}}
|-
! Module Page
| {{{page}}}
|-
! Forum Link
| {{{link}}}
|}
</div><includeonly>[[Category:Modules]]</includeonly><noinclude>[[Category:Templates]]</noinclude>

Startide

2013-11-28T00:17:15Z

BDota:

{{Module
|name=Startide
|developer=[[User:BDota|BDota]]
|version=0.0.2
|engine=1.0.5
|page=[http://te4.org/games/startide]
|link=[http://forums.te4.org/viewtopic.php?f=40&t=38429]
}}

A sci-fi module for T-Engine 4.

Creating a standalone release

2013-11-22T19:32:52Z

BDota:

Creating a standalone release allows people to play your game without having to download ToME, download your module, put it in the right place, etc. It also allows you to customize the boot module (which handles the startup screen and main menu) so that you can come up with something thematically appropriate for your module.

How to create a standalone release and how to create your own boot module:
* Download http://te4.org/dl/dev/boot-example.zip as a base for the main menu.
* Remove the boot module from <code>game/engines/default/modules/boot*</code>
* Put your new boot module in place.
* Edit or replace <code>boot/data/gfx/background/</code> files with your own splash screen.
* Edit <code>boot/init.lua</code> to give it a correct name, change the boot screen's startup background, etc. (This <code>init.lua</code> uses the same format as the one you created in [[Getting Started]].)
* Grab ToME's archives, inside replace the boot module by yours and tome module by yours.
{{Module Guides}}

Uploading a module

2013-09-29T15:00:04Z

BDota:

Once your module is complete, you'll want to upload it to http://te4.org/games so that others can play it. To do so:

<ol>
<li>Request upload permission from http://te4.org/contact, if you haven't already done so.</li>
<li> Go to http://te4.org and click the "Create a module" link. Fill out the form there; most of the information here can come straight out of your [[Getting_Started#init.lua|init.lua]].</li>
<li>Zip your module up into a <code>.team</code> file. A <code>.team</code> file is simply a zip file, renamed to have a <code>.team</code> extension. The <code>.team</code> file's layout is slightly different than the normal [[Directory_Structure|module directory structure]]; the <code>data</code> subdirectory remains unchanged, while everything else is placed in a <code>mod</code> subdirectory. (You'll probably also want to exclude any development documentation, .gitignore files, scripts, etc.)</li>
<li>Get the MD5 checksum for your module. To do so, start ToME, load your newly zipped module, then exit. Check <code>te4_log.txt</code> for a line similar to the following:
<pre>[MODULE LOADER] module MD5 1234567890abcdef1234567890abcdef</pre>
In this example, "1234567890abcdef1234567890abcdef" is the checksum.</li>
<li>Go to http://te4.org and click the "Upload a module" link. Under "File:", select your <code>.team</code> file and click Upload. Fill out the rest of the page and click Save.</li>
<li>Go to http://te4.org/games and bask in the pleasure of seeing it listed alongside the other T-Engine4 games. Dream about it becoming the next smash hit.
</ol>

A script to automate creating the .team file and calculating the MD5 checksum is available at https://github.com/joshkel/qdz/blob/master/dev/release.py. Although it was written for another T-Engine module, it should work with any module. Just run it from the command line with the path to your module directory as a command-line parameter. (You'll need to have Python 2.7 or 3 installed.)

{{Module Guides}}

Particle Effects

2013-09-29T14:59:37Z

BDota:

Particle effects can be used to add pizzazz to your game. There are two parts to adding particles: invoking the particles from your main Lua code and actually defining them. We'll cover invoking particle effects first, since it's considerably simpler, and you'll want to be able to invoke your new effects to test them out and tune their parameters.

= Invoking Particles =

Assuming your particle effect is named "my_particle.lua" (see [[#Defining Particles|below]]), there are a few main options for invoking it. (Other alternatives also exist for more specialized circumstances.)

== On the map ==

The [http://te4.org/docs/t-engine4/1.0.0/modules/engine.Map.html#_M:particleEmitter Map.particleEmitter function] can add a particle effect to the map. For example, if a talent should display an effect centered on the user, add the following code to your talent's <code>action</code> function:

game.level.map:particleEmitter(self.x, self.y, 1, "my_particle")

Make sure that your particle effect limits how many particles it generates; otherwise, it can run forever.

== On an entity ==

A long-lasting particle effect can be added to an entity with [http://te4.org/docs/t-engine4/1.0.0/modules/engine.Entity.html#_M:addParticles Entity.addParticles] and removed with [http://te4.org/docs/t-engine4/1.0.0/modules/engine.Entity.html#_M:removeParticles Entity.removeParticles]. For example, to associate a particle effect with a status condition, add the following to the appropriate <code>newEffect</code> block in your <code>timed_effects.lua</code>:

activate = function(self, eff)
eff.particle = self:addParticles(Particles.new("my_particle", 1))
end,
deactivate = function(self, eff)
self:removeParticles(eff.particle)
end,

== As a projectile ==

See [http://te4.org/docs/t-engine4/1.0.0/modules/engine.interface.ActorProject.html ActorProject]. Specifically:

* To add a particle effect when the projectile hits, pass <code>{type="my_particle"}</code> for the <code>particles</code> to <code>project</code> or <code>projectile</code>.
* To add a particle effect for the projectile itself, add a <code>display={particle="my_particle"}</code> entry in the table that you pass for the <code>t</code> parameter. (This table will often come from a talent's <code>target</code> function.)

== Testing your particle effects ==

Note that particle effects files are loaded ''every time'' they're invoked. This makes it very easy to test your particles: make up a talent that invokes the particles, give it no resource cost and no cooldown, and invoke it as much as you want as you tweak the particle parameters.

= Defining Particles =

To define a new particle effect, create a Lua file under your module's <code>data/gfx/particles</code> directory.

The ToME source code has a huge set of existing particle effects under [http://git.net-core.org/darkgod/t-engine4/tree/master/game/modules/tome/data/gfx/particles game/modules/tome/data/gfx/particles], so you can look there to see how particular effects are implemented.

== Basic concepts ==

Particle effects are processed at 30 frames per second (regardless of the T-Engine's actual frame rate).

A particle effect is a fragment of Lua code that returns the following:

# A table of [[#parameters|parameters]] for each particle. This table can define parameters directly, or it can contain a <code>generator</code> function that returns a table of parameters each time it's invoked.
# An emitter function. This function is called every frame (i.e., 30 times a second). Its main job is to call <code>self:ps:emit(N)</code> (where N is the number of particles to generate for that frame) as appropriate.
# (Optional) A number giving the maximum number of particles that the system will handle for this particle effect. Setting this too high will slightly hurt performance.
# (Optional) A string giving an image filename (minus extension) to load and use in place of the standard dot or spherical image.
# (Optional) A boolean that can be set to cause the particle system to not be automatically deleted when no more particles exist. Use with care.

Under normal conditions, a particle system will be automatically deleted when no more particles exist. The emitter function often limits itself to only running a certain number of times to ensure that particle systems don't go on forever.

Some basic trigonometry may be helpful to convert between x, y coordinates and angles on a circle.

== Parameters ==

Particle effect code can return a table of parameters directly for use with the T-Engine's simple generator, or it can return a generator function.

=== Simple generator ===

A table for use with the simple generator might look like this:

<pre>
return {
base = 1000,

angle = { 0, 360 }, anglev = { 2000, 4000 }, anglea = { 200, 600 },

life = { 5, 10 },
size = { 3, 6 }, sizev = {0, 0}, sizea = {0, 0},

r = {0, 0}, rv = {0, 0}, ra = {0, 0},
g = {80, 200}, gv = {0, 10}, ga = {0, 0},
b = {0, 0}, bv = {0, 0}, ba = {0, 0},
a = {255, 255}, av = {0, 0}, aa = {0, 0},
}
</pre>

Note that each value is given as a pair of numbers; these give the minimum and maximum values for the RNG to randomly generate each particle. Also note that colors (r, g, b, and a) range from 0 to 255. Only integers are permitted.

The simple generator is fairly restrictive; it's only really suitable for particles moving outwards from a central point.

=== Generator function ===

The same particle effect expressed as a generator function would look like this: (UNTESTED)

<pre>
return { generator = function()
return {
trail = 0,

life = rng.range(5, 10),
size = rng.range(3, 6), sizev = 0, sizea = 0,

x = 0, xv = 0, xa = 0,
y = 0, yv = 0, ya = 0,
dir = math.rad(rng.range(0, 360)), dirv = 0, dira = 0,
vel = rng.range(2, 4), velv = rng.range(0.2, 0.6), vela = 0,

r = 0, rv = 0, ra = 0,
g = rng.range(80, 200)/255, gv = rng.range(0, 10)/255, ga = 0,
b = 0, bv = 0, ba = 0,
a = 1, av = 0, aa = 0
}
end }
</pre>

The generator function invokes the RNG itself and returns floating point numbers.

=== Parameter values ===

Several parameters have ...v and ...a values. These give velocity and acceleration for that value. Each frame, velocity is added to the base value, then acceleration is added to velocity (causing velocity to change for future frames). For example:

r = 1, rv = -0.1, ra = 0
g = 0, gv = 0, ga = 0,
b = 0, bv = 0, ba = 0

starts out solid red and fades to black over 10 frames.

As another example:

y = 0, yv = 0, ya = -0.4

creates a particle that is initially motionless but starts moving up faster and faster.

Details on values:

<table class="wikitable">
<tr>
<td colspan=2>'''''General settings'''''</td>
</tr>
<tr>
<td>life</td>
<td>Number of frames for which the particle will exist</td>
</tr>
<tr>
<td>size, sizev, sizea</td>
<td>Size of the particle</td>
</tr>
<tr>
<td colspan=2>'''''Simple generator only'''''</td>
</tr>
<tr>
<td>base</td>
<td>All velocity and acceleration values are divided by this before being processed (since the default generator can't take fractional values directly).</td>
</tr>
<tr>
<td>angle, anglev, anglea</td>
<td>Angle along which the particle should move, in degrees, and velocity and acceleration at which it should move along that angle. Generator functions can use dir and vel for a similar effect.</td>
</tr>
<tr>
<td colspan=2>'''''Generator function only'''''</td>
</tr>
<tr>
<td>trail</td>
<td>Used to draw trails from one particle to another. trail is 0-based, unlike most values in T-Engine.</td>
</tr>
<tr>
<td>x, xv, xa</td>
<td>x coordinate, relative to the center of the particle system</td>
</tr>
<tr>
<td>y, yv, ry</td>
<td>y coordinate, relative to the center of the particle system</td>
</tr>
<tr>
<td>dir, dirv, dira</td>
<td>Angle along which the particle should move, in radians. dirv and dira give the rate at which that angle should change.</td>
</tr>
<tr>
<td>vel, velv, vela</td>
<td>Velocity to move along the angle given by dir, and the "velocity of velocity" (i.e., acceleration) and the "acceleration of velocity." Movement can be done via xv, xa, yv, ya or dir, vel (or both at the same time).</td>
</tr>
<tr>
<td colspan=2>'''''Color'''''</td>
</tr>
<tr>
<td>r, rv, ra</td>
<td>Red component</td>
</tr>
<tr>
<td>g, gv, ga</td>
<td>Green component</td>
</tr>
<tr>
<td>b, bv, ba</td>
<td>Blue component</td>
</tr>
<tr>
<td>a, av, aa</td>
<td>Alpha component. 255 (for the simple generator) or 1 (for a generator function) means fully opaque, 0 means fully transparent.</td>
</tr>

{{Module Guides}}

T4 Modules Howto Guide/Developing a static map using the Tiled plugin

2013-09-29T14:59:25Z

BDota:

<h1 id="toc0">Developing a static map using the Tiled plugin</h1>
<p>A T-Engine map is composed of square grids and each of these grids has several content slots where the actual T-Engine entities are stored. You will be dealing with the TERRAIN, TRAP, OBJECT and ACTOR slots. Most maps in ToME are generated according to an algorithm (called a generator) which leads to a different map each time. T-Engine also supports static maps that you can prepare beforehand and to help designing this type of map a T-Engine plugin has been developed for the [http://www.mapeditor.org Tiled map editor]. The T-Engine plugin will convert Tiled maps into the Lua format that T-Engine expects, or alternatively you can directly create the Lua maps. The Lua maps are constructed by first assigning an ASCII character <tt>char</tt> values for each of the content slots:<br />

<pre>defineTile = function(char, grid, obj, actor, trap, status, spot)</pre>

<br />
Then you return an ASCII map that will be interpreted by the map generator according to the tiles defined with the defineTile function. Understanding this will help you determine if the Tiled map is being exported properly to the Lua file.</p>

<h3 id="toc1">ToME Vault Tutorial</h3>
<p>One use for static maps in ToME is to define the various vaults that can be encountered, and we will use this as a tutorial for learning how to use Tiled. You can grab the prepared files (<strong>coming soon</strong>). You can skip down to <strong>Create a Terrain layer and paint</strong> section if you are just developing vaults, but if you are developing a map for your own module you will need to look at these two sections.</p>

<h4 id="toc2">Create a tilemap image</h4>
<p>The first thing you need to get started is a tilemap. The tilemap is a single image that is a collection of the individual images for each terrain that you want to add to the map. Since T-Engine uses individual 32x32 pixel images you will need to create this, and the fastest way is to use the ImageMagick montage command. First copy all of the individual images you want to use into a single directory and the run this command:<br />

<pre>montage -border 0 -geometry 32x32 *png tilemap.png</pre>

</p>

<h4 id="toc3">Create a Tiled terrain tileset</h4>
<p>Launch the Tiled program and go to <tt>Map -> New Tileset</tt>. Name it whatever you want and select the tilemap image you just created. Make sure the tile width/height (32) and margin/spacing (0) are set up correctly. The tileset should now appear in the bottom right of the Tiled window. Now we need to assign an ASCII character and value to each tile. You need to right-click on each tile and select <tt>Tile Properties</tt>. Click on <tt><new property></tt> and enter <tt>display</tt>. Then click in the value space next to your new display property and enter any ASCII character you would like to be associated with this tile, eg. <tt>T</tt> for tree. Now add another property called <tt>value</tt> and a corresponding value, eg. <tt>"TREE"</tt>. Note the inclusion of quotation marks since these properties will be exported directly to the Lua code and you want the Lua code to recognize this value as a string. Keep doing this until you have a complete terrain tileset. You can then right-click on the tileset and export it so you can re-use it in other maps.</p>

<h4 id="toc4">Create a new Tiled map (and load the Tileset)</h4>
<p>You can either create a new 10x10 map of 32x32 tiles. Now go to <tt>Map -> Add External Tileset</tt> and select <tt>vault.tsx</tt> In this tutorial we are going to be making a bandit-themed vault, and the final results can be seen in <tt>vault-tutorial.tmx</tt>.</p>

<h4 id="toc5">Create a Terrain layer and paint</h4>
<p>Tiled maps start with a default Tile Layer called <tt>Tile Layer 1</tt>. We will use this layer to "paint" the terrain content slot for the T-Engine map. In order for the T-Engine plugin to recognize we want to use this layer for the terrain content slot we need to have the layer name start with <tt>Terrain</tt> (case-insensitive). You can rename the layer by double-clicking on the current name. Now you can select a tile from the tileset and start painting on the map. Test what you have done so far by exporting the map with the T-Engine plugin (<tt>File -> Export as</tt> and select <tt>T-Engine4 map files</tt> in the format pull down). Open up the created Lua file and see if it makes sense. The tiles marked with a "V" are vault walls, so surround the exterior of the map with those.</p>

<h4 id="toc6">Create an Actor object layer</h4>
<p>Tiled has two different types of layers: Tiles and Objects. In the previous section we saw the Tile Layer, where we painted the terrain using the various tiles from our tileset. We could theoretically do the same thing for Actors, but creating a tileset for all of the actors (monsters) in ToME doesn't strike me as a lot of fun and thus we will use Object Layers for this work. Right-click in the layers window and select <tt>Add Object Layer</tt>. In order to link this layer to the <tt>Actor</tt> content slot we (you guessed it) rename the new layer to start with <tt>Actor</tt>. Instead of selecting a tile and painting it onto the map we now create free-sized rectangles on the map. Practice drawing, resizing and deleting the objects. Now we need to set the <tt>display</tt> and <tt>value</tt> properties of each object we put down, so place an object and open the property editor. Let us make this one our bandit lord. Put <tt>l</tt> in for <tt>display</tt> and <tt>{random_filter={name="bandit lord", add_levels=15}}</tt> in for <tt>value</tt>. Note that the value does not have quotation marks this time, and is actually a Lua table! When this table gets passed to the static map generator the generator will try to create a random actor that matches the name provided and then add an additional 15 levels (vaults are supposed to be difficult). The full syntax of what can be passed in this table is outside the scope of this article. Now each tile that the bandit lord object overlaps will attempt to place a matching actor there, so make sure your bandit lord object is fully contained within a single tile. You can add another object that tries to place assassins and make it larger than one tile, though.</p>

<h4 id="toc7">Use Layer Properties as defaults</h4>
<p>For a small vault creating and editing the properties for each individual actor is ok, but this can get really tedious when adding a lot of similar actors to the map. Well layers can have properties just like objects and tiles, and the T-Engine plugin will look at the layer's properties if it does not find <tt>display</tt> or <tt>value</tt> in the tile/object. To see this in action let us create a new Object Layer and call it <tt>Actor - Generic Bandit</tt>. Now right-click on the object layer and select <tt>Layer Properties</tt>. Add a <tt>display</tt> and <tt>value</tt> layer property and add some object to the new layer. Export the map and check that the actor content from your new layer is handled correctly.</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Frame Buffers

2013-09-29T14:59:14Z

BDota:

<div class="content"><p>[Quoting Darkgod from the forums]</p>

<p>Hum shaders ... You need to understand one thing about how this all works.<br />
To use a fullscreen or fullmap shader the game makes a FBO (framebuffer object, like a virtual screen that outputs to a texture), displays the map inside it and then displays the FBO's texture through the shader. The shader is applied to each and every pixel drawn from the texture.</p>

<p>So first you setup your FBOs, for that just copy ToME's Game:createFBOs() method and call it as tome does (in setupDisplayMode).<br />
Now your fbos are created and your shaders are loaded. You need to use them now. Not all displays can do shaders or FBO though, so you need two versions of your map display code:<br />
Where your module probably just does (if you copied example module):</p>

<p><br />
<pre> self.level.map:display(nil, nil, nb_keyframe)
self.target:display()</pre><br />
</p>

<p>You instead do:</p>

<p><br />
<pre> -- Display using Framebuffer, so that we can use shaders and all
local map = game.level.map
if self.fbo then
self.fbo:use(true)
map:display(0, 0, nb_keyframe)
self.fbo:use(false, self.full_fbo)
self.fbo:toScreen(map.display_x, map.display_y, map.viewport.width, map.viewport.height, self.fbo_shader.shad)

if self.target then self.target:display() end

-- Basic display; no FBOs
else
map:display(nil, nil, nb_keyframe)
if self.target then self.target:display() end
end</pre><br />
</p>

<p>This will make the map display in its own texture and then use the fbo shader on it.<br />
ToME uses two fbos, one for the map and one for the whole screen.<br />
The fullscreen one must thus also be used:<br />
At the top of Game:display() right after the "if self.change_res_dialog" you add a line:</p>

<p><br />
<pre> if self.full_fbo then self.full_fbo:use(true) end</pre><br />
</p>

<p>And then at the very bottom of Game:display() you do:</p>

<p><br />
<pre> if self.full_fbo then
self.full_fbo:use(false)
self.full_fbo:toScreen(0, 0, self.w, self.h, self.full_fbo_shader.shad)
end</pre><br />
</p>

<p>This will display all the game inside a fbo and then display it with the given shader.</p>

<p>Now shaders themselves. They live in data/gfx/shaders/ There must usualy be two file per shaders, a .lua file that describes it and a .frag one that is the shader code to run on the GPU. Try to see how main_fbo and full_fbo shaders in ToME work. They probably are enough for your needs but you can play with them as you need (or ask more specific questions).</p>

<p>Now if you did it all right your game should display .. just as before!<br />
So we need to tell the shaders to do stuff. First tell the full_fbo shader to handle gamme correction instead of the OS (it usualy looks better):<br />
define</p>

<p><br />
support_shader_gamma = true<br />
</p>

<p>in Game.lua, before the init method (like ToME does).<br />
If at that point you get a fully dark screen, try to add</p>

<p><br />
self:setGamma(config.settings.gamma_correction / 100)<br />
</p>

<p>right at the end of createFBOs.</p>

<p>Now the fun part!<br />
Say you want to colorize your game in red, you simply do:</p>

<p><br />
game.fbo_shader:setUniform("colorize", {1,0.2,0,1})<br />
</p>

<p>Somewhere in your code. To restore default you do:</p>

<p><br />
game.fbo_shader:setUniform("colorize", {0,0,0,0})<br />
</p>

<p>ToME's relevant code for that is in Player:updateMainShader()</p>

<p>Go play with those</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

Colors

2013-09-29T14:59:03Z

BDota:

T-Engine provides a number of predefined colors. There are two ways to refer to these:

* In your Lua code. For example: <code>code.DARK_GREEN</code>
* Embedded within strings (using # signs to mark them). For example: <code>"Hello, #BLUE#world#LAST#!"</code>

The following colors are defined by T-Engine 1.0.4:

<table class="wikitable">
<tr><th>Name</th><th>Red</th><th>Green</th><th>Blue</th><th>Demo</th></tr>
<tr><td>BLACK</td><td>0</td><td>0</td><td>0</td><td><span style="background: #000000; border: solid 1px black">    </span></td></tr>
<tr><td>WHITE</td><td>255</td><td>255</td><td>255</td><td><span style="background: #ffffff; border: solid 1px black">    </span></td></tr>
<tr><td>SLATE</td><td>140</td><td>140</td><td>140</td><td><span style="background: #8c8c8c; border: solid 1px black">    </span></td></tr>
<tr><td>ORANGE</td><td>255</td><td>119</td><td>0</td><td><span style="background: #ff7700; border: solid 1px black">    </span></td></tr>
<tr><td>RED</td><td>201</td><td>0</td><td>0</td><td><span style="background: #c90000; border: solid 1px black">    </span></td></tr>
<tr><td>GREEN</td><td>0</td><td>134</td><td>69</td><td><span style="background: #008645; border: solid 1px black">    </span></td></tr>
<tr><td>BLUE</td><td>0</td><td>0</td><td>227</td><td><span style="background: #0000e3; border: solid 1px black">    </span></td></tr>
<tr><td>UMBER</td><td>142</td><td>69</td><td>0</td><td><span style="background: #8e4500; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_DARK</td><td>80</td><td>80</td><td>80</td><td><span style="background: #505050; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_SLATE</td><td>209</td><td>209</td><td>209</td><td><span style="background: #d1d1d1; border: solid 1px black">    </span></td></tr>
<tr><td>VIOLET</td><td>192</td><td>0</td><td>175</td><td><span style="background: #c000af; border: solid 1px black">    </span></td></tr>
<tr><td>YELLOW</td><td>255</td><td>255</td><td>0</td><td><span style="background: #ffff00; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_RED</td><td>255</td><td>0</td><td>104</td><td><span style="background: #ff0068; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_GREEN</td><td>0</td><td>255</td><td>0</td><td><span style="background: #00ff00; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_BLUE</td><td>81</td><td>221</td><td>255</td><td><span style="background: #51ddff; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_UMBER</td><td>215</td><td>142</td><td>69</td><td><span style="background: #d78e45; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_UMBER</td><td>87</td><td>94</td><td>37</td><td><span style="background: #575e25; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_GREY</td><td>67</td><td>67</td><td>67</td><td><span style="background: #434343; border: solid 1px black">    </span></td></tr>
<tr><td>GREY</td><td>127</td><td>127</td><td>127</td><td><span style="background: #7f7f7f; border: solid 1px black">    </span></td></tr>
<tr><td>ROYAL_BLUE</td><td>65</td><td>105</td><td>225</td><td><span style="background: #4169e1; border: solid 1px black">    </span></td></tr>
<tr><td>AQUAMARINE</td><td>127</td><td>255</td><td>212</td><td><span style="background: #7fffd4; border: solid 1px black">    </span></td></tr>
<tr><td>CADET_BLUE</td><td>95</td><td>158</td><td>160</td><td><span style="background: #5f9ea0; border: solid 1px black">    </span></td></tr>
<tr><td>STEEL_BLUE</td><td>70</td><td>130</td><td>180</td><td><span style="background: #4682b4; border: solid 1px black">    </span></td></tr>
<tr><td>TEAL</td><td>0</td><td>128</td><td>128</td><td><span style="background: #008080; border: solid 1px black">    </span></td></tr>
<tr><td>LIGHT_STEEL_BLUE</td><td>176</td><td>196</td><td>222</td><td><span style="background: #b0c4de; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_BLUE</td><td>0</td><td>0</td><td>147</td><td><span style="background: #000093; border: solid 1px black">    </span></td></tr>
<tr><td>ROYAL_BLUE</td><td>0</td><td>108</td><td>255</td><td><span style="background: #006cff; border: solid 1px black">    </span></td></tr>
<tr><td>PINK</td><td>255</td><td>192</td><td>203</td><td><span style="background: #ffc0cb; border: solid 1px black">    </span></td></tr>
<tr><td>GOLD</td><td>255</td><td>215</td><td>0</td><td><span style="background: #ffd700; border: solid 1px black">    </span></td></tr>
<tr><td>FIREBRICK</td><td>178</td><td>34</td><td>34</td><td><span style="background: #b22222; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_RED</td><td>100</td><td>0</td><td>0</td><td><span style="background: #640000; border: solid 1px black">    </span></td></tr>
<tr><td>VERY_DARK_RED</td><td>50</td><td>0</td><td>0</td><td><span style="background: #320000; border: solid 1px black">    </span></td></tr>
<tr><td>CRIMSON</td><td>220</td><td>20</td><td>60</td><td><span style="background: #dc143c; border: solid 1px black">    </span></td></tr>
<tr><td>MOCCASIN</td><td>255</td><td>228</td><td>181</td><td><span style="background: #ffe4b5; border: solid 1px black">    </span></td></tr>
<tr><td>KHAKI</td><td>240</td><td>230</td><td>130</td><td><span style="background: #f0e682; border: solid 1px black">    </span></td></tr>
<tr><td>SANDY_BROWN</td><td>244</td><td>164</td><td>96</td><td><span style="background: #f4a460; border: solid 1px black">    </span></td></tr>
<tr><td>SALMON</td><td>250</td><td>128</td><td>114</td><td><span style="background: #fa8072; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_ORCHID</td><td>153</td><td>50</td><td>204</td><td><span style="background: #9932cc; border: solid 1px black">    </span></td></tr>
<tr><td>ORCHID</td><td>218</td><td>112</td><td>214</td><td><span style="background: #da70d6; border: solid 1px black">    </span></td></tr>
<tr><td>PURPLE</td><td>128</td><td>0</td><td>139</td><td><span style="background: #80008b; border: solid 1px black">    </span></td></tr>
<tr><td>CHOCOLATE</td><td>210</td><td>105</td><td>30</td><td><span style="background: #d2691e; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_KHAKI</td><td>189</td><td>183</td><td>107</td><td><span style="background: #bdb76b; border: solid 1px black">    </span></td></tr>
<tr><td>TAN</td><td>210</td><td>180</td><td>140</td><td><span style="background: #d2b48c; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_TAN</td><td>110</td><td>80</td><td>40</td><td><span style="background: #6e5028; border: solid 1px black">    </span></td></tr>
<tr><td>HONEYDEW</td><td>240</td><td>255</td><td>240</td><td><span style="background: #f0fff0; border: solid 1px black">    </span></td></tr>
<tr><td>ANTIQUE_WHITE</td><td>250</td><td>235</td><td>215</td><td><span style="background: #faebd7; border: solid 1px black">    </span></td></tr>
<tr><td>OLD_LACE</td><td>253</td><td>245</td><td>230</td><td><span style="background: #fdf5e6; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_SLATE_GRAY</td><td>47</td><td>79</td><td>79</td><td><span style="background: #2f4f4f; border: solid 1px black">    </span></td></tr>
<tr><td>OLIVE_DRAB</td><td>107</td><td>142</td><td>35</td><td><span style="background: #6b8e23; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_SEA_GREEN</td><td>143</td><td>188</td><td>143</td><td><span style="background: #8fbc8f; border: solid 1px black">    </span></td></tr>
<tr><td>YELLOW_GREEN</td><td>154</td><td>205</td><td>50</td><td><span style="background: #9acd32; border: solid 1px black">    </span></td></tr>
<tr><td>DARK_GREEN</td><td>50</td><td>77</td><td>12</td><td><span style="background: #324d0c; border: solid 1px black">    </span></td></tr>
</table>

{{Module Guides}}

T4 Modules Howto Guide/Chats

2013-09-29T14:58:51Z

BDota:

<h1 id="toc0">Chats: Beyond Hack and Slash </h1>
<p>"But this is a roguelike," you say, "I <em>like</em> the hacking and slashing." Well fine... how about a chat <em>before</em> the fight, then? And what better an example than the Black Knight from the Monty Python and the Holy Grail?</p>

<p>The first thing to do is to let the game know that an NPC can talk. In the code below we set the "can_talk" variable of the entity and we also set the black knight's faction (See [[Factions]]) to be the same as the players.</p>

<pre>newEntity{
name = "The Black Knight", define_as = "BLACK_KNIGHT",
display = "k", color=colors.BLACK,
desc = [[a knight dressed in black armor stands before you.]],
level_range = {1, 4}, exp_worth = 1,
can_talk = "black_knight",
faction = "players",
}</pre>

<p>The game can now check for the can_talk variable when you bump into a NPC (or maybe target an NPC with a talk command, however you decide to code it). If you are using the Combat interface from the example module I suggest you edit the bumpInto function like so</p>

<pre>function _M:bumpInto(target)
local reaction = self:reactionToward(target)
if reaction < 0 then
return self:attackTarget(target)
elseif reaction >= 0 then
-- Talk ?
if self.player and target.can_talk then
local chat = Chat.new(target.can_talk, target, self)
chat:invoke()
elseif target.player and self.can_talk then
local chat = Chat.new(self.can_talk, self, target)
chat:invoke()
-- Displace
elseif self.move_others then
game.level.map:remove(self.x, self.y, Map.ACTOR)
game.level.map:remove(target.x, target.y, Map.ACTOR)
game.level.map(self.x, self.y, Map.ACTOR, target)
game.level.map(target.x, target.y, Map.ACTOR, self)
self.x, self.y, target.x, target.y = target.x, target.y, self.x, self.y
end
end
end</pre>

<p>Remember how we set the black knight's faction to "players"? Well that ensures us a favorable reaction between the two, taking us into the "elseif reaction >= 0" loops. The creation of a new chat takes three variables, a string with the name of the chat, the npc and the player. In our example we will be passing "black_knight", the black knight entity and finally the player entity. Now we need to actually create the chat so T-Engine has something to find when trying to create the Chat object.</p>

<p>The default location for chats is in the data/chats folders of your module. Create data/chats/black_knight.lua and open it. Each round of dialog will be created using the newChat function. We need to supply an id tag for each dialog round, the text that the NPC will say, and the possible responses we can select from. The answers table is where most of the magic happens, but we will start with a simple example.</p>

<pre>newChat{ id="first",
text = [[#light_green#* The black knight stares at you in silence.]],
answers = {
{[["You fight with the strength of many men, sir knight. I am Arthur, King of the Britons."]], jump="second"},
{[[Walk away.]]},
},
}</pre>

<p>Each entry in the answers table is itself a table which I will refer to as a response rather than the singular answer. The first entry in the response is a string and this is what will be displayed in the chat window. Other parameters can be supplied in the response such as the "jump" parameter above. The jump parameter tells the Chat the id of the round of dialog to be loaded when that option is selected. The second response does not have a jump parameter, so selecting that option will quit the Chat. Now we have to define the next few rounds of dialog!</p>

<pre>newChat{ id="second",
text = [[#light_green#* The black knight continues to stare at you in silence.]],
answers = {
{[["I seek the finest and the bravest knights in the land to join me in my court of Camelot."]], jump="third"},
{[[Walk away.]]},
},
}
newChat{ id="third",
text = [[#light_green#* The black knight is silent once again.]],
answers = {
{[["You have proved yourself worthy; will you join me?"]], jump="fourth"},
{[[Walk away.]]},
},
}
newChat{ id="fourth",
text = [[#light_green#* Silence... well what did you expect?]],
answers = {
{[["You make me sad. So be it. Come, Patsy."]], jump="fifth"},
{[[Walk away.]]},
},
}
newChat{ id="fifth",
text = [["None shall pass."]],
answers = {
{[["What?"]], jump="fifth"},
{[["I have no quarrel with you, good sir knight, but I must cross this bridge."]], jump="sixth"},
{[[Walk away.]]},
},
}</pre>

<p>In that last ("fifth") round of dialog we see something interesting, a recursive dialog. Nothing wrong there, and it actually saves us from coding an extra round of dialog. We are getting near the hack-and-slash bits!</p>

<pre>newChat{ id="sixth",
text = [["Then you shall die."]],
answers = {
{[["What?"]], jump="fifth"},
{[["I command you as King of the Britons to stand aside!"]], jump="seventh"},
{[[Walk away.]]},
},
}
newChat{ id="seventh",
text = [["I move for no man."]],
answers = {
{[["What?"]], jump="seventh"},
{[["So be it!"]], action=function(npc, player)
npc.faction = "enemies"
},
{[[Walk away.]]},
},
}</pre>

<p>The interesting response is the one below. The "action" parameter should be a function that accepts the npc as a first argument and the player as the second. What you do then is up to you, but in our case we want the game to recognize that the player and black knight are now enemies. A simple way to do that is to change the black knight's faction from "players" to "enemies." The response does not have a jump entry, so the Chat will end but since we are now enemies with the knight we can attack him to our heart's content.<br />

<pre> {[["So be it!"]], action=function(npc, player)
npc.faction = "enemies"
},</pre>

</p>

<p>Wait, there is one more thing! We need to return the id of the initial round of dialog, in our case "first." This should be done at the end of the chat lua file.<br />

<pre>return "first"</pre>

</p>

<p>There, you are all done. There are some more advanced chat features like conditional responses and for now you can dig into the ToME code if you want to discover those.</p>

<h2 id="toc1">Randomizing chats</h2>
<p>If you want to randomize chats just use tables as in the following example:<br />

<pre>greeting = {"Hi", "Hello", "Good day", "Bonjour", "Greetings"}
hope = {"hope", "trust", "see", "perceive"}

newChat{ id="hello",
text = rng.table(greeting) .. " @playername@! I " .. rng.table(hope) .. " your quest goes well.",
answers = {
{rng.table(greeting) .. "!"},
},
}</pre>

</p>

<p>Notice the use of rng.table(foo) to pick a random string and the use of ".." to combine the strings.</p>

<h2 id="toc2">Conditional Answers and Jumps</h2>
<p>An answer in the newChat answers table can have a cond variable with the following signature:<br />

<pre>cond = function(npc, player)
...
end</pre>

<br />
If the function returns true then the answer will appear in the chat, but if it returns false it will not. You can use this to only allow certain options in dialogs after a sub-quest has been completed, or a certain item is in the player's inventory.</p>

<p>You can also have a single answer send the player to various places using the action function. In the action function above we did not bother with a return value, but if there is a return value that will be used as the next chat instead of the jump variable. For example, say you want a NPC to offer the player a side quest only 20% of the times they talk. You could do:<br />

<pre>action = function(npc, player)
if rng.percent(20) then
return "offer quest"
else
return "regular response"
end
end</pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Factions

2013-09-29T14:58:42Z

BDota:

<h1 id="toc0">Factions: Taking Sides!</h1>
<p>Factions seem reasonably simple.</p>

<p>In your load.lua file include the following line near the top:</p>

<pre>local Faction = require "engine.Faction"</pre>

<p>Two default factions are already included, so there is no need to create them:</p>

<pre>-- Add a few default factions
_M:add{ name="Players", reaction={enemies=-100} }
_M:add{ name="Enemies", reaction={players=-100} }</pre>

<p>engine/Actor.lua includes this line in all actor's init that sets the default faction to enemies:</p>

<pre>self.faction = t.faction or "enemies"</pre>

<p>At the time of writing ToME's load.lua also includes two additional custom factions:</p>

<pre>-- Factions
Faction:add{ name="water lair", reaction={} }
Faction:add{ name="assassin lair", reaction={} }</pre>

<p>Without initializing the reaction list, their reaction will be 0 to everyone, aka neutral. This is so they start out neutral, and their reaction to the different sides can change depending on in-game actions. In-game the reactions are modified using the following code:</p>

<pre>Faction:setFactionReaction("assassin-lair", "players", -100, true)</pre>

<p>Now the assassin lair and players factions hate each other (notice the true, which means the feeling is mutual). The setFactionReaction function uses the faction short names, which are either set explicity in the Faction:add function or are the lowercase version of the faction name with all spaces replaces with "-"s. The above code will only work when in-game, though, and that means not in load.lua. To modify reactions in load.lua you can use the Faction:setInitialReaction function with the exact same parameters as Faction:setFactionReaction.</p>

<p>To make use of custom factions, the actor's faction variable need to be set to the desired faction. For naturally faction creatures this can be set in the NPC definition. For summoned creatures this is set in the talent's code when summoning and creating the creature(setting it to faction "players"). Custom Actor generators may also make use of this.</p>

<p>In order to test for reaction, whether an Actor should be hostile to another, you can use the reactionToward() method.</p>

<pre>self:reactionToward(target)</pre>

<p>For traps, you can set it so they only trigger against Actors hostile to themselves. For instance, this is a modification of the ToME base elemental trap:</p>

<pre>newEntity{ define_as = "TRAP_ELEMENTAL",
type = "elemental", id_by_type=true, unided_name = "trap",
display = '^',
triggered = function(self, x, y, who)
if who:reactionToward(self) < 0 then
self:project({type="hit",x=x,y=y}, x, y, self.damtype, self.dam, self.particles and {type=self.particles})
return true
else
return false
end
end,
}</pre>

<p>If you have multiple factions that players can belong to, make sure to set the faction on the player as late as possible in the descriptor tree [That is, if you had "race", "subrace", and "class" in that order, you'd want to set it at "class"]. You will also want to put the statement in a copy block, as earlier copy blocks (like that used by the default faction) will over-ride later options that aren't.<br />

<pre>copy = {
faction = "yourfactionhere"
}</pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Character Sheet Dialogs

2013-09-29T14:58:32Z

BDota:

<h1 id="toc0">Character Sheet</h1>

<h2 id="toc1">Player Display</h2>
<p>A Player Display is the sidebar usually on the left that gives you a quick summary of your stats and status.</p>

<p>In order to create your own Player Display, create and copy the following code into your module's /class/PlayerDisplay.lua file.</p>

<pre> require "engine.class"

module(..., package.seeall, class.make)

function _M:init(x, y, w, h, bgcolor, font, size)
self.display_x = x
self.display_y = y
self.w, self.h = w, h
self.bgcolor = bgcolor
self.font = core.display.newFont(font, size)
self:resize(x, y, w, h)
end

--- Resize the display area
function _M:resize(x, y, w, h)
self.display_x, self.display_y = x, y
self.w, self.h = w, h
self.font_h = self.font:lineSkip()
self.font_w = self.font:size(" ")
self.bars_x = self.font_w * 9
self.bars_w = self.w - self.bars_x - 5
self.surface = core.display.newSurface(w, h)
self.surface_line = core.display.newSurface(w, self.font_h)
self.texture = self.surface:glTexture()

self.items = {}
end

function _M:makeTexture(text, x, y, r, g, b, max_w)
local s = self.surface_line
s:erase(0, 0, 0, 0)
s:drawColorStringBlended(self.font, text, 0, 0, r, g, b, true, max_w)

local item = { s:glTexture() }
item.x = x
item.y = y
item.w = self.w
item.h = self.font_h
self.items[#self.items+1] = item

return item.w, item.h, item.x, item.y
end

function _M:makeTextureBar(text, nfmt, val, max, reg, x, y, r, g, b, bar_col, bar_bgcol)
local s = self.surface_line
s:erase(0, 0, 0, 0)
s:erase(bar_bgcol.r, bar_bgcol.g, bar_bgcol.b, 255, self.bars_x, h, self.bars_w, self.font_h)
s:erase(bar_col.r, bar_col.g, bar_col.b, 255, self.bars_x, h, self.bars_w * val / max, self.font_h)

s:drawColorStringBlended(self.font, text, 0, 0, r, g, b, true)
s:drawColorStringBlended(self.font, (nfmt or "%d/%d"):format(val, max), self.bars_x + 5, 0, r, g, b)
if reg and reg ~= 0 then
local reg_txt = (" (%s%.2f)"):format((reg > 0 and "+") or "",reg)
local reg_txt_w = self.font:size(reg_txt)
s:drawColorStringBlended(self.font, reg_txt, self.bars_x + self.bars_w - reg_txt_w - 3, 0, r, g, b)
end
local item = { s:glTexture() }
item.x = x
item.y = y
item.w = self.w
item.h = self.font_h
self.items[#self.items+1] = item

return item.w, item.h, item.x, item.y
end

-- Displays the stats
function _M:display()
local player = game.player
if not player or not player.changed or not game.level then return end

self.items = {}

local h = 6
local x = 2

self.font:setStyle("bold")
self:makeTexture(("%s#{normal}#"):format(player.name), 0, h, colors.GOLD.r, colors.GOLD.g, colors.GOLD.b, self.w) h = h + self.font_h
self.font:setStyle("normal")

self:makeTexture(("Str/Dex/Con: #00ff00#%3d/%3d/%3d"):format(player:getStr(), player:getDex(), player:getCon()), x, h, 255, 255, 255) h = h + self.font_h

h = h + self.font_h

self:makeTextureBar("#c00000#Life:", nil, player.life, player.max_life, player.life_regen * util.bound((player.healing_factor or 1), 0, 2.5), x, h, 255, 255, 255, colors.DARK_RED, colors.VERY_DARK_RED) h = h + self.font_h

self:makeTextureBar("#ffcc80#Power:", nil, player:getPower(), player.max_power, player.power_regen, x, h, 255, 255, 255, colors.DARK_BLUE, {r=colors.DARK_BLUE.r/2, g=colors.DARK_BLUE.g/2, b=colors.DARK_BLUE.b/2}) h = h + self.font_h

if savefile_pipe.saving then
h = h + self.font_h
self:makeTextureBar("Saving:", "%d%%", 100 * savefile_pipe.current_nb / savefile_pipe.total_nb, 100, nil, x, h, colors.YELLOW.r, colors.YELLOW.g, colors.YELLOW.b,
{r=49, g=54,b=42},{r=17, g=19, b=0})

h = h + self.font_h
end

end

function _M:toScreen(nb_keyframes)
self:display()

core.display.drawQuad(self.display_x, self.display_y, self.w, self.h, 100,100,100, 200)

for i = 1, #self.items do
local item = self.items[i]
if type(item) == "table" then
if item.glow then
local glow = (1+math.sin(core.game.getTime() / 500)) / 2 * 100 + 120
item[1]:toScreenFull(self.display_x + item.x, self.display_y + item.y, item.w, item.h, item[2], item[3], 1, 1, 1, glow / 255)
else
item[1]:toScreenFull(self.display_x + item.x, self.display_y + item.y, item.w, item.h, item[2], item[3])
end
else
item(self.display_x, self.display_y)
end
end

end </pre>

<p>The class is now defined, but your game still has to be told to display it. Add the following near to the top of your Game.lua file:</p>

<pre> local PlayerDisplay = require "mod.class.PlayerDisplay" </pre>

<p>Then in the run function add</p>

<pre> self.player_display = PlayerDisplay.new(0, 0, 200, self.h, {30,30,0}, "/data/font/VeraMono.ttf", 12) </pre>

<p>Also modify the LogFlasher's x position so it does not render underneath the PlayerDisplay. Change it as following:</p>

<pre> self.flash = LogFlasher.new(208, 0, self.w, 20, nil, nil, nil, {255,255,255}, {0,0,0}) </pre>

<p>And finally find the display method and insert the following line:</p>

<pre> self.player_display:toScreen(nb_keyframe) </pre>

<p>And you are done, you should now have a working PlayerDisplay that you can modify to suit your needs.</p>

<h2 id="toc2">Character Sheet</h2>
<p>In the example module, you may notice that pressing 'C' causes an exception to occur due to a missing /dialogs/CharacterSheet.lua</p>

<p>Following is two example CharacterSheet Dialogs you can use in your own module. Simply paste one of these into your /dialogs/CharacterSheet.lua, start the game and press 'C' to see how it looks.</p>

<h3 id="toc3">Simple example</h3>
<p>This example is a very basic bare-bones Character sheet that can be customized any way necessarily. Simply update the drawDialog method with the information you wish to display of your own module.</p>

<pre> require "engine.class"

local Dialog = require "engine.ui.Dialog"
local Talents = require "engine.interface.ActorTalents"
local SurfaceZone = require "engine.ui.SurfaceZone"
local Stats = require "engine.interface.ActorStats"
local Textzone = require "engine.ui.Textzone"

module(..., package.seeall, class.inherit(Dialog))

function _M:init(actor)
self.actor = actor

self.font = core.display.newFont("/data/font/VeraMono.ttf", 12)
Dialog.init(self, "Character Sheet: "..self.actor.name, math.max(game.w * 0.7, 950), 500, nil, nil, font)

self.c_desc = SurfaceZone.new{width=self.iw, height=self.ih,alpha=0}

self:loadUI{
{left=0, top=0, ui=self.c_desc},
}

self:setupUI()

self:drawDialog()

self.key:addBind("EXIT", function() cs_player_dup = game.player:clone() game:unregisterDialog(self) end)
end

function _M:drawDialog()
local player = self.actor
local s = self.c_desc.s

s:erase(0,0,0,0)

local h = 0
local w = 0

h = 0
w = 0
s:drawStringBlended(self.font, "Name : "..(player.name or "Unnamed"), w, h, 255, 255, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "Role : "..(player.descriptor.role or player.type:capitalize()), w, h, 255, 255, 255, true) h = h + self.font_h

h = h + self.font_h -- Adds an empty row

h = 0
w = self.w * 0.25
-- start on second column

s:drawStringBlended(self.font, "STR : "..(player:getStr()), w, h, 0, 255, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "DEX : "..(player:getDex()), w, h, 255, 0, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "CON : "..(player:getCon()), w, h, 255, 255, 0, true) h = h + self.font_h

self.c_desc:generate()
self.changed = false
end </pre>

<h3 id="toc4">Complex example</h3>
<p>This example is a cut down version of the character sheet used in ToME. It includes tabs, tooltips and the ability to dump your character to a text file. Simply update the drawDialog method with the information you wish to display of your own module.</p>

<p>To see how the ToME character sheet performs some of its more advanced functions, refer to its source code.</p>

<pre> require "engine.class"

local Dialog = require "engine.ui.Dialog"
local Talents = require "engine.interface.ActorTalents"
local Tab = require "engine.ui.Tab"
local SurfaceZone = require "engine.ui.SurfaceZone"
local Separator = require "engine.ui.Separator"
local Stats = require "engine.interface.ActorStats"
local Textzone = require "engine.ui.Textzone"

module(..., package.seeall, class.inherit(Dialog))

function _M:init(actor)
self.actor = actor
Dialog.init(self, "Character Sheet: "..self.actor.name, math.max(game.w * 0.7, 950), 500)

self.font = core.display.newFont("/data/font/VeraMono.ttf", 12)
self.font_h = self.font:lineSkip()

self.c_general = Tab.new{title="General", default=true, fct=function() end, on_change=function(s) if s then self:switchTo("general") end end}
self.c_attack = Tab.new{title="Attack", default=false, fct=function() end, on_change=function(s) if s then self:switchTo("attack") end end}
self.c_defence = Tab.new{title="Defense", default=false, fct=function() end, on_change=function(s) if s then self:switchTo("defence") end end}

local tw, th = self.font_bold:size(self.title)

self.vs = Separator.new{dir="vertical", size=self.iw}

self.c_tut = Textzone.new{width=self.iw * 0.6, auto_height=true, no_color_bleed=true, font = self.font, text=[[
Keyboard: #00FF00#'d'#LAST# to save character dump. #00FF00#TAB key#LAST# to switch between tabs.
Mouse: Hover over stat for info
]]}

self.c_desc = SurfaceZone.new{width=self.iw, height=self.ih - self.c_general.h - self.vs.h - self.c_tut.h,alpha=0}

self.hoffset = 17 + self.c_tut.h + self.vs.h + self.c_general.h

self:loadUI{
{left=0, top=0, ui=self.c_tut},
{left=15, top=self.c_tut.h, ui=self.c_general},
{left=15+self.c_general.w, top=self.c_tut.h, ui=self.c_attack},
{left=15+self.c_general.w+self.c_attack.w, top=self.c_tut.h, ui=self.c_defence},
{left=0, top=self.c_tut.h + self.c_general.h, ui=self.vs},

{left=0, top=self.c_tut.h + self.c_general.h + 5 + self.vs.h, ui=self.c_desc},
}
self:setFocus(self.c_general)
self:setupUI()

self:switchTo("general")

self:updateKeys()
end

function _M:switchTo(kind)
self:drawDialog(kind, cs_player_dup)
if kind == "general" then self.c_attack.selected = false self.c_defence.selected = false
elseif kind == "attack" then self.c_general.selected = false self.c_defence.selected = false
elseif kind == "defence" then self.c_attack.selected = false self.c_general.selected = false
end
self:updateKeys()
end

function _M:updateKeys()
self.key:addCommands{
_TAB = function() self:tabTabs() end,
__TEXTINPUT = function(c)
if c == 'd' or c == 'D' then
self:dump()
end
end,
}

self.key:addBinds{
EXIT = function() cs_player_dup = game.player:clone() game:unregisterDialog(self) end,
}
end

function _M:tabTabs()
if self.c_general.selected == true then self.c_attack:select() elseif
self.c_attack.selected == true then self.c_defence:select() elseif
self.c_defence.selected == true then self.c_general:select() end
end

function _M:mouseTooltip(text, _, _, _, w, h, x, y)
self:mouseZones({
{ x=x, y=y+self.hoffset, w=w, h=h, fct=function(button) game.tooltip_x, game.tooltip_y = 1, 1; game.tooltip:displayAtMap(nil, nil, game.w, game.h, text) end},
}, true)
end

function _M:mouseZones(t, no_new)
-- Offset the x and y with the window position and window title
if not t.norestrict then
for i, z in ipairs(t) do
if not z.norestrict then
z.x = z.x + self.display_x + 5
z.y = z.y + self.display_y + 20 + 3
end
end
end

if not no_new then self.mouse = engine.Mouse.new() end
self.mouse:registerZones(t)
end

function _M:drawDialog(kind)
self.mouse:reset()

self:setupUI()

local player = self.actor
local s = self.c_desc.s

s:erase(0,0,0,0)

local h = 0
local w = 0

if kind == "general" then
h = 0
w = 0
s:drawStringBlended(self.font, "Name : "..(player.name or "Unnamed"), w, h, 255, 255, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "Role : "..(player.descriptor.role or player.type:capitalize()), w, h, 255, 255, 255, true) h = h + self.font_h

h = h + self.font_h -- Adds an empty row

-- Draw some text with an attatched tooltip
self:mouseTooltip([[#GOLD#A Tooltip!!#LAST#]], s:drawColorStringBlended(self.font, ("#c00000#Life: #00ff00#%d/%d"):format(player.life, player.max_life), w, h, 255, 255, 255, true)) h = h + self.font_h

h = 0
w = self.w * 0.25
-- start on second column

s:drawStringBlended(self.font, "STR : "..(player:getStr()), w, h, 0, 255, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "DEX : "..(player:getDex()), w, h, 255, 0, 255, true) h = h + self.font_h
s:drawStringBlended(self.font, "CON : "..(player:getCon()), w, h, 255, 255, 0, true) h = h + self.font_h

elseif kind=="attack" then
h = 0
w = 0

-- draw the attack tab here

elseif kind=="defence" then
h = 0
w = 0

-- draw the defence tab here

end

self.c_desc:generate()
self.changed = false
end

function _M:dump()
local player = self.actor

fs.mkdir("/character-dumps")
local file = "/character-dumps/"..(player.name:gsub("[^a-zA-Z0-9_-.]", "_")).."-"..os.date("%Y%m%d-%H%M%S")..".txt"
local fff = fs.open(file, "w")
local labelwidth = 17
local w1 = function(s) s = s or "" fff:write(s:removeColorCodes()) fff:write("\n") end
--prepare label and value
local makelabel = function(s,r) while s:len() < labelwidth do s = s.." " end return ("%s: %s"):format(s, r) end

w1(" [MyModule Character Dump]")
w1()

w1(("%-32s"):format(makelabel("Name", player.name)))
w1(("%-32s"):format(makelabel("Role", player.descriptor.role or player.type:capitalize())))

w1(("STR: %d"):format(player:getStr()))

w1(("DEX: %d"):format(player:getDex()))

w1(("CON: %d"):format(player:getCon()))

fff:close()

Dialog:simplePopup("Character dump complete", "File: "..fs.getRealPath(file))
end </pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

Dialogs

2013-09-29T14:58:18Z

BDota:

<h1 id="toc29">Dialogs - Customizing your UI experience</h1>

<h2 id="toc30">Drawing Dialogs</h2>
<p>The draw code for dialogs can be customized by overriding the drawDialog(s) function in your custom dialog class. The passed 's' represents the passed sdl surface. Always use this to draw. Though the Dialog class has a Dialog.surface property, it is the whole dialog surface including the borders and title. The passed s is just the internal surface of the dialog.</p>

<p>To draw text, 3 functions are provided on the surface for drawing of text:<br />

<table>
<tr>
<th>Function</th>
<th>Use</th>
</tr>
<tr>
<td>drawString</td>
<td>Draws uncolored strings.</td>
</tr>
<tr>
<td>drawColoredString</td>
<td>Draws colored strings.</td>
</tr>
<tr>
<td>drawColoredStringCentered</td>
<td>Draws centered colored strings.</td>
</tr>
</table>

</p>

<p>To illustrate, here is code from ToME's CharacterSheet.lua:</p>

<pre> local h = 0
local w = 0
s:drawString(self.font, "Sex: "..game.player.descriptor.sex, w, h, 0, 200, 255) h = h + self.font_h
s:drawString(self.font, "Race: "..game.player.descriptor.subrace, w, h, 0, 200, 255) h = h + self.font_h
s:drawString(self.font, "Class: "..game.player.descriptor.subclass, w, h, 0, 200, 255) h = h + self.font_h
h = h + self.font_h
s:drawColorString(self.font, "Level: #00ff00#"..game.player.level, w, h, 255, 255, 255) h = h + self.font_h
s:drawColorString(self.font, ("Exp: #00ff00#%2d%%"):format(100 * cur_exp / max_exp), w, h, 255, 255, 255) h = h + self.font_h
s:drawColorString(self.font, ("Gold: #00ff00#%0.2f"):format(game.player.money), w, h, 255, 255, 255) h = h + self.font_h </pre>

<p>The parameters for all 3 drawstring methods are identical, and are as follows:</p>

<table>
<tr>
<th>Parameter</th>
<th>Use</th>
</tr>
<tr>
<td>font</td>
<td>Font object. Unless you want to draw different parts of your dialog with different fonts, this will always be self.font (the dialog's set font).</td>
</tr>
<tr>
<td>v</td>
<td>Text. The ColorString variants recognise the replacement #xxxxxx#. This is a color code value, with 2 characters per r, g and b in hex(0-f). Lua text:format() method is advised to output numbers.</td>
</tr>
<tr>
<td>x</td>
<td>x position coordinate of text. Unless its a monospaced font, every character can potentially have a different width.</td>
</tr>
<tr>
<td>y</td>
<td>y position coordinate of text. self.font:lineSkip() can be used to get the font height.</td>
</tr>
<tr>
<td>r</td>
<td>Red color value of text. (0-255)</td>
</tr>
<tr>
<td>g</td>
<td>Green color value of text. (0-255)</td>
</tr>
<tr>
<td>b</td>
<td>Blue color value of text. (0-255)</td>
</tr>
</table>

<h2 id="toc31">Drawing Images</h2>
<p>To load an image the simpliest way is to do:<br />

<pre> local img = core.display.loadImage("/data/..../foo.png") </pre>

</p>

<p>Then you can draw it on an other surface with:<br />

<pre> dest:merge(img, x, y) </pre>

</p>

<p>You can also directly display a surface on screen:<br />

<pre> img:toScreen(x, y) </pre>

</p>

<p>If the surface wont change later you can make an opengl texture from it to speed up rendering:<br />

<pre> local tex = im:glTexture() </pre>

<br />
and display it:<br />

<pre> tex:toScreen(x, y, w, h) </pre>

<br />
You can actually update the texture if the surface changes (this is how dialogs work internally) this is faster than just drawing the surface.</p>

<h2 id="toc32">Player Display</h2>
<p>Player Displays is the quick summary of stats you get on the left side while playing. This is related to dialogs, but this class does not inherit from the dialog class.</p>

<p>ToME implements this by defining a display() function in the PlayerDisplay.lua class and calling it in game:display(), updating the surface whenever the player's changed property is true.</p>

<h2 id="toc33">Registering and Displaying Dialogs</h2>
<p>Displaying dialogs from code is simple:</p>

<pre> local d = CustomDialog.new()
game:registerDialog(d) </pre>

<p>To remove it(usually called from the dialog itself):</p>

<pre> game:unregisterDialog(self) </pre>

<p>This will set the dialog to open and display. If key or mousebindings are set for the dialog, these will also be made current. Note that dialogs do not automatically pause the game. In real-time games the action will continue, and even in turn-based games, animations and particles will continue in the background.</p>

<p>Most Dialogs will also need keyboard or mouse bindings. You use the following methods to define these in the dialog's init() function:</p>

<table>
<tr>
<th>Method</th>
<th>Purpose</th>
</tr>
<tr>
<td>keyCommands(KeyCommands, KeyBinds)</td>
<td>Sets keyboard keys recognised by this dialog. KeyCommands and KeyBinds are tables containing keyboard binding functions.</td>
</tr>
<tr>
<td>mouseZones(zones)</td>
<td>Sets a table of mouse zones recognised by the dialog. Note that the x and y coordinates are automatically offset by the dialog's extents.</td>
</tr>
</table>

<h3 id="toc34">Keyboard Input</h3>
<p>Manually setting keyCommands are strongly unadvised. Use keyBindings whenever possible, since these can be remapped by the user. There are however some exceptions:</p>

<table>
<tr>
<th>keyCommand</th>
<th>Effect</th>
</tr>
<tr>
<td>_ _DEFAULT</td>
<td>Matches any key press.</td>
</tr>
<tr>
<td>_ _TEXTINPUT</td>
<td>Used to receive alphanumeric text from keyboard.</td>
</tr>
</table>

<p>This example code is taken from ToME's DeathDialog.lua:</p>

<pre> self:keyCommands({
__TEXTINPUT = function(c)
if c == 'd' or c == 'D' then
self:dump()
end
end,
}, {
ACCEPT = "EXIT",
EXIT = function()
game:unregisterDialog(self)
end,
}) </pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Inventory Dialogs

2013-09-29T14:58:05Z

BDota:

<h1 id="toc0">Inventory and Equipment Dialogs</h1>
<p>This section assumes that objects and inventory has already been enabled by following the instructions in the [[Objects]] guide.</p>

<h2 id="toc1">Picking up and dropping items</h2>
<p>To start, lets add the ability to actually pickup and drop items.</p>

<p>First, in your Game.lua file, find the setupCommands() method. Inside this method add the following entry to the self.key:addBinds command:</p>

<pre> PICKUP_FLOOR = function()
if self.player.no_inventory_access then return end
self.player:playerPickup()
end,
DROP_FLOOR = function()
if self.player.no_inventory_access then return end
self.player:playerDrop()
end, </pre>

<p>This allows the pickup and drop commands to be mapped, which causes the player:playerPickup() or player:playerDrop() methods to execute. Now lets add these methods to the Player.lua file:</p>

<pre> function _M:playerPickup()
-- If 2 or more objects, display a pickup dialog, otherwise just picks up
if game.level.map:getObject(self.x, self.y, 2) then
local d d = self:showPickupFloor("Pickup", nil, function(o, item)
self:pickupFloor(item, true)
self.changed = true
d:used()
end)
else
self:pickupFloor(1, true)
self:sortInven()
self:useEnergy()
self.changed = true
end
end

function _M:playerDrop()
local inven = self:getInven(self.INVEN_INVEN)
local d d = self:showInventory("Drop object", inven, nil, function(o, item)
self:dropFloor(inven, item, true, true)
self:sortInven(inven)
self:useEnergy()
self.changed = true
return true
end)
end </pre>

<p>Now you can play and pick up and drop your items!</p>

<h2 id="toc2">Inventory and equipment Screen</h2>
<p>Now that you can pick up and drop items, you need to be able to obtain an inventory list and equip items.</p>

<p>First, as above, add the following to the key mappings in Game.lua:</p>

<pre> SHOW_INVENTORY = function()
if self.player.no_inventory_access then return end
local d
d = self.player:showEquipInven("Inventory", nil, function(o, inven, item, button, event)
if not o then return end
local ud = require("mod.dialogs.UseItemDialog").new(event == "button", self.player, o, item, inven, function(_, _, _, stop)
d:generate()
d:generateList()
if stop then self:unregisterDialog(d) end
end)
self:registerDialog(ud)
end)
end, </pre>

<p>Once done, you can try run the game and enjoy your new inventory listing. You may however notice that the game will crash if you try to actually use or equip anything in your inventory. This is because we have not yet defined the UseItemDialog.</p>

<p>In your module's Dialogs directory, create a new file file UseItemDialog.lua and paste the following:</p>

<pre> require "engine.class"
require "engine.ui.Dialog"
local List = require "engine.ui.List"
local Savefile = require "engine.Savefile"
local Map = require "engine.Map"

module(..., package.seeall, class.inherit(engine.ui.Dialog))

function _M:init(center_mouse, actor, object, item, inven, onuse)
self.actor = actor
self.object = object
self.inven = inven
self.item = item
self.onuse = onuse

self:generateList()
local name = object:getName()
local w = self.font_bold:size(name)
engine.ui.Dialog.init(self, name, 1, 1)

local list = List.new{width=math.max(w, self.max) + 10, nb_items=#self.list, list=self.list, fct=function(item) self:use(item) end}

self:loadUI{
{left=0, top=0, ui=list},
}
self:setupUI(true, true, function(w, h)
if center_mouse then
local mx, my = core.mouse.get()
self.force_x = mx - w / 2
self.force_y = my - (self.h - self.ih + list.fh / 3)
end
end)

self.key:addBinds{ EXIT = function() game:unregisterDialog(self) end, }
end

function _M:use(item)
if not item then return end
game:unregisterDialog(self)

local act = item.action

--if act == "use" then
--self.actor:playerUseItem(self.object, self.item, self.inven, self.onuse)
--self.onuse(self.inven, self.item, self.object, true)
--else
if act == "drop" then
self.actor:doDrop(self.inven, self.item, function() self.onuse(self.inven, self.item, self.object, false) end)
elseif act == "wear" then
self.actor:doWear(self.inven, self.item, self.object)
self.onuse(self.inven, self.item, self.object, false)
elseif act == "takeoff" then
self.actor:doTakeoff(self.inven, self.item, self.object)
self.onuse(self.inven, self.item, self.object, false)
end
end

function _M:generateList()
local list = {}

--if self.object:canUseObject() then list[#list+1] = {name="Use", action="use"} end
if self.inven == self.actor.INVEN_INVEN and self.object:wornInven() and self.actor:getInven(self.object:wornInven()) then list[#list+1] = {name="Wield/Wear", action="wear"} end
if self.inven ~= self.actor.INVEN_INVEN and self.object:wornInven() then list[#list+1] = {name="Take off", action="takeoff"} end
if self.inven == self.actor.INVEN_INVEN then list[#list+1] = {name="Drop", action="drop"} end

self.max = 0
self.maxh = 0
for i, v in ipairs(list) do
local w, h = self.font:size(v.name)
self.max = math.max(self.max, w)
self.maxh = self.maxh + self.font_h
end

self.list = list
end </pre>

<p>In your Player.lua class file paste the following two functions:</p>

<pre> function _M:doDrop(inven, item, on_done, nb)
if self.no_inventory_access then return end

if nb == nil or nb >= self:getInven(inven)[item]:getNumber() then
self:dropFloor(inven, item, true, true)
else
for i = 1, nb do self:dropFloor(inven, item, true) end
end
self:sortInven(inven)
self:useEnergy()
self.changed = true
if on_done then on_done() end
end

function _M:doWear(inven, item, o)
self:removeObject(inven, item, true)
local ro = self:wearObject(o, true, true)
if ro then
if type(ro) == "table" then self:addObject(inven, ro) end
elseif not ro then
self:addObject(inven, o)
end
self:sortInven()
self:useEnergy()
self.changed = true
end

function _M:doTakeoff(inven, item, o)
if self:takeoffObject(inven, item) then
self:addObject(self.INVEN_INVEN, o)
end
self:sortInven()
self:useEnergy()
self.changed = true
end </pre>

<p>You should now be able to drop items from within the inventory screen as well as equip and takeoff items.</p>

<h2 id="toc3">Consumable and activatable items</h2>
<p>Right now you can only "wear", "takeoff", "pickup" and "drop" items. This section deals with allowing objects to be "used".</p>

<p>First, return to the UseItemDialog.lua file in the dialogs directory and uncomment the commented lines in the use and generateList methods.</p>

<p>Next you need to add a new method to the object class to allow the code to check whether an object can be used. If you have not already, this will involve actually creating an objects class. Paste the following into the Object.lua class file:</p>

<pre> require "engine.class"
require "engine.Object"
require "engine.interface.ObjectActivable"

local Stats = require("engine.interface.ActorStats")
local Talents = require("engine.interface.ActorTalents")
local DamageType = require("engine.DamageType")

module(..., package.seeall, class.inherit(
engine.Object,
engine.interface.ObjectActivable,
engine.interface.ActorTalents
))

function _M:init(t, no_default)
t.encumber = t.encumber or 0

engine.Object.init(self, t, no_default)
engine.interface.ObjectActivable.init(self, t)
engine.interface.ActorTalents.init(self, t)
end

function _M:canAct()
if self.power_regen or self.use_talent then return true end
return false
end

function _M:act()
self:regenPower()
self:cooldownTalents()
self:useEnergy()
end

function _M:use(who, typ, inven, item)
inven = who:getInven(inven)

if self:wornInven() and not self.wielded and not self.use_no_wear then
game.logPlayer(who, "You must wear this object to use it!")
return
end

local types = {}
if self:canUseObject() then types[#types+1] = "use" end

if not typ and #types == 1 then typ = types[1] end

if typ == "use" then
local ret = {self:useObject(who, inven, item)}
if ret[1] then
if self.use_sound then game:playSoundNear(who, self.use_sound) end
who:useEnergy(game.energy_to_act * (inven.use_speed or 1))
end
return unpack(ret)
end
end </pre>

<p>You will also need to modify you Game.lua class: In the loaded function modify the Zone:setup call to also include your new Object class:</p>

<pre> Zone:setup{npc_class="mod.class.NPC", grid_class="mod.class.Grid", object_class="mod.class.Object"} </pre>

<p>Also add the following function to the Player.lua class:</p>

<pre> function _M:playerUseItem(object, item, inven)
local use_fct = function(o, inven, item)
if not o then return end
local co = coroutine.create(function()
self.changed = true

local ret = o:use(self, nil, inven, item) or {}
if not ret.used then return end
if ret.destroy then
if o.multicharge and o.multicharge > 1 then
o.multicharge = o.multicharge - 1
else
local _, del = self:removeObject(self:getInven(inven), item)
if del then
game.log("You have no more %s.", o:getName{no_count=true, do_color=true})
else
game.log("You have %s.", o:getName{do_color=true})
end
self:sortInven(self:getInven(inven))
end
end
end)
local ok, ret = coroutine.resume(co)
if not ok and ret then print(debug.traceback(co)) error(ret) end
return true
end

if object and item then return use_fct(object, inven, item) end

local titleupdator = self:getEncumberTitleUpdator("Use object")
self:showEquipInven(titleupdator(),
function(o)
return o:canUseObject()
end,
use_fct
)
end </pre>

<p>Congratulations, you now have usable items.</p>

<p>Now all you need to do is define your items usable.</p>

<p>For consumable objects like potions:</p>

<pre> use_simple = { name = "power name",
use = function(self,who)
<Code for power use here>
return {used = true, destroy = true}
end
}, </pre>

<p>For an object like a wand with limited charges:</p>

<pre> multicharge = <charges>,
use_simple = { name = "power name",
use = function(self,who)
<Code for power use here>
return {used = true, destroy = true}
end
}, </pre>

<p>For a magical object with regenerating power:</p>

<pre> max_power = <max power>,
power_regen = <power regained per turn>,
use_power = {name = "power name", power = <power use per charge>,
use = function(self, who)
<Code for power use here>
return true
end
}, </pre>

<p>For a magical object that activates a talent on use:</p>

<pre> max_power = <max power>,
power_regen = <power regained per turn>,
use_talent = {id = Talents.T_SOMETALENT, level = <level of talent>, power = <power use per charge> }, </pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Objects

2013-09-29T14:57:44Z

BDota:

<h1 id="toc0">Objects: Loot and Equipment</h1>

<h2 id="toc1">Editing the Example Module to use ActorInventory</h2>
<p>If your module will make use of objects and equipment, some changes are needed to the code since the example module does not by default use the ActorInventory class.</p>

<p>In your load.lua you should call at the top of the file <br />

<pre>local ActorInventory = require "engine.interface.ActorInventory"</pre>

<br />
You can then define slots through the command:<br />

<pre>ActorInventory:defineInventory("SLOT", "slot name", IS_WORN, "slot desc")</pre>

<br />
with SLOT being the slot's codeside identifier, "slot name" being the display name of the slot, IS_WORN being a boolean that determines if its a worn slot or a container slot and "slot_desc" is the description of the slot.</p>

<p>You will also then have to edit the module's /class/Actor.lua file.<br />
Add<br />

<pre>require "engine.interface.ActorInventory"</pre>

<br />
to the requires at the top of the file and add the engine.interface.ActorInventory to its inheritances:<br />

<pre>module(..., package.seeall, class.inherit(
engine.Actor,
engine.interface.ActorInventory, -- Add this line to whatever is already there!
engine.interface.ActorTemporaryEffects,
engine.interface.ActorLife,
engine.interface.ActorProject,
engine.interface.ActorLevel,
engine.interface.ActorStats,
engine.interface.ActorTalents,
engine.interface.ActorResource,
engine.interface.ActorFOV,
mod.class.interface.Combat
))</pre>

</p>

<p>THEN, in the _M:init(t, no_default) function add:<br />

<pre>engine.interface.ActorInventory.init(self, t)</pre>

</p>

<p>Now you need to tell the game what slots each specific Actor can use. Say you used the defineInventory function to add the "MAINHAND", "OFFHAND", "HEAD", and "BODY" slots to the game. You should put the following table into the birth descriptor for your player:<br />

<pre> body = { INVEN = 10, MAINHAND = 1, OFFHAND = 1, BODY = 1, HEAD = 1 },</pre>

<br />
Your player can know carry 10 items (the INVEN slots) and have one piece of equipment in each of the other slots. NPCs work the same way, by adding a body table to their [[NPCs]] newEntity definition. For example a headless horseman would use this code:<br />

<pre> body = { INVEN = 10, MAINHAND = 1, OFFHAND = 1, BODY = 1 },</pre>

<br />
Notice the missing HEAD slot, which tells the game that this NPC cannot use any equipment marked for the HEAD slot!</p>

<h2 id="toc2">Adding objects</h2>
<p>Now that the game has an inventory system implemented you can start making objects. For now let us put the objects into the "data/zones/dungeon/objects.lua" file. How about adding some weapons to the Example module? Let us start with a two-handed battleaxe:</p>

<pre>newEntity{
define_as = "BASE_BATTLEAXE",
slot = "MAINHAND",
slot_forbid = "OFFHAND",
type = "weapon", subtype="battleaxe",
display = "/", color=colors.SLATE,
encumber = 3,
rarity = 5,
combat = { sound = "actions/melee", sound_miss = "actions/melee_miss", },
name = "a generic battleaxe",
desc = [[t4modules massive two-handed battleaxes.]],
}

newEntity{ base = "BASE_BATTLEAXE",
name = "iron battleaxe",
level_range = {1, 10},
require = { stat = { str=11 }, },
cost = 5,
combat = {
dam = 10,
},
}</pre>

<p>There is a lot going on in there. First, notice we define a "BASE_BATTLEAXE" that specific types of battleaxes can inherit from. This stores things like which slots the battleaxe can be equipped in (this is what we set up above), which slots this will stop us from using, and some other properties like encumbrance, rarity and description. Second, we make a specific type of iron battleaxe that inherits using the "base" variable. The resulting entity will have all of the properties of the base entity except when there is an explicit conflict. An example of this is the "name" variable. The name variable from the iron battleaxe will overwrite the "a generic battleaxe" name from the base entity. Tables will not overwrite each other, instead they will merge. This can be seen in the "combat" variable, which in the iron battleaxe will be a table with the "sound" and "sound_miss" from the base class and the "dam" from the child class.</p>

<h2 id="toc3">Adding objects to a Zone</h2>
<p>The "objects.lua" file for the dungeon zone now has some objects in it, but we need to tell T-Engine how many objects to add to the zone and where to put them. This is handled by a generator, and we tell T-Engine which generator to use in the "zone.lua" file. If you open up zone.lua you see that there are already generator entries for the map and the actors:<br />

<pre> generator = {
map = {
class = "engine.generator.map.Roomer",
nb_rooms = 10,
rooms = {"simple", "pilar"},
lite_room_chance = 100,
['.'] = "FLOOR",
['#'] = "WALL",
up = "UP",
down = "DOWN",
door = "DOOR",
},
actor = {
class = "engine.generator.actor.Random",
nb_npc = {20, 30},
},
},</pre>

<br />
Well we need to add a generator for objects, too! This code will do the trick if added right after the actor = {...} line:<br />

<pre> object = {
class = "engine.generator.object.Random",
nb_object = {20, 30},
},</pre>

<br />
Now T-Engine will randomly generate and drop 20-30 objects. Give it a try!</p>

<p>The next step is to implement [[Inventory Dialogs]]</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/NPCs

2013-09-29T14:57:35Z

BDota:

<h1 id="toc0">Actors: NPCs and Monsters</h1>

<h2 id="toc1">Important NPC Definitions</h2>

Note that these are also used in the copy table in a player descriptor. These expand on the properties available to all entities, see [[Entities]].

<table class="wikitable">
<tr>
<th>Variable</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>Displayed NPC name.</td>
</tr>
<tr>
<td>short_name</td>
<td>NPC identifier. name is used if unset</td>
</tr>
<tr>
<td>desc</td>
<td>Optional description of NPC.</td>
</tr>
<tr>
<td>type</td>
<td>NPC Type (No known hardcoded types)</td>
</tr>
<tr>
<td>subtype</td>
<td>Better categorization for NPC.</td>
</tr>
<tr>
<td>display</td>
<td>Character that the NPC is displayed as in text mode.</td>
</tr>
<tr>
<td>faction</td>
<td>Actor faction. Defaults to "enemies".</td>
</tr>
<tr>
<td>ai</td>
<td>Selects which ai to use for NPC.</td>
</tr>
<tr>
<td>ai_state</td>
<td>(?) Depends on AI class.</td>
</tr>
<tr>
<td>rarity</td>
<td>How common this NPC is to generate. Higher is rarer. If not set will not ever generate.</td>
</tr>
<tr>
<td>level_range</td>
<td>Minimum and maximum levels for NPC. Read NPC Level Scaling below.</td>
</tr>
<tr>
<td>autolevel</td>
<td>Which leveling function to use to level up NPC. Read NPC Level Scaling below.</td>
</tr>
<tr>
<td>max_life</td>
<td>Max life at level 1.</td>
</tr>
<tr>
<td>energy.mod</td>
<td>Scales how much energy is gained per tick. Defaults to 1.</td>
</tr>
<tr>
<td>sight</td>
<td>Sight radius.</td>
</tr>
<tr>
<td>exp_mod</td>
<td>Scales how much exp is needed to reach a new level. Defaults to 1.</td>
</tr>
<tr>
<td>exp_worth</td>
<td>Indicator of Actor exp value. By default, exp for killing an Actor is its level times this value.</td>
</tr>
<tr>
<td>egos</td>
<td>See ego section in [[Entities]]</td>
</tr>
<tr>
<td>egos_chance</td>
<td>See ego section in [[Entities]]</td>
</tr>
</table>

These variables are not set in the definitions file, though they can be. They can be useful to access in code however.

<table class="wikitable">
<tr>
<th>Important runtime variables</th>
<th>Effect</th>
</tr>
<tr>
<td>energy.value</td>
<td>Current energy of this actor. Defaults to 0.</td>
</tr>
<tr>
<td>self.energy.used</td>
<td>Set to true if some energy was used this tick.</td>
</tr>
<tr>
<td>life</td>
<td>Current life. Defaults to max_life.</td>
</tr>
<tr>
<td>dead</td>
<td>true if entity is dead. Different from undead.</td>
</tr>
<tr>
<td>level</td>
<td>Current Actor level.</td>
</tr>
<tr>
<td>exp</td>
<td>Current experience.</td>
</tr>
<tr>
<td>max_level</td>
<td>Maximum level for the Actor.</td>
</tr>
</table>

The example module implements several other variables in its Actor class and Combat interface. These are not hardcoded, but can be used as a base or example for implementing your own module.

<table class="wikitable">
<tr>
<th>Variable</th>
<th>Effect</th>
</tr>
<tr>
<td>combat_armor</td>
<td>Removes this amount from damage taken.</td>
</tr>
<tr>
<td>combat.dam</td>
<td>This is added to strength to determine the damage done by attacks.</td>
</tr>
</table>

<h2 id="toc2">Actor class important methods</h2>

For more information, read the documentation.

<table class="wikitable">
<tr>
<th>Method</th>
<th>Purpose</th>
</tr>
<tr>
<td>act()</td>
<td>Code that gets executed every time the entity gets to act.</td>
</tr>
<tr>
<td>canSee(actor)</td>
<td>Test if the actor can see the target actor. This does not check LOS or such, only the actual ability to see it, such as influenced by stealth, invisibility or telepathy. Returns true or false and a number from 0 to 100 representing the 'chance' to be seen.</td>
</tr>
<tr>
<td>getTarget()</td>
<td>Gets the Actor target. Redefined by player and AI.</td>
</tr>
<tr>
<td>setTarget(target)</td>
<td>Sets the actor target. Redefined by player and AI.</td>
</tr>
<tr>
<td>move(x, y, force)</td>
<td style="text-align: left;">Do NOT manually set the actor's x and y values. Use this method instead. Set force to true to not test for the presence of other entities. Returns true if a move was attempted and energy should propably be used.</td>
</tr>
<tr>
<td>moveDir(dir)</td>
<td>Moves in a certain direction. Calls move() internally.</td>
</tr>
<tr>
<td>canMove(x, y, terrain_only)</td>
<td>Checks if the Actor can go there. if terrain_only is true it only checks terrain and ignores the presence of actors and other entities.</td>
</tr>
<tr>
<td>teleportRandom(x, y, dist, min_dist)</td>
<td>Teleports randomly to x,y. dist is the radius of the effect, min_dist is a minimum radius of the effect and defaults to 0. Set dist to 0 for precise teleport.</td>
</tr>
<tr>
<td>useEnergy(amount)</td>
<td>Amount of energy to subtract from the actor in energy based time systems. Often used in the act() method after taking an action that takes time.</td>
</tr>
<tr>
<td>reactionToward(target)</td>
<td>Uses factions to check for hostility. -100 is fully hostile, 0 is neutral and 100 is friendly.</td>
</tr>
<tr>
<td>addTemporaryValue(prop, v, noupdate)</td>
<td>Changes a property on the actor, but returns an id so the value change can be reversed with a call to removeTemporaryValue(). If noupdate is true the property is not actually changed.</td>
</tr>
<tr>
<td>removeTemporaryValue(prop, id, noupdate)</td>
<td>Reverses a previous call to addTemporaryValue(). Use its returned id to reverse its change.</td>
</tr>
<tr>
<td>onTemporaryValueChange(prop, sub, v)</td>
<td>Does nothing. Redefine to perform some action when temporary values are applied or removed.</td>
</tr>
<tr>
<td>attr(prop, v, fix)</td>
<td>Non-temporarily increases or decreases an actor property. Use this for compatibility with temporary values above. If fix is set the property is set to v, not increased or decreased. Commonly, attr(prop) alone is used to check for the existance of a property instead of modifying it.</td>
</tr>
<tr>
<td>isNear(x, y, radius)</td>
<td>Checks whether the actor is within a certain radius of the passed coordinate.</td>
</tr>
</table>

In addition, defining stats automatically creates a getStat() function. For example, defining the stat str creates a getStr() function for you.

<h2 id="toc3">NPC Egos</h2>

<h2 id="toc4">NPC Level Scaling</h2>
<p>Depending on the zone settings, the spawned creatures can actually level with the player. This requires a level_range variable to be properly set and a levelup() method in the Actor class.</p>

<p>The level_range variable defines the possible range the creature can be. The entity will always be leveled up to at least its minimum level in the level range. It will also never be leveled above that range either.</p>

<p>The leveling method should be defined in Actor.lua. In ToME this method adds to the life, stamina and mana of actors. Alternatively, you can create several, and use the autolevel variable to pick which to call.</p>

<p>All creatures are always generated at level 1, then leveled up to reach their required level. Keep this is mind when creating the NPC descriptor. Note also that you can create your own levelup() function in the NPC descriptor if a unique levelup method is needed.</p>

<p>See [[Dev-Zones]] for more info</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Zones

2013-09-29T14:57:25Z

BDota:

<h1 id="toc0">Zones: Your local adventurer hangouts</h1>
<p>Zones are description files for areas. The dungeon is a zone, the ice themed cave is a zone, the overland map is a zone, the town is a zone. They can be relatively simple or complex, and can be interconnected in various ways.</p>

<p>What a zone is to the module writer is a directory in the /data/zones folder with 5 files in it:</p>

<table>
<tr>
<th>File</th>
<th>Purpose</th>
</tr>
<tr>
<td>zone.lua</td>
<td>Zone description file</td>
</tr>
<tr>
<td>grids.lua</td>
<td>Description of the zone terrain</td>
</tr>
<tr>
<td>npcs.lua</td>
<td>NPCs that exist in the zone</td>
</tr>
<tr>
<td>objects.lua</td>
<td>Objects in the zone</td>
</tr>
<tr>
<td>traps.lua</td>
<td>Traps in the zone</td>
</tr>
</table>

<h2 id="toc1">Zone Description: zone.lua</h2>
<p>The zone name, as referred to by other files, is the same as the folder name that this file is in.</p>

<table>
<tr>
<th>Variable</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>Display name of this zone. May contain punctuation and spacing.</td>
</tr>
<tr>
<td>level_scheme</td>
<td>If "player", scale zone and NPC levels to match player level, if "fixed", do not scale NPC levels.</td>
</tr>
<tr>
<td>level_range</td>
<td>If level_scheme is "player", this limits the min and max that NPC levels can scale to.</td>
</tr>
<tr>
<td>max_level</td>
<td>Depth of a multi-level dungeon</td>
</tr>
<tr>
<td>actor_adjust_level</td>
<td>See below under "On level_scheme and level_range"</td>
</tr>
<tr>
<td>width</td>
<td>Width of levels. No effect if static level generated.</td>
</tr>
<tr>
<td>height</td>
<td>Height of levels. No effect if static level generated.</td>
</tr>
<tr>
<td>all_remembered</td>
<td>If true, level starts explored.</td>
</tr>
<tr>
<td>all_lited</td>
<td>If true, level starts lit.</td>
</tr>
<tr>
<td>persistant</td>
<td>If not set, randomizes the level again every time it is entered. If true it saves one level per file. If "zone" it saves all levels in a zone file. If "memory" it saves the level with the mail savefile.</td>
</tr>
<tr>
<td>generator</td>
<td>Defines the generators used for this zone, read below.</td>
</tr>
<tr>
<td>levels</td>
<td>Used to override zone defaults for single levels, such as to add a static boss level at lowest level of zone.</td>
</tr>
</table>

<h2 id="toc2">Generator</h2>
<p>There are four kinds of generators at the time of writing. You can only select one of each type per zone, though you can override this in the levels variable.</p>

<h3 id="toc3">map</h3>

*<h5 id="toc4">engine.generator.map.Cavern</h5>
**Generates a caven-like level. Used e.g. for Ardhungol in the tome module.

*<h5 id="toc5">engine.generator.map.Empty</h5>
**makes an empty level<br />

*<h5 id="toc6">engine.generator.map.Forest</h5>
**Generates a forest level with possible ponds of water. Used for the Trollshaws.<br />

*<h5 id="toc7">engine.generator.map.GOL</h5>
**GOL is game of life I should rename it

*<h5 id="toc8">engine.generator.map.Heightmap</h5>
**Heightmap is just a bad experiment;<br />

*<h5 id="toc9">engine.generator.map.Maze</h5>
**Maze makes well, a maze...like in .. the maze ;)

*<h5 id="toc10">engine.generator.map.Roomer</h5>
**Roomer is the standard dungeon builder

*<h5 id="toc11">engine.generator.map.Rooms</h5>
**yeah Rooms is badly named and half working

*<h5 id="toc12">engine.generator.map.Static</h5>
**Loads a map file from the data/maps/ folder. It is used e.g. for towns or special levels (the map is then fixed) or for placing special fixed rooms/structures in a random map (e.g. the last level of Amon-Sûl).

*<h5 id="toc13">engine.generator.map.TileSet</h5>
**TileSet splits the level in tiles of 3x3, 5x5, .. (customizable) each with a set of defined tiles possibilities and it randomly places them, matching existing ones. Examples are the ancient elven ruins, the moria, the first level of the lost merchant quest

*<h5 id="toc14">engine.generator.map.Town</h5>
**Generates a random town composed by L-shaped and rectangular buildings. Used e.g. for the Rak'shor Pride.

<h3 id="toc15">actor</h3>

*<h5 id="toc16">engine.generator.actor.Random</h5>

<h3 id="toc17">object</h3>

*<h5 id="toc18">engine.generator.object.Random</h5>

<h3 id="toc19">trap</h3>

*<h5 id="toc20">engine.generator.trap.Random</h5>

<h2 id="toc21">Additional file contents</h2>
<p>The files grids.lua, npcs.lua, objects.lua and traps.lua are used to load or define the features available in the zone.</p>

<p>At its simplest, a load() call to one of the files defined in the /data/general/ directory is used, but zone special features can also be defined here, such as ice tiles in a ice cave or a boss that appears only in that zone.</p>

<p>The reason for this is so you can have only orcs or trolls appear in your zone, with a forest tileset and only outdoor traps. This is also one of the main reasons for segmenting your definition files.</p>

<h2 id="toc22">Static maps</h2>

<h2 id="toc23">Travelling between zones</h2>

<h2 id="toc24">Word of DarkGod</h2>

<h3 id="toc25">On level_scheme and level_range</h3>
<p><> max_level is the "physical" depth<br />
<> and level_range is the range of levels allowed<br />
<> if the scheme is set to "fixed", or not set, then actors will only have their natural level<br />
<> if it is set to "player" then the zone calls game:getPlayer() to get a player, takes its level and uses it to select a level for the zone<br />
<> imagine:<br />
<> if you haev a zone with max_level = 5; level_range={10,20}<br />
<> then if a level 12 player enters, the zone "levels itself" to be level 12 for the first level and then one more per level<br />
<> basically it means that you can have zones that levelup with the player, as to provide a challenge even if the player is not at the exact right level<br />
<> actors are always created as level 1, then they are leveled up to theuir minimun level (their own level_range)<br />
<> then the zone force levelup to the selected level\<dg_> using the <br />
<> actor_adjust_level = function(zone, level, e) return zone.base_level + e:getRankLevelAdjust() + level.level-1 + rng.range(-1,2) end,<br />
<> field of the zone</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Entities

2013-09-29T14:57:14Z

BDota:

=Entities and Egos: Everything comes from here=

==Entity Definitions==
<p>These variables are valid for all entities, that is, grid, actors, objects, stores or traps.</p>

<table class="wikitable">
<tr>
<th>Variable</th>
<th>Default</th>
<th>Effect</th>
</tr>
<tr>
<td>display</td>
<td>'.'</td>
<td>Character to display in ASCII mode.</td>
</tr>
<tr>
<td>image</td>
<td>nil</td>
<td>Image to use as a tile.</td>
</tr>
<tr>
<td>color</td>
<td>0,0,0</td>
<td>Display color. No effect on images. A table of r,g,b. Sets color_r, color_g and color_b.</td>
</tr>
<tr>
<td>back_color</td>
<td>-1,-1,-1</td>
<td>Back display color. No effect on images. A table of r,g,b. Sets color_br, color_bg and color bb.</td>
</tr>
<tr>
<td>tint</td>
<td>1,1,1</td>
<td>Color to tint the display texture with. Has an effect on both image and ASCII displays. Sets tint_r, tint_g and tint_b.</td>
</tr>
<tr>
<td>unique</td>
<td>unset</td>
<td>If true, only one of these will ever be generated.</td>
</tr>
<tr>
<td>changed</td>
<td>unset</td>
<td>Gets set to true whenever an entity undergoes changes.</td>
</tr>
</table>

==Egos: Adding some variety==
<p>Egos are defined as 'special' versions of usually items that grant additional properties or effects to the user beyond the normal.</p>

<p>Egos are a very generic system in T-Engine. NPCs, objects, traps, grids or even stores can potentially have egos.</p>

<p>In the entity definitions, 3 ego-related variables are recognized:</p>

<table class="wikitable">
<tr>
<th>Property</th>
<th>Effect</th>
</tr>
<tr>
<td>egos</td>
<td>String pointing to a lua file containing ego definitions.</td>
</tr>
<tr>
<td>egos_chance</td>
<td>Number between 0 and 100 defining the chance of this entity being an ego entity.</td>
</tr>
<tr>
<td>force_ego</td>
<td>Forces the entity to be generated with the ego named by this variable.</td>
</tr>
</table>

<p>Egos are defined the same way as normal entities, in a newEntity{...} block. Unlike other entities though they do not have a base (unless the base is another ego). In addition, the following variables are recognized:</p>

<table class="wikitable">
<tr>
<th>Property</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>This is the suffix the ego will add to the base entity. If prefix is set to true, this is a prefix instead.</td>
</tr>
<tr>
<td>prefix</td>
<td>If true, the ego is a prefix instead of a suffix.</td>
</tr>
</table>

<p>This allows one ego to apply to a wide range of entities, such as a +strength ego apply to weapons and armor. It also makes silliness possible such as a 'sharpened troll'. Take care.</p>

===Ego Grids===
----
<p>Note that while its possible to have ego grids, the way the map works at the moment all grids that are the same are the same object. This means that the ego chance doesn't get evaluated per grid tile, it gets evaluated once per tile type for the whole level.</p>

<p>It may be possible and has been suggested to force every grid to be a unique object in future versions, but this is still not advised due to increased memory use and larger resulting save files.</p>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Talents

2013-09-29T14:57:04Z

BDota:

=Talents: Your special skills=

==Talent Definitions==

By default, Talent definitions are stored in the /data/talents.lua file. This file can include other files through the use of the Load(file) method.

Talent definitions require talent type definitions first. These are defined in newTalentType{...} blocks.

<table class="wikitable">
<tr>
<th>Important TalentType Variables</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>Display name of this talent type. REQUIRED.</td>
</tr>
<tr>
<td>type</td>
<td>Identifier of this talent type. REQUIRED.</td>
</tr>
<tr>
<td>description</td>
<td>String description of this talent type.</td>
</tr>
<tr>
<td>points</td>
<td>Maximum amount of points in this talent type.</td>
</tr>
</table>

Talent definitions are defined in newTalent{...} blocks.

<table class="wikitable">
<tr>
<th>Important Talent Variables</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>Displayed Talent name. REQUIRED.</td>
</tr>
<tr>
<td>short_name</td>
<td>Talent identifier. name is used if unset.</td>
</tr>
<tr>
<td>points</td>
<td>Maximum amount of points that can be put into the talent.</td>
</tr>
<tr>
<td>require</td>
<td>Requirements table for adding points. See the requirements definition below.</td>
</tr>
<tr>
<td>mode</td>
<td>Talent mode. One of either: "passive" - always on, "sustained" - can be turned on or off and "activated" - can be used. Default is "activated".</td>
</tr>
<tr>
<td>info</td>
<td>String description of the talent. REQUIRED.</td>
</tr>
<tr>
<td>type</td>
<td>Talent group. REQUIRED.</td>
</tr>
<tr>
<td>cooldown</td>
<td>Amount of turns to wait before a talent can be used again.</td>
</tr>
<tr>
<td>range</td>
<td>Range of talent. May be a number or function, but use getTalentRange(t) below as a getter in that case.</td>
</tr>
</table>

Identifiers for the talents are created by uppercasing the short_name (or name if no short_name is defined), replacing spaces with underscores ('_') and appending T_ in the front. These can then be accessed statically through [ActorTalents.*].

In this way the talent "Wind Walk" can be accessed by [ActorTalents.T_WIND_WALK].

Some talent variables require functions to be defined. These are of the form function(self, t), where self is the invoking actor and t is the talent being invoked.

<table class="wikitable">
<tr>
<th>Important Talent Functions</th>
<th>Use</th>
</tr>
<tr>
<td>action</td>
<td>"activated" mode talents only. Function that gets used when talent is activated.</td>
</tr>
<tr>
<td>activate</td>
<td>"sustained" mode talents only. Function that gets used when talent gets turned on.</td>
</tr>
<tr>
<td>deactivate</td>
<td>"sustained" mode talents only. Function that gets used when talent gets turned off.</td>
</tr>
<tr>
<td>on_learn</td>
<td>Function that gets used when talent is learned.</td>
</tr>
<tr>
<td>on_unlearn</td>
<td>Function that gets used when talent is unlearned.</td>
</tr>
</table>

In order to add stat, level or other talent requirements, a requirement table is required. These are the recognised variables.

<table class="wikitable">
<tr>
<th>Requirement Definition</th>
<th>Use</th>
</tr>
<tr>
<td>stat</td>
<td>Actor must have these stats at these levels.</td>
</tr>
<tr>
<td>level</td>
<td>Actor must be at least this level.</td>
</tr>
<tr>
<td>talent</td>
<td>Prerequisite talents.</td>
</tr>
</table>

For instance if a talent requires another talent and stats you can use:

<pre>require = { stat = { str = 10, dex = 10 }, talent = { Talents.T_STONE_SKIN }, },</pre>

If a talent requires that another talent NOT be taken you can use

<pre>require = { talent = { { Talents.T_STONE_SKIN, false }, }, },</pre>

==Talent Targeting==

Many activatable talents require some user targeting input. This is done through a coroutine. This is an example of the standard targeting and dealing damage case:

<pre>local tg = {type="bolt", range=self:getTalentRange(t), talent=t}
local x, y = self:getTarget(tg)
if not x or not y then return nil end
self:project(tg, x, y, DamageType.FIRE, 10, nil)</pre>

In this case, tg contains the targeting and damage settings. Possible variables are:

<table class="wikitable">
<tr>
<th>Targeting Settings</th>
<th>Effect</th>
</tr>
<tr>
<td>type</td>
<td>Targeting type. See below.</td>
</tr>
<tr>
<td>range</td>
<td>Range limit. Usually always self:getTalentRange(t).</td>
</tr>
<tr>
<td>talent</td>
<td>The talent being used.</td>
</tr>
<tr>
<td>friendlyfire</td>
<td>(?) Defaults to true.</td>
</tr>
<tr>
<td>no_restrict</td>
<td>Makes no restrictions regarding targeting</td>
</tr>
<tr>
<td>stop_block</td>
<td>Denotes that the projection will be blocked by entities that block move (bolts have this true by default)</td>
</tr>
<tr>
<td>radius</td>
<td>"ball" and "cone" targeting modes use this.</td>
</tr>
<tr>
<td>cone_angle</td>
<td>"cone" targeting mode uses this. Defaults to 55.</td>
</tr>
<tr>
<td>msg</td>
<td>Message to display during targeting.</td>
</tr>
</table>

The possible targeting modes are:

<table class="wikitable">
<tr>
<th>type</th>
<th>Effect</th>
</tr>
<tr>
<td>hit</td>
<td>Simple single target.</td>
</tr>
<tr>
<td>bolt</td>
<td>Hits first thing in path.</td>
</tr>
<tr>
<td>beam</td>
<td>Hits everything in path.</td>
</tr>
<tr>
<td>ball</td>
<td>Hits everything in a ball around the target.</td>
</tr>
<tr>
<td>cone</td>
<td>Hits everything in a cone in the direction.</td>
</tr>
</table>

getTarget(tg) is a method that is overriden by an AI for NPCs, or by the game module class.

Note that the last parameter of the project() method is the particle system to use.

==ActorTalents Class==

By default, Actors inherit from the ActorTalents class, even in the example module. This class provides an interface for manipulating and accessing talents. These are some of the valuable methods.

<table class="wikitable">
<tr>
<th>Useful Talent Related ActorTalents class methods</th>
<th>Use</th>
</tr>
<tr>
<td>useTalent(t)</td>
<td>Forces the Actor to use the talent.</td>
</tr>
<tr>
<td>useTalents()</td>
<td>Shows the use talent dialog.</td>
</tr>
<tr>
<td>knowTalent(t)</td>
<td>Returns true if the talent is known.</td>
</tr>
<tr>
<td>knowTalentType(tt)</td>
<td>Returns true if the talent group is known.</td>
</tr>
<tr>
<td>learnTalent(t, force, nb)</td>
<td>Has an Actor learn a talent. force prevents a canLearnTalent(t) test. nb is the amount of points to put into the talent.</td>
</tr>
<tr>
<td>unlearnTalent(t)</td>
<td>Makes the Actor forget the talent.</td>
</tr>
<tr>
<td>learnTalentType(tt, v)</td>
<td>Has the Actor learns a Talent Type. (v is true or false?)</td>
</tr>
<tr>
<td>unlearnTalentType(tt)</td>
<td>Has the Actor forget a Talent Type.</td>
</tr>
<tr>
<td>canLearnTalent(t)</td>
<td>Returns true if the Actor meets the requirements for the talent.</td>
</tr>
<tr>
<td>getTalentLevel(t)</td>
<td>Gets the amount of points in talent. 0 if unlearned.</td>
</tr>
<tr>
<td>isTalentCoolingDown(t)</td>
<td>Returns true if the specified talent is in the process of cooldown.</td>
</tr>
<tr>
<td>getTalentRange(t)</td>
<td>Returns the talent range. Use this instead of checking the range variable, since this allows the range variable to be either a function or a number.</td>
</tr>
<tr>
<td>cooldownTalents()</td>
<td>Cools down all talents by 1. This needs to be in your act() method.</td>
</tr>
</table>

All of the above methods can also be redefined in your own class if their functionality needs to be expanded. In addition, the following may also be useful to redefine:

<table class="wikitable">
<tr>
<th>Method</th>
<th>Use</th>
</tr>
<tr>
<td>preUseTalent(t)</td>
<td>Called before an actor uses a talent. Not returning true stops the talent from invoking.</td>
</tr>
<tr>
<td>postUseTalent(t)</td>
<td>Called after an actor uses a talent. Not returning true stops stops cooldown or sustained state from happening.</td>
</tr>
<tr>
<td>getTalentFullDescription(t)</td>
<td>Used in Dialogs. Overload to add more information such as mana use.</td>
</tr>
</table>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Player Descriptors

2013-09-29T14:56:53Z

BDota:

=Who do you want to be today?=

==Important variables==

<table>
<tr>
<th>Variable</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>Display name of this option in the selection menu. REQUIRED.</td>
</tr>
<tr>
<td>short_name</td>
<td>Identifier of this option. name is used if unset.</td>
</tr>
<tr>
<td>type</td>
<td>Defines which birth stage this descriptor belongs to. REQUIRED.</td>
</tr>
<tr>
<td>descriptor_choices</td>
<td>Selects which later descriptors are allowed or disallowed.</td>
</tr>
<tr>
<td>talents_types</td>
<td>Talent types learned at start of game</td>
</tr>
<tr>
<td>talents</td>
<td>List of starting learned talents.</td>
</tr>
<tr>
<td>desc</td>
<td>String that describes the descriptor. Appears in the selection menu. REQUIRED.</td>
</tr>
<tr>
<td>body</td>
<td>Initializes available slots. Requires ActorInventory defineInventory() calls in load.lua beforehand(?) which is NOT done in the example module.</td>
</tr>
<tr>
<td>copy</td>
<td>These variables and values will be copied to the resulting player object. See [[NPCs|NPCs]] for values.</td>
</tr>
<tr>
<td>experience</td>
<td>Experience rate. 1 being normal experience gain.</td>
</tr>
<tr>
<td>stats</td>
<td>Initial stats for character. Is added to default stat values.</td>
</tr>
</table>

<p>Important to note is that these variables do not overwrite, they add every time. If your race adds 2 strength, and your class adds 2 strength again you will end up with 4 strength. The exception to this is the copy variable. All elements in this will overwrite previous copy elements.</p>

<h2 id="toc2">Editing the Example Module for your own use</h2>
<p>At the time of writing, ToME has descriptors for world, race, subrace, sex, class and subclass. However, the example module only has a descriptor for role.</p>

<p>If you want to expand this and introduce your own descriptors for races and classes like ToME, or different descriptors entirely, you need to edit the following line in your /class/Game.lua file:</p>

<pre>local birth = Birther.new(self.player, {"base", "role" }, function()</pre>

<p>For comparison, ToME has this line:</p>

<pre>local birth = Birther.new(self.player, {"base", "world", "race", "subrace", "sex", "class", "subclass" }, function()</pre>

<p>Now you just need to create your own descriptors in the /data/birth/descriptors.lua file. If you want to organize your descriptors in multiple files for organization such as ToME does, remember to make a load call with your file path, such as the following ToME uses for its elf descriptor file.</p>

<pre>load("/data/birth/races/elf.lua")</pre>

==Leveling up==
<p>Once you gain enough xp to level, the levelup() method on the player gets called.<br />
Use this method to include specific special code that runs on a new level up, such as gaining hp and stats.</p>

<p>Note that if you make use of NPC level scaling, its important to define a levelup() on the Actor class as well. Since Player inherits from Actor, you can have the Player class call Actor's levelup() method through:</p>

<pre>mod.class.Actor.levelup(self)</pre>

==Guide==
<p>This guide is roughly based on the [[t4modules t3modules module_guide_part_1|te3 player descriptor guide]].</p>

<p>In the default ToME module, you get to choose from a race, a sub-race, gender, a background, a class, and then a subclass. To the T-Engine, these are all the same thing, called 'player descriptors' (Charcter descriptors would be more accurate, but that's nitpicking), or PDs for short. PDs are what let you alter the player character in all sorts of different ways. Player descriptors typically stack, so any modifications done to one will usually add with any other modifications, rather than replacing them.</p>

<p>There's no definition or distinction between different types of PDs by the engine. They can all have the same functionality, the only place any consistency is found is by the module author. So, if you only want stats to come from races, and skills from classes, you will have to make sure that only races gain stat bonuses and only classes have skill bonuses. The engine will not discriminate against this for you.</p>

<p>All the example below will be from the ToME module, so you should be able to see pretty easily where everything came from and can easily modify it and see what happens.</p>

<p>Possibly the most important PD is the one that the player will never see, the base descriptor, found in /data/birth/descriptors.lua. This is the one that is loaded for every character, and provides the universal traits that each character will share. This one has been edited slightly for clarity.</p>

<pre>newBirthDescriptor{
type = "base",
name = "base",
desc = {
},
talents = {},
experience = 1.0,
body = { INVEN = 1000, MAINHAND=1, OFFHAND=1, BODY=1, QUIVER=1 },

copy = {
-- Mages are unheard of at first, nobody but them regenerates mana
mana_rating = 6,
mana_regen = 0,

max_level = 50,
money = 10,
resolvers.equip{ id=true,
{type="lite", subtype="lite", name="brass lantern"},
},
resolvers.inventory{ id=true,
{type="potion", subtype="potion", name="potion of lesser healing", ego_chance=-1000},
{type="potion", subtype="potion", name="potion of lesser healing", ego_chance=-1000},
{type="potion", subtype="potion", name="potion of lesser healing", ego_chance=-1000},
{type="potion", subtype="potion", name="potion of cure poison", ego_chance=-1000},
{type="potion", subtype="potion", name="potion of cure poison", ego_chance=-1000},
},
resolvers.generic(function(e)
e.hotkey[9] = {"inventory", "potion of lesser healing"}
end),
},
}</pre>

<p>This defines out the body and inventory slots for each character, the base experience rate and starting gold and the minimum equipment each character will need to have.</p>

<p>The second PD applied by the ToME module is your race, followed by subrace, found appropriate in /data/birth/races/. Races are where ToME typically grants the charcter their most unique abilities and major stat adjustments. Below is the PD for elves, and then a subrace of elf.</p>

<pre>newBirthDescriptor{
type = "race",
name = "Elf",
desc = {
"Quendi are Elves, the first children of Eru.",
"The first Elves awoke by Cuiviénen, the Water of Awakening in the far east of Middle-earth, long Ages before the Rising of the Sun or Moon.",
"Unlike Men, the Elves are not subject to death by old age.",
},
descriptor_choices =
{
subrace =
{
Nandor = "allow",
Avari = "allow",
__ALL__ = "never",
},
},
talents = {
-- [ActorTalents.T_IMPROVED_MANA_I]=1,
},
copy = {
type = "humanoid", subtype="elf",
default_wilderness = {39, 17},
starting_zone = "tower-amon-sul",
starting_quest = "start-dunadan",
starting_intro = "elf",
},
experience = 1.05,
}

newBirthDescriptor
{
type = "subrace",
name = "Nandor",
desc = {
"Elves who turned aside from the Great Journey in the early days and settled in th east of the Misty Mountains.",
"Both the Wood-Elves of Mirkwood and the Elves of Lórien are Nandor.",
"They posses the Grace of the Eldar talent which allows them a boost of speed every once in a while.",
},
stats = { str=-2, mag=2, wil=3, cun=1, dex=1, con=0 },
experience = 1.3,
talents = { [ActorTalents.T_NANDOR_SPEED]=1 },
copy = {
life_rating = 9,
},
}</pre>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Engine Structure

2013-09-29T14:56:39Z

BDota:

=How it all fits together=

==Global Variables==
<p>These objects are global and are available from anywhere in the program:</p>

<table>
<tr>
<th>Object</th>
<th>Purpose</th>
</tr>
<tr>
<td>game</td>
<td>This is your game class, core of your game and allows access to pretty much any other object in the game.</td>
</tr>
<tr>
<td>world</td>
<td>This is your world class. By default this doesn't do much, but a custom world class allows persistance between new characters and savefiles. Think history, or bones files.</td>
</tr>
<tr>
<td>profile</td>
<td>This is the player profile.</td>
</tr>
</table>

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Directory Structure

2013-09-29T14:56:29Z

BDota:

=An Overview=
==Player Profiles==

When you run T-Engine or a module for the first time a player profile will be created. This contains your settings and keybindings, as well as module specific settings and achievements.

On linux this profile can be found in your home directory.

For Windows the profile folder will be called T-Engine. It will be located in the following locations.

Windows 7 - C:\Users\<username>\T-Engine
Windows XP - C:\Documents and Settings\<username>\T-Engine

Future plans involve moving the profile online, making it easier to compare, rank and show off individual accomplishments to friends. (As of April 2011, this appears to have been implemented.)

==T-Engine Root Directory==

In your T-Engine directory, the one where your executable is located, you will find a game directory. This directory contains all the Lua scripts used by the game and all its modules. The script is interpreted at runtime, so no recompilation is needed after modifying a file.

If you are writing a custom module you should avoid editing any file outside your module directory, since you will not be able to distribute those changes along with your module if you do.
modules directory

This directory is located in your game folder and contains every module currently available to T-Engine. Every module has its own folder and copying a module directory here is sufficient for it to be detected and appear on the list of available modules when starting a new game.

For all of these guides, the convention to refer to a filepath will use the game's module directory as its root. This is the folder that contains your init.lua file.

Note that the structure described here is only a convention used by ToME, but it is advised that third party module writers follow it for consistency. Few of these paths are hardcoded.

Directories and files not in the example module are underlined. Directories are boldface.

ToME uses many more than listed here, this is only intended to be a rough guide for structuring your own modules.

<table>
<tr>
<th>Directory or file</th>
<th>Purpose</th>
</tr>
<tr>
<td><strong>/</strong></td>
<td>Root Module directory</td>
</tr>
<tr>
<td>/init.lua</td>
<td>Description and basic information about the module.</td>
</tr>
<tr>
<td>/load.lua</td>
<td>This file loads all the basic code and definitions needed to run the module.</td>
</tr>
<tr>
<td><u>/resolvers.lua</u></td>
<td>Contains additional custom resolvers.</td>
</tr>
<tr>
<td><u><strong>/ai/</strong></u></td>
<td>Directory for custom AI definitions.</td>
</tr>
<tr>
<td><strong>/class/</strong></td>
<td>Directory for module custom class files. These usually extend the generic T-Engine classes of the same name and are used instead of them if they exist.</td>
</tr>
<tr>
<td>/class/Actor.lua</td>
<td>Both the player and all NPCs use this class.</td>
</tr>
<tr>
<td>/class/Game.lua</td>
<td>Handles game initialization, lower level code like keybindings and changing levels and displaying to screen.</td>
</tr>
<tr>
<td>/class/Grid.lua</td>
<td>Defines tooltips for grids and methods that handle what terrain blocks movement.</td>
</tr>
<tr>
<td>/class/NPC.lua</td>
<td>Handles non-player actors.</td>
</tr>
<tr>
<td><u>/class/Object.lua</u></td>
<td>Handles all objects in the game.</td>
</tr>
<tr>
<td>/class/Player.lua</td>
<td>Handles all player specific code that isn't generic to all Actors.</td>
</tr>
<tr>
<td><u>/class/PlayerDisplay.lua</u></td>
<td>Handles displaying the player's stats.</td>
</tr>
<tr>
<td><u>/class/Store.lua</u></td>
<td>Handles stores.</td>
</tr>
<tr>
<td><u>/class/Trap.lua</u></td>
<td>Handles traps.</td>
</tr>
<tr>
<td><u>/class/World.lua</u></td>
<td>Handles saving and Achievements.</td>
</tr>
<tr>
<td><u><strong>/class/generator/</strong></u></td>
<td>Directory for custom generators in zones.</td>
</tr>
<tr>
<td><strong>/class/interface/</strong></td>
<td>Directory for custom interfaces. These are inherited by other classes to help segment and seperate code and improve readability for complex classes.</td>
</tr>
<tr>
<td>/class/interface/Combat.lua</td>
<td>Module custom combat code is defined here.</td>
</tr>
<tr>
<td><strong>/data/</strong></td>
<td>Most of T-Engine is data-driven, not code-driven. This directory contains all the module custom definitions loaded to make your game unique.</td>
</tr>
<tr>
<td>/data/damage_types.lua</td>
<td>Defines the default damage projector and all the different damage types used in the module. (fire, water, acid, etc)</td>
</tr>
<tr>
<td>/data/talents.lua</td>
<td>Default talents file loaded by /init.lua. This file often Load()'s other talent files to improve readability.</td>
</tr>
<tr>
<td>/data/timed_effects.lua</td>
<td>Defines various timed effects available to the module.</td>
</tr>
<tr>
<td><u><strong>/data/achievements/</strong></u></td>
<td>Stores module achievements.</td>
</tr>
<tr>
<td><strong>/data/birth/</strong></td>
<td>Birth descriptors folder.</td>
</tr>
<tr>
<td>/data/birth/descriptors.lua</td>
<td>Default birth descriptors file. Often Load()'s other descriptor files to improve readability..</td>
</tr>
<tr>
<td><u><strong>/data/chats/</strong></u></td>
<td>Stores NPC chats for mobs that can speak.</td>
</tr>
<tr>
<td><strong>/data/general/</strong></td>
<td>Defines entities available to your module. Note that zones may define their own entities, such as bosses or special items, in the zone directories.</td>
</tr>
<tr>
<td><strong>/data/general/grids/</strong></td>
<td>Defines general grids (terrain).</td>
</tr>
<tr>
<td><strong>/data/general/npcs/</strong></td>
<td>Defines general NPCs.</td>
</tr>
<tr>
<td><u><strong>/data/general/objects/</strong></u></td>
<td>Defines general objects.</td>
</tr>
<tr>
<td><u><strong>/data/general/stores/</strong></u></td>
<td>Defines general stores.</td>
</tr>
<tr>
<td><u><strong>/data/general/traps/</strong></u></td>
<td>Defines general traps.</td>
</tr>
<tr>
<td><strong>/data/gfx/</strong></td>
<td>Special module image or particle assets.</td>
</tr>
<tr>
<td><strong>/data/gfx/particles/</strong></td>
<td>Particle script files.</td>
</tr>
<tr>
<td><u><strong>/data/maps/</strong></u></td>
<td>Static map definitions.</td>
</tr>
<tr>
<td><u><strong>/data/music/</strong></u></td>
<td>Module music.</td>
</tr>
<tr>
<td><u><strong>/data/quest/</strong></u></td>
<td>Module quests.</td>
</tr>
<tr>
<td><strong>/data/rooms/</strong></td>
<td>Special generators for rooms.</td>
</tr>
<tr>
<td><u><strong>/data/sound/</strong></u></td>
<td>Sound effects directory.</td>
</tr>
<tr>
<td><u><strong>/data/talents/</strong></u></td>
<td>Stores talent description files. These are Load()'ed by the /data/talents.lua file.</td>
</tr>
<tr>
<td><u><strong>/data/texts/</strong></u></td>
<td>Special non-quest or monster related texts. Used in ToME for introduction messages and new class unlock texts.</td>
</tr>
<tr>
<td><u><strong>/data/tilesets/</strong></u></td>
<td>Data folder for the map generator.</td>
</tr>
<tr>
<td><strong>/data/zones/</strong></td>
<td>Zones folder. Each zone has its own directory.</td>
</tr>
<tr>
<td>/data/ZONE/grids.lua</td>
<td>Zone load file for grids.</td>
</tr>
<tr>
<td>/data/ZONE/npcs.lua</td>
<td>Zone load file for npcs.</td>
</tr>
<tr>
<td>/data/ZONE/objects.lua</td>
<td>Zone load file for objects.</td>
</tr>
<tr>
<td>/data/ZONE/traps.lua</td>
<td>Zone load file for traps.</td>
</tr>
<tr>
<td>/data/ZONE/zone.lua</td>
<td>Zone description file.</td>
</tr>
<tr>
<td><strong>/dialogs/</strong></td>
<td>Contains module specific dialogs.</td>
</tr>
<tr>
<td>/dialogs/DeathDialog.lua</td>
<td>Dialog displayed on death.</td>
</tr>
<tr>
<td>/dialogs/Quit.lua</td>
<td>Dialog displayed when a quit is requested.</td>
</tr>
</table>

==Module team files==
The team files are renamed zip files. However, they have a different directory structure. The data folder remains the same and everything else is put in a mod folder.

Go back to [[T4 Modules Howto Guide]]

{{Module Guides}}

T4 Modules Howto Guide/Getting Started

2013-09-29T14:56:18Z

BDota:

<p>In order to start your own module, you need to create a new directory in the /game/modules/ directory, into which you copy the contents of either /game/modules/example/ or /game/modules/example_realtime/, which will give you bare-bones but working base to work off of.</p>

==init.lua==
<p>The first file you need to customize is the init.lua file. This file has a few things you need to edit to make this module your own:</p>

<table class="wikitable">
<tr>
<th>Setting</th>
<th>Effect</th>
</tr>
<tr>
<td>name</td>
<td>This is the official name of the module as seen in module selection list.</td>
</tr>
<tr>
<td>long_name</td>
<td>This is the long name of the module that appears is descriptions.</td>
</tr>
<tr>
<td>short_name</td>
<td>This is a short name used internal to the module. Preferred to be lower case and should be the same as the folder name.</td>
</tr>
<tr>
<td>author</td>
<td>Your name or pseudonym and email address.</td>
</tr>
<tr>
<td>homepage</td>
<td>Optional homepage of the module.</td>
</tr>
<tr>
<td>version</td>
<td>Module version. Does not automatically update. Change this between releases to differentiate them.</td>
</tr>
<tr>
<td>engine</td>
<td>Expected engine version.</td>
</tr>
<tr>
<td>description</td>
<td>A description of your module. Can be multiple lines and paragraphs.</td>
</tr>
<tr>
<td>starter</td>
<td>Only change if you know what you are doing. And if you have to ask, you don't.</td>
</tr>
<tr>
<td>show_only_on_cheat</td>
<td>If true, prevents this module from appearing in the mods list normally. This is enabled by default on the example module and should be disabled in your module.</td>
</tr>
<tr>
<td>no_get_name</td>
<td>Prevents the new character name dialog from showing up for your module. Use this if you set the character name yourself in your module.</td>
</tr>
<tr>
<td>allow_userchat</td>
<td>Registers 'space' as a key to talk, joins a channel named "module", and inits the chat system. If the game implements a game.logChat(str, ...) method it'll send chat listens to there.</td>
</tr>
<tr>
<td>background</td>
<td>A list of filenames (without the extension) of PNG images under the data/gfx/background directory to use as startup screen backgrounds</td>
</tr>
</table>

<h2 id="toc2">Launching your module using command line parameters</h2>
<p>By now you should be able to start t-engine normally and see your module in the list when you select new game. However, when changing features then quickly wanting to see its effects, this process involves a lot of unneeded clicks and wasted time. For this reason t-engine.exe supports various command line parameters.</p>

<table class="wikitable">
<tr>
<th>Parameter</th>
<th>Effect</th>
</tr>
<tr>
<td>-M<Module></td>
<td>Auto-loads the specified module (using the module's short_name).</td>
</tr>
<tr>
<td>-u<name></td>
<td>Uses the specified name for the character.</td>
</tr>
<tr>
<td>-n</td>
<td>Forces a new character, overwriting any old saves with the same name.</td>
</tr>
</table>

<p>To take advantage of this in windows, you need to right-click on t-engine.exe and select 'Create Shortcut'. On the created shortcut right-click again and select properties. In the dialog add the following to the Target field:</p>

<code>.../t-engine.exe -MMyModule -udefault -n</code>

<p>Replacing MyModule with your module name and default with whichever character name you desire. Using this shortcut now will launch your module directly, saving you some time while prototyping.</p>

Go back to [[T4 Modules Howto Guide]].

{{Module Guides}}

Category:Module Guides

2013-09-29T14:55:25Z

BDota: Created page with "How to guides for T-Engine 4."

[[T4 Modules Howto Guide|How to guides]] for T-Engine 4.

T4 Modules Howto Guide

2013-09-29T14:54:57Z

BDota:

How to start making a module for the T-Engine 4:
----
*[[Getting Started]]
*[[Directory Structure]]
*[[Engine Structure]]
*[[Player Descriptors]]
*[[T4 Modules Howto Guide/Talents|Talents]]
*[[Entities]]
*[[T4 Modules Howto Guide/Zones|Zones]]
*[[NPCs]]
*[[Objects]]
*[[Inventory Dialogs]]
*[[T4 Modules Howto Guide/Traps|Traps]] (not created)
*[[Dialogs]]
*[[Character Sheet Dialogs]]
*[[T4 Modules Howto Guide/Stores|Stores]] (not created)
*[[Factions]]
*[[T4 Modules Howto Guide/Quests|Quests]] (not created)
*[[Chats]]
*[[Colors]]
*[[Frame Buffers]]
*[[Developing a static map using the Tiled plugin]]
*[[T4 Modules Howto Guide/Resolvers|Resolvers]] (not created)
*[[Particle Effects]]
*[[Uploading a module]]

{{Module Guides}}

Template:Module Guides

2013-09-29T14:52:47Z

BDota: Created page with "<includeonly>Category:Module Guides</includeonly><noinclude> A placeholder for now. Will for navigating the guides eventually. Category:Templates</noinclude>"

<includeonly>[[Category:Module Guides]]</includeonly><noinclude>
A placeholder for now. Will for navigating the guides eventually.
[[Category:Templates]]</noinclude>

Startide

2013-09-20T19:42:40Z

BDota: Created page with "{{Module |name=Startide |developer=User:BDota| |version=0.0.1 |engine=1.0.4 |page=[http://te4.org/games/startide] |link=[http://forums.te4.org/viewtopic.php?f=40&t=38429] ..."

{{Module
|name=Startide
|developer=[[User:BDota|BDota]]
|version=0.0.1
|engine=1.0.4
|page=[http://te4.org/games/startide]
|link=[http://forums.te4.org/viewtopic.php?f=40&t=38429]
}}

A sci-fi module for T-Engine 4.

Template:Module

2013-09-20T19:39:04Z

BDota:

<div style="margin: 1.4em; margin-top:0; margin-right:0; padding: 0px; float: right; border:none;">
{|class="wikitable" style="border:none; margin:0; padding:0; text-align:left"
!colspan="2" style="font-size:larger;"|{{{name}}}
|-
! style="width:125px;" | Developer
| style="width:175px;" | {{{developer}}}
|-
! Current Version
| {{{version}}}
|-
! Engine Version
| {{{engine}}}
|-
! Module Page
| {{{page}}}
|-
! Forum Link
| {{{link}}}
|}
</div><includeonly>[[Category:Modules]]</includeonly><noinclude>[[Category:Templates]]</noinclude>

Template:Module

2013-09-20T19:32:05Z

BDota: Created page with "<div style="margin: 1.4em; margin-top:0; margin-right:0; padding: 0px; float: right; border:none;"> {|class="wikitable" style="border:none; margin:0; padding:0; text-align:lef..."

<div style="margin: 1.4em; margin-top:0; margin-right:0; padding: 0px; float: right; border:none;">
{|class="wikitable" style="border:none; margin:0; padding:0; text-align:left"
!colspan="2" style="font-size:larger;"|{{{name}}}
|-
! style="width:125px;" | Developer
| style="width:175px;" | {{{developer}}}
|-
! Current Version
| {{{version}}}
|-
! Engine Version
| {{{version}}}
|-
! Module Page
| {{{page}}}
|-
! Forum Link
| {{{link}}}
|}
</div><includeonly>[[Category:Modules]]</includeonly><noinclude>[[Category:Templates]]</noinclude>

Modules

2013-09-19T19:32:17Z

BDota:

Discuss modules released for [[T-Engine 4]], as well as their development, here.

Looking to write your own module? [[T4 Modules Howto Guide|check out the documents here for some help.]]

A list of some modules in developement
* [[Bone Builder]]
* [[Broken Bottle]]
* [[Iron and Steam]]
* [[Mosaic]]
* [[Qi Daozei]]
* [[RPG Engine for T-Engine]]
* [[Startide]]
* [[The Power of Dreams]]
* [[Veins of the Earth]]

[[Category:Modules]]

Modules

2013-09-19T19:24:52Z

BDota:

Discuss modules released for [[T-Engine 4]], as well as their development, here.

Looking to write your own module? [[T4 Modules Howto Guide|check out the documents here for some help.]]

A list of some modules in developement
* [[Bone Builder]]
* [[Broken Bottle]]
* [[Iron and Steam]]
* [[Mosaic]]
* [[RPG Engine for T-Engine]]
* [[Startide]]
* [[The Power of Dreams]]
* [[Veins of the Earth]]

[[Category:Modules]]

Category:Modules

2013-09-19T19:24:15Z

BDota: Created page with "Modules for T-Engine 4."

Modules for T-Engine 4.

Veins of the Earth

2013-09-19T19:24:00Z

BDota:

The Veins of the Earth is a module for T-Engine 4.0.1.

'''Updated''': 16 Sep 2013 (v.0.0.13 aka beta 2.8)

The standalone version (T-Engine + module) can be downloaded from https://github.com/Zireael07/The-Veins-of-the-Earth/releases. The ModDB site downloads come later due to their authorization process.

The game is a playable beta.

'''Contributors WANTED!''' The to-debug branch contains WIP code which isn't working properly for some reason. Any help debugging it is welcome!

Just fork the repo, make your changes and then make a pull request back. There's a list of issues (bugs and ideas) available on git, too.

Remember, do NOT include anything that's not OGL (i.e. no kuo-toa or illithids).

Anything that IS OGL - for example, SRD, Incursion, or the D&D Wiki portions marked as Open Game Content - is fine.

Any contributors will be credited in the Readme.

----

Features currently implemented include:
* brand-new start-up screen and menu [standalone version only]
* 8 classes: fighter, rogue, mage, ranger, cleric, barbarian, druid, warlock
* 2 prestige classes: shadowdancer, assasin
* 10 races: human, half-elf, elf, dwarf, half-orc; drow, duergar, deep gnomes
* a random name generator, taking into account your race and sex
* working ECL (Effective Character Level)
* multiclassing & prestige classes
* colored character sheet
* randomized unarmed and weapon damage; archery and weapon finesse
* attack roll & AC & critical hits & offhand attacks & iterative attacks
* saving throws [Seb]; now take the best of two stats (Dex-Int; Con-Str; Wis-Cha)
* hp, exp, dungeon level on-screen display
* inventory & encumbrance
* spellbook, an iconed hotbar for spells, some 0 and 1st level spells [Seb]
* armor spell failure chance; key stat must be 9 to cast spells
* attributes roller before character creation; now guarantees higher stats
* some monsters up to CR 1; CR displayed in tooltips; monsters drop equipment and corpses
* feat and skill select [Seb]
* skill checks and opposed checks, including armor check penalty and racial bonuses; more skill points at first character level
* skill tests printed to log; max skill ranks implemented
* most weapons from SRD; magic armors and shields; light sources; amulet of natural armor; cure x wounds potions [Seb]
* ranged weapons as starting equipment; deep-dwelling races no longer get a torch
* most melee & skill enhancing feats from SRD
* working Intuition skill and item identification
* colored in-game help screen; legend screen
* stairs have a chance of not changing the dungeon level [Seb]
* calendar
* colored tooltips; colored log messages
* item tooltips
* terrain effects
* speed bonuses

[[Category:Modules]]

God

2013-09-01T15:26:52Z

BDota: Created page with "Gods were powerful beings. Nearly all were killed by the Sher'Tul in the Godhunt, but some escaped. ==List of Gods== * Amakthel * Gerlyk * Quekorja * Ralkur"

Gods were powerful beings. Nearly all were killed by the Sher'Tul in the Godhunt, but some escaped.

==List of Gods==
* Amakthel
* Gerlyk
* Quekorja
* Ralkur

Ruins of Kor'Pul

2013-09-01T03:10:30Z

BDota: alternate zone info

{{Zone
|name=Ruins of Kor'Pul
|guardian=[[The Shade]], [[The Possessed]], [[Kor's Fury]]
|floors=3
|min_level=1
|max_level=5
|min_ilevel=1
|max_ilevel=4
|width=50
|height = 50
}}

==Zone Information==
The ruins of Kor'Pul are a first-tier zone in the northern region of [[Maj'Eyal]], between [[Derth]] and the mountain pass leading to the frozen north.

It has a "dungeon" layout, with darkened corridors connecting rooms that may be lit or dark. It is inhabited by rodents and weak undead.

Its boss is [[The Shade]], a spellcasting undead, who always appears in a special predefined room in the southern part of the third level.

In the alternate zone layout, The Shade has been killed by a gang of bandits but their leader was possessed.

Kor'Pul may have 4 kinds of [[vaults]]: circle, amon sul crypt, rat nest, and skeleton mage cabal.

After returning from the Far East, the [[backup guardian]] is [[Kor's Fury]], yet another undead. This guy just doesn't know when to quit.

The material level range is 1-2 (or 3-4 after returning from the Far East).

Trollmire

2013-09-01T02:54:11Z

BDota:

{{Zone
|name=Trollmire
|floors=3
|guardian=[[Prox the Mighty]], [[Bill]], [[Aluin the Fallen]], [[Shax the Slimy]]
|min_level=1
|max_level=5
|min_ilevel=1
|max_ilevel=4
|width=65
|height=40
}}

==Zone Information==
The Trollmire is a first-tier dungeon in the northern part of [[Maj'Eyal]], near [[Derth]]. It has a [[material]] level range of 1 to 2 (or 3 to 4 after returning from the Far East). The Trollmire is the starting zone for any race/class combination that doesn't have its own special starting zone.

The Trollmire is inhabited mostly by trolls and animals. It uses a dense forest layout, mostly trees with highly irregular, short, random paths and some clearings. Since beta 32, there is a road connecting the exits and leading to the boss's clearing.

The official boss is [[Prox the Mighty]], a troll; but Prox's boss is [[Bill]] (also a troll, and substantially tougher), whose treasure-filled dwelling is on the secret fourth level. (If you started in the Trollmire, and have only beaten Prox, you are probably level 4-5 and should postpone your chat with Bill, unless you want a seriously challenging fight.)

If you are playing the "alternate" Trollmire (which you can tell by a high level of water), the boss will be [[Shax the Slimy]].

After the returning from the Far East, the [[backup guardian]] is [[Aluin the Fallen]], a fallen [[Sun Paladin]].

The Trollmire can have 6 kinds of [[vaults]]: honey glade, ruined building 1 through 3, snake pit, and mage hideout.

Heart of the Gloom

2013-09-01T02:48:29Z

BDota: alternate zone info

{{Zone| name = Heart of the Gloom| floors = 3| guardian = [[The Withering Thing]], [[The Dreaming One]]| min_level = 1| max_level = 5| min_ilevel = 1| max_ilevel = 2| width = 50| height = 50}}

==Zone Information==
The Heart of the Gloom is a first-tier dungeon in the northern forest region of [[Maj'Eyal]], near [[Shatur]]. It has a forest layout with one large central clearing with paths leading to numerous smaller outlying clearings. It is fully lit.

The zone is inhabited by corrupted animals and plants; these have been given random [[Cursed]] and [[Doomed]] talents. The boss is [[The Withering Thing]], a corrupted wolf, who appears randomly on the third level.

The alternate zone layout has a dream theme, with [[The Dreaming One]] as the boss.

Category:Classes

2013-08-24T17:35:25Z

BDota:

ToME4 [[Classes]].

Category:Class Guides

2013-08-24T17:34:41Z

BDota:

Guides for ToME classes.

[[Category:Classes]]